Mode PionSelectionne créé (a minima)

lib/Attaque.py

@@ -2,6 +2,8 @@
 # -*- coding: utf-8 -*-
 import regles
 
+
+
 class Attaque():
     """attaque pre-parametree affectee a un pion, un personnage ou une creature"""
     def __init__(self):
@@ -10,27 +12,11 @@ class Attaque():
         self.attributs = regles.listeAttributsAttaques()
         self.notes = ""
 
-        #variables de fonctionnement
-        self._numPionCible = None
         self._coordCible = (-1, -1)
-        self._casesCibles = []
-
-        #items graphiques
-        self._itemLigne = None
-        self._itemCible = None
-
+##        self._itemCible = [] #cible du curseur: liste de pions et/ou cases
+        
     def activer(self, plateau):
         self.plateau = plateau
-        self.plateau.materialiserPions(False)
-
-    def desactiver(self):
-        pass
-
-    def effectuer(self):
-        pass
-
-    def annuler(self):
-        pass
 
     def majCoordCible(self, coord):
         """met a jour les coordonnees de la cible,
@@ -39,6 +25,30 @@ class Attaque():
             self._coordCible = coord
             self.maj()
 
+    def desactiver(self):
+        pass
+
+    def valider(self):
+        #envoyer signal
+        self.desactiver()
+
+    def estValide(self):
+        return True
+
+    #manipulation des items graphiques
+    def creerItemsGraphiques(self):
+        pass
+
+    def majItemsGraphiques(self):
+        pass    
+
+    def detruireItemsGraphiques(self):
+        pass
+
+    #affichage des cibles
+    def afficherCibles(self, actif):
+        pass
+    
 
 class Cac(Attaque):
     """attaque au corps a corps"""
@@ -61,7 +71,6 @@ class Cac(Attaque):
         return (self._coordCible in self.plateau.zone(self.plateau.pionSelectionne().position, self.portee, 0, False, True))
 
 
-
             
 class Distance(Attaque):
     """attaque a distance"""

lib/Modes.py

@@ -1,3 +1,5 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
 """les modes d'interaction permettent l'interaction
 entre l'interface (l'utilisateur) et le plateau de combat.
 Un seul mode ne peut etre actif a la fois
@@ -6,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 regles
 
 class ModeBase(object):
     """mode de base: tous les modes heritent de cette classe"""
@@ -114,6 +117,9 @@ class ModeBase(object):
     def toucheClavier(self, event):
         pass
 
+    def clicDroit(self, event):
+        pass
+
 
 class ModeBaseCp(ModeBase):
     """mode servant de base a tous les modes lies a la creation de plateau"""
@@ -121,6 +127,9 @@ class ModeBaseCp(ModeBase):
         super(ModeBaseCp, self).__init__(plateau)
         self.type = "cp"
 
+    def clicDroit(self, event):
+        self.plateau.activerMode(Modes.StandardCp)
+
 
 class ModeBasePi(ModeBase):
     """mode servant de base a tous les modes lies aux actions des combattants"""
@@ -128,6 +137,9 @@ class ModeBasePi(ModeBase):
         super(ModeBasePi, self).__init__(plateau)
         self.type = "pi"
 
+    def clicDroit(self, event):
+        self.plateau.activerMode(Modes.StandardPi)
+
 ### --------------------------------------- ####
 
 
@@ -204,11 +216,11 @@ class Pipette(ModeBaseCp):
         super(Pipette, self).activerCurseur()
         
     def clic_case(self, coord):
-        if len(case.terrain.nom) > 0:
-             param = case.terrain
+        if len(self.plateau.cases[coord].terrain.nom) > 0:
+             param = self.plateau.cases[coord].terrain
         else:
-             param = case.couleur
-        self.plateau.activerMode(Modes.CaseMaj, param)     
+             param = self.plateau.cases[coord].couleur
+        self.plateau.activerMode(MajCases, param)     
              
 
 class ZonePlacement(ModeBaseCp):
@@ -393,16 +405,123 @@ class StandardPi(ModeBasePi):
         self._focus = False
         self._activerDragMode = True
 
-    def clic_pion(self, num):
-        pass
-        #doit selectionner le pion
+    def clic_combattant(self, num):
+        self.plateau.activerMode(PionSelectionne, num)
+
+
+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
+
+    def pion(self):
+        """retourne la ref du pion actuellement selectionne"""
+        return self.plateau.combattants[self._num]
+
+    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.setText(QString.fromUtf8(self.pion().txtId()))
+        if len(self.pion().img.nomFichier) > 0:
+            pix = QPixmap(QString.fromUtf8("img\\"+self.pion().img.nomFichier))
+            pix = pix.scaled(44, 44, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+        else:
+            pix = QPixmap()
+        self.plateau.fenetre.ui.pi_img.setPixmap(QPixmap())    
+
+        ### 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.setText(QString.fromUtf8(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()  
 
+        super(PionSelectionne, self).activer()
+
+
+    def desactiver(self):
+        self.pion().afficheOmbreSelection(False)
 
+        #maj des infos dans le panneau pi
+        self.plateau.fenetre.ui.pi_img.setPixmap(QPixmap())  
+        self.plateau.fenetre.ui.pi_nom.setText(QString.fromUtf8("Pas de pion\nselectionné"))
 
+        #vide la liste des attributs
+        self.plateau.disconnect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.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()
 
+        super(PionSelectionne, self).desactiver()
 
 
 

lib/Plateau.py

@@ -484,10 +484,12 @@ class Plateau(QGraphicsScene):
     def plateauModeCreation(self):
         self.fenetre.majVisibilitePanneauxPlateau("creation")
         self.modePrincipal = "creation"
+        self.activerMode(Modes.StandardCp)
 
     def plateauModeCombat(self):
         self.fenetre.majVisibilitePanneauxPlateau("combat")
         self.modePrincipal = "combat"
+        self.activerMode(Modes.StandardPi)
 
     def activerMode(self, mode, param = None):
         """desactive le mode actif et active le nouveau a la place"""
@@ -675,46 +677,7 @@ class Plateau(QGraphicsScene):
                 self.curseurPinceau()
                 self.fenetre.ui.cbt_vue.setDragMode(0)
                 self.pinceau.majForme("rectP")
-                self.pinceau.verrouillerForme(True)      
-                
-            elif mode == "pionDecorCreation":
-                #curseur 'plus', on cree de nouveaux decors
-                self.modeParam["decor"] = None
-                self.fenetre.ui.cbt_vue.setDragMode(0)
-                
-                if param != None:
-                    if param.__class__.__name__ == "Decor":
-                         self.modeParam["decor"] = param
-                         self.proj.creer(param)
-
-            elif mode == "pionDecorSelectionne":
-                #un pion decor est selectionne
-                if param != None:
-                    self.modeParam["numPionSelectionne"] = param
-                    self.pionDecorSelectionne().afficheOmbreSelection(True)
-                    self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-                    self.proj.creer(self.pionDecorSelectionne())
-                
-            elif mode == "pionSupprimer":
-                #mode suppression de pions/pions decors
-                self.curseurGomme()
-                self.fenetre.ui.cbt_vue.setDragMode(0)
-
-            elif mode == "pionSelectionne":
-                #un pion est selectionne, on affiche les deplacements possibles
-                if param != None:
-                    self.modeParam["numPionSelectionne"] = param
-                    self.pionSelectionne().afficheOmbreSelection(True)
-                    self.numPionEnCours = param
-                    for i in range(0, self.fenetre.ui.inf_listeOrdreJeu.rowCount()):
-                        if str(self.fenetre.ui.inf_listeOrdreJeu.item(i, 0).text().toUtf8()) == str(param):
-                            self.fenetre.ui.inf_listeOrdreJeu.setCurrentCell(i,0)
-                    #bobby        
-                    self.majAffichagePionSelectionne()
-                    self.majListeAttributs()
-                    self.afficherNotesCombattant()
-                    self.majListeAttaques()
-                    self.majModeCombat("aucun")                  
+                self.pinceau.verrouillerForme(True)                    
 
 
         ##on reinitialise si necessaire    
@@ -722,12 +685,9 @@ class Plateau(QGraphicsScene):
             #mode standard : pas d'interaction avec les cases, on deplace le plateau en le saisissant ou les pions en cliquant dessus
             self.modeActif_old = "standard"
 
-            self.majAffichagePionSelectionne()
             self.majInfosPion()
             self.majInfosDecor()
-            self.majListeAttributs()
-            self.majListeAttaques()
-            self.afficherNotesCombattant()
+
 ##            self.fenetre.majVisibiliteBarreCombat("menu")
             QApplication.processEvents()
             self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
@@ -921,44 +881,44 @@ class Plateau(QGraphicsScene):
             self.ordreJeu[numCombattant] = 1
         self.majOrdreJeu()
         
-    def majListeAttributs(self):
-        """met a jour la liste des attributs dans le panneau de combat"""
-        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)
-        self.fenetre.ui.pi_listeAttributs.setVisible((self.pionSelectionne() != None))    
-        if self.pionSelectionne() != None:        
-            #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)
-            
+##    def majListeAttributs(self):
+##        """met a jour la liste des attributs dans le panneau de combat"""
+##        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)
+##        self.fenetre.ui.pi_listeAttributs.setVisible((self.pionSelectionne() != None))    
+##        if self.pionSelectionne() != None:        
+##            #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)
+##            
     def listeAttributCelluleModifiee(self, ligne, colonne):
         """une cellule de la liste des attributs a ete modifiee"""
         if colonne != 1:
@@ -1038,7 +998,6 @@ class Plateau(QGraphicsScene):
                     self.majModeCombat("combatAttaqueZone")
 
     def majInfosAttaqueEC(self):
-        #*aec
         """met a jour les infos de l'attaque en cours (selectionnee)"""
         selection = self.fenetre.ui.pi_listeAttaques.selectedItems()
         self.fenetre.ui.pi_panneauAttaqueEC.setVisible(self.pionSelectionne() != None and len(selection) > 0)
@@ -1102,11 +1061,11 @@ class Plateau(QGraphicsScene):
         else:
             pass
 
-    def afficherNotesCombattant(self):
-        """affiche les notes du pion selectionne dans le QTextEdit dedie"""
-        self.fenetre.ui.pi_notes.setVisible((self.pionSelectionne() != None))
-        if self.pionSelectionne() != None:
-            self.fenetre.ui.pi_notes.setText(QString.fromUtf8(self.pionSelectionne().notes))
+##    def afficherNotesCombattant(self):
+##        """affiche les notes du pion selectionne dans le QTextEdit dedie"""
+##        self.fenetre.ui.pi_notes.setVisible((self.pionSelectionne() != None))
+##        if self.pionSelectionne() != None:
+##            self.fenetre.ui.pi_notes.setText(QString.fromUtf8(self.pionSelectionne().notes))
             
     ###############
 
@@ -1406,20 +1365,20 @@ class Plateau(QGraphicsScene):
                       break
          return valide       
 
-    def validerAttaqueDist(self):
-        """on essaie de valider une attaque a distance vers un pion ou une case"""
-        if self.modeParam["pionCibleAttaqueDist"] != None:
-            msg = "{} attaque a distance le pion {}".format(self.pionSelectionne().txtId(),
-                                                              self.modeParam["pionCibleAttaqueDist"].txtId())
-            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"], self.modeParam["pionCibleAttaqueDist"].z)
-        else:
-            msg = "{} attaque a distance la case {}".format(self.pionSelectionne().txtId(), 
-                                                              self.modeParam["cibleAttaqueDist"])
-            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"])
-        if not valide:
-            msg += " [INVALIDE]"
-        print(msg)
-        self.majModeCombat("aucun")
+##    def validerAttaqueDist(self):
+##        """on essaie de valider une attaque a distance vers un pion ou une case"""
+##        if self.modeParam["pionCibleAttaqueDist"] != None:
+##            msg = "{} attaque a distance le pion {}".format(self.pionSelectionne().txtId(),
+##                                                              self.modeParam["pionCibleAttaqueDist"].txtId())
+##            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"], self.modeParam["pionCibleAttaqueDist"].z)
+##        else:
+##            msg = "{} attaque a distance la case {}".format(self.pionSelectionne().txtId(), 
+##                                                              self.modeParam["cibleAttaqueDist"])
+##            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"])
+##        if not valide:
+##            msg += " [INVALIDE]"
+##        print(msg)
+##        self.majModeCombat("aucun")
 
 ##    def rectEllipseCirculaire(self, centre, rayon):
 ##        """renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param
@@ -1646,6 +1605,7 @@ class Plateau(QGraphicsScene):
                         if coord != self.pionSelectionne().position:
                             self.pionDeposer(coord)
                             accepte = True
+                            
                 elif self.modeCombat == "combatAttaqueCaC":
                     if self.modeParam["cibleAttaqueCaC"] in self.modeParam["zoneAttaqueCaC"]:
                         print("{} attaque {} au corps a corps".format(self.pionSelectionne().nom, self.modeParam["cibleAttaqueCaC"]))
@@ -1680,6 +1640,7 @@ class Plateau(QGraphicsScene):
             
         elif self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatAttaqueDist" and self.modeParam["cibleAttaqueDist"] != (case.x, case.y):
             self.majLigneMireAttaqueDist((case.x,case.y))
+            
         elif self.modeActif_old == "pionSelectionne" and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueZone":
             if case.centreGraphique != self.modeParam["point2AttaqueZone"]:
                 self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False)
@@ -1713,18 +1674,14 @@ class Plateau(QGraphicsScene):
     def pionClique(self, num):
         """on a clique sur ce pion"""
         if num < 10000:
-            pion = self.combattants[num]
             self.modeActif.clic_combattant(num)
-
             
             accepte = False
             if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":    
                 self.validerAttaqueDist()
                 accepte = True
 
-                
         else:
-            pion = self.decors[num]
             self.modeActif.clic_decor(num)
         
         if self.modeActif.nom() == "Standard":