Fin de la restructuration en Modes et en Actions

lib/Actions.py

@@ -12,15 +12,19 @@ class Action(object):
         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)
+        self._sourceCurseur = ""
+        self._nomBouton = ""     
 
     def activer(self, plateau, numPion):
         self.plateau = plateau
         self._num = numPion
+        self.activerCurseur()
         self.creerItemsGraphiques()
 
     def majCoordCible(self, coord):
         """met a jour les coordonnees de la cible,
             cad la case actuellement survolee par la souris"""
+        self.enfoncerBouton(True)
         if self.plateau.coordonneesValides(coord):
             self._coordCible = coord
             self.maj()
@@ -28,6 +32,8 @@ class Action(object):
     def desactiver(self):
         self.afficherCibles(False)
         self.detruireItemsGraphiques()
+        self.desactiverCurseur()
+        self.enfoncerBouton(False)
 
     def valider(self):
         #envoyer signal
@@ -46,6 +52,21 @@ class Action(object):
     def coordActeur(self):
         return self.acteur().position
 
+    def activerCurseur(self):
+        if len(self._sourceCurseur) > 0:
+            curseurPix = QPixmap(self._sourceCurseur)
+            if not curseurPix.isNull():
+                curseur = QCursor(curseurPix, 0, curseurPix.height())
+                self.plateau.fenetre.ui.cbt_vue.setCursor(curseur)   
+
+    def desactiverCurseur(self):
+        self.plateau.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
+
+    def enfoncerBouton(self, actif):
+        for bouton in self.plateau.fenetre.ui.pi_actions.findChildren(QToolButton):
+            if bouton.objectName() == self._nomBouton:
+                bouton.setChecked(actif)
+
     #manipulation des items graphiques
     def creerItemsGraphiques(self):
         pass
@@ -56,9 +77,6 @@ class Action(object):
     def detruireItemsGraphiques(self):
         pass
 
-    def activerCurseur(self):
-        pass
-
     #affichage des cibles
     def afficherCibles(self, actif):
         pass
@@ -80,6 +98,8 @@ class Deplacement(Action):
         self._chercheurChemin = None
         self._cout = 0     #cout en points de dep
         self.cible_aConfirmer = None
+        self._sourceCurseur = ""
+        self._nomBouton = "pi_deplacement" 
 
     def activer(self, plateau, numPion):
         super(Deplacement, self).activer(plateau, numPion)
@@ -97,7 +117,7 @@ class Deplacement(Action):
             self.cible_aConfirmer = self._coordCible
             self.creerChemin()
         else:
-            if self.estValide():
+            if self.estValide() and self.plateau.proj.projectionValide():
                 self.acteur().majPosition(self.plateau.proj.coord(), self.plateau.proj.nbRotations())
                 super(Deplacement, self).valider()
 
@@ -137,7 +157,6 @@ class Deplacement(Action):
     def envoiSignal(self):
         cout = self._chemin[-1][1]  #cout de deplacement retenu pour la derniere case
         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"""
@@ -154,6 +173,8 @@ class Cac(Attaque):
         super(Cac, self).__init__()
         self.nom = "Attaque au corps-à-corps"
         self._pionCible = None
+        self._sourceCurseur = ""
+        self._nomBouton = "pi_attaqueCac" 
 
     def desactiver(self):
         self.afficherCibles(False)
@@ -189,6 +210,8 @@ class Distance(Attaque):
         self.nom = "Attaque à distance"
         self._itemLigne = None
         self._pionCible = None
+        self._sourceCurseur = ""
+        self._nomBouton = "pi_attaqueDist" 
 
     def majCoordCible(self, coord):
         if self._pionCible:
@@ -255,6 +278,8 @@ class Zone(Attaque):
         self._itemLigne = None
         self._itemCible = None
         self._casesCibles = []
+        self._sourceCurseur = ""
+        self._nomBouton = "pi_attaqueZone" 
 
     def valider(self):
         if self.estValide() and len(self._casesCibles) > 0:

lib/Modes.py

@@ -48,8 +48,8 @@ class ModeBase(object):
         self.plateau.fenetre.ui.cbt_vue.setDragMode(self._activerDragMode)
         curseurPix = QPixmap(self._sourceCurseur)
         if not curseurPix.isNull():
-            curseurPinceau = QCursor(curseurPix, 0, curseurPix.height())
-            self.plateau.fenetre.ui.cbt_vue.setCursor(curseurPinceau)   
+            curseur = QCursor(curseurPix, 0, curseurPix.height())
+            self.plateau.fenetre.ui.cbt_vue.setCursor(curseur)   
 
     def desactiverCurseur(self):
         self.plateau.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
@@ -152,10 +152,12 @@ class StandardCp(ModeBaseCp):
         self._focus = False
         self._activerDragMode = True
 
-    def clic_pion(self, num):
-        pass
-        #doit selectionner le pion
-
+    def clic_combattant(self, num):
+        self.plateau.activerMode(DeplacementPion, num)
+        
+    def clic_decor(self, num):
+        self.plateau.activerMode(DeplacementPion, num)
+        
 class MajCases(ModeBaseCp):
     """mode de mise a jour des cases (terrain, couleur, effet special)"""
     def __init__(self, plateau):
@@ -452,7 +454,7 @@ class PionSelectionne(ModeBasePi):
     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)
@@ -462,10 +464,12 @@ class PionSelectionne(ModeBasePi):
             self._action.valider()        
            
     def clicDroit(self, event):
-        if self._action:
+        if self._action != None:
             self._action.desactiver()
             self._action = None
+            print "cd ps 1"
         else:
+            print "cd ps 2"
             super(PionSelectionne, self).clicDroit(event)
 
     def toucheClavier(self, event):

lib/Plateau.py

@@ -703,29 +703,18 @@ class Plateau(QGraphicsScene):
     def majModeCombatDeplacement(self):
         """active le mode de combat 'deplacement' (mode standard)"""
         self.modeActif.nouvelleAction(Actions.Deplacement)
-##        self.majModeCombat("combatDeplacement")
 
     def majModeCombatAttaqueCaC(self):
         """active le mode de combat 'corps-a-corps'"""
         self.modeActif.nouvelleAction(Actions.Cac)
-##        self.majModeCombat("combatAttaqueCaC")
 
     def majModeCombatAttaqueDist(self):
         """active le mode de combat 'attaque a distance'"""
         self.modeActif.nouvelleAction(Actions.Distance)
-##        self.majModeCombat("combatAttaqueDist")
 
     def majModeCombatZone(self):
         if not len(self.modeParam["typeAttaqueZone"]) > 0: self.modeParam["typeAttaqueZone"] = "ligne"
-        self.modeActif.nouvelleAction(Actions.Ligne)
-##        self.majModeCombat("combatAttaqueZone")        
-
-    def majModeCombatZoneForme(self):
-        pass
-##        if self.modeCombat == "combatAttaqueZone":
-##            origine = self.sender().objectName()
-##            self.modeParam["typeAttaqueZone"] = str(origine).split("_")[1]
-##            self.majModeCombat("combatAttaqueZone")
+        self.modeActif.nouvelleAction(Actions.Ligne)      
 
     def majModeDefinirEntree(self):
         entree = EntreeSortie(self, "E")
@@ -738,125 +727,7 @@ class Plateau(QGraphicsScene):
     def majModeZonePlacement(self):
         self.activerMode(Modes.ZonePlacement)
     
-    def majMode(self, mode = "standard", param = None):
-        """modifie ou reinitialise le type d'interaction avec le plateau"""   
-        reinit = True    #doit-on reinitialiser a la fin de l'operation
-        ##on desactive le mode precedent
-        if self.pionSelectionne() != None:
-            self.pionSelectionne().afficheOmbreSelection(False)
-            if self.modeActif_old == "pionSelectionne":    
-                 self.majModeCombat("")   
-            self.modeParam["numPionSelectionne"] = 0
-        elif self.pionDecorSelectionne() != None:
-            self.pionDecorSelectionne().afficheOmbreSelection(False)
-            self.modeParam["numPionSelectionne"] = 0
-
-        if self.modeActif_old == "pionSelectionne" or self.modeActif_old == "pionDecorSelectionne":  
-            self.proj.desactiver()
-                
-        if self.modeActif_old == "cachePlacer":
-            self.pinceau.reinit()
-   
-        ### definition du nouveau mode
-        if mode != "standard":
-            self.modeActif_old = mode
-            reinit = False
-            if mode == "caseMajEffet":
-                #on met a jour l'effet actif sur les cases
-                if param != None:
-                    self.curseurPinceau()
-                    self.fenetre.ui.cbt_vue.setDragMode(0)
-                    self.modeParam["effet"] = param                
-
-            elif mode == "caseMajAltitude":
-                self.curseurPinceau()
-                self.fenetre.ui.cbt_vue.setDragMode(0)                           
-
-            elif mode == "cachePlacer":
-                self.curseurPinceau()
-                self.fenetre.ui.cbt_vue.setDragMode(0)
-                self.pinceau.majForme("rectP")
-                self.pinceau.verrouillerForme(True)                    
-
-
-        ##on reinitialise si necessaire    
-        if reinit:
-            #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.majInfosPion()
-            self.majInfosDecor()
-
-##            self.fenetre.majVisibiliteBarreCombat("menu")
-            QApplication.processEvents()
-            self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-            self.fenetre.ui.cbt_vue.setDragMode(1)
-        else:
-            self.fenetre.ui.cbt_vue.setFocus()
-
-    def majModeCombat(self, mode = ""):
-        """met a jour le mode de combat actif pour le pion selectionne"""
-        ## on desactive le mode precedent si besoin
-        #la projection de position
-        
-        if self.modeCombat == "combatDeplacement":
-            #le champ de deplacement
-            if self.modePrincipal == "combat":
-                self.afficherChampDeplacement(False)
-            self.proj.desactiver()
-                
-        elif self.modeCombat == "combatAttaqueCaC":        
-            #la zone d'attaque au cac
-            self.materialiserPions(True)
-            self.majZoneAttaqueCaC(False)
-            self.modeParam["zoneAttaqueCaC"] = []
-            if self.modeParam["cibleAttaqueCaC"] != None:
-                self.modeParam["cibleAttaqueCaC"].estCibleAttaque(False)
-                self.modeParam["cibleAttaqueCaC"] = None
-                
-        elif self.modeCombat == "combatAttaqueDist":
-            self.materialiserPions(True)
-            self.majLigneMireAttaqueDist()
-            
-        elif self.modeCombat == "combatAttaqueZone":  
-            #l'attaque de zone
-            self.materialiserPions(True)
-            QApplication.processEvents()
-            self.reinitAttaqueZone()
-##            if mode != "combatAttaqueZone": self.fenetre.majVisibiliteBarreCombat("menu")
-            self.modeParam["listeCasesAttaqueZone"] = []
-
-        ## definition du nouveau mode de combat
-        if self.pionSelectionne() != None:
-            self.modeCombat = mode
-            self.fenetre.ui.cbt_vue.setDragMode(0)
-            if mode == "aucun":
-                self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-            
-            if mode == "combatDeplacement":
-                self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-                self.proj.creer(self.pionSelectionne())
 
-                if self.modePrincipal == "combat":
-                    #si mode combat, affichage de la zone de deplacement
-                    self.afficherChampDeplacement(True)
-                         
-            elif mode == "combatAttaqueCaC":
-                self.curseurEpee()
-                self.materialiserPions(False)
-##                self.modeParam["zoneAttaqueCaC"] = self.zone(self.pionSelectionne().position, self.pionSelectionne().allonge, True, True)
-                self.modeParam["zoneAttaqueCaC"] = self.zone(self.pionSelectionne().position, 1, True, True)
-                self.majZoneAttaqueCaC(True)
-                
-            elif mode == "combatAttaqueDist":
-                self.curseurArc()
-                self.materialiserPions(False)
-
-            elif mode == "combatAttaqueZone":
-                self.curseurBaguette()
-                self.materialiserPions(False)
-                self.majFormeAttaqueZone()
-            
     ###############
 
     ########## Gestion du combat ##############
@@ -864,23 +735,8 @@ class Plateau(QGraphicsScene):
         """met a jour l'affichage du tour en cours"""
         self.fenetre.ui.cbt_tour.majTexte("Tour: {}".format(self.tour))
 
-    def majAffichagePionSelectionne(self):
-        """affiche le nom et le logo du pion actuellement selectionne"""
-        if self.pionSelectionne() != None:
-            self.fenetre.ui.pi_nom.majTexte(self.pionSelectionne().txtId())
-            if len(self.pionSelectionne().img.nomFichier) > 0:
-                pix = QPixmap(QString.fromUtf8("img\\"+self.pionSelectionne().img.nomFichier))
-                pix = pix.scaled(44, 44, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-                self.fenetre.ui.pi_img.setPixmap(pix)
-            else:    
-                self.fenetre.ui.pi_img.setPixmap(QPixmap())    
-        else:
-            self.fenetre.ui.pi_img.setPixmap(QPixmap())  
-            self.fenetre.ui.pi_nom.majTexte("Pas de pion\nselectionné")
-
     def initListeOrdreJeu(self):
         """cree les colonnes et met en forme la table ordre jeu"""
-##        self.fenetre.ui.infoOrdreJeu.setColumnWidth(0, 20)
         self.fenetre.ui.inf_listeOrdreJeu.setColumnWidth(2, 30)
         self.fenetre.ui.inf_listeOrdreJeu.hideColumn(0)
         self.fenetre.ui.inf_listeOrdreJeu.hideColumn(2)      
@@ -934,7 +790,6 @@ class Plateau(QGraphicsScene):
         self.pionSaisir(numCombattant)        
  
     def afficheEcranGestionCombat(self):
-        #*egc
         """affiche l'ecran de gestion du combat"""
         self.gestionCombat = EcranGestionCombat(self)
         self.gestionCombat.show()
@@ -1168,6 +1023,59 @@ class Plateau(QGraphicsScene):
             
     ###############
 
+    ### panneau d'info
+    def majInfosPion(self, pionSurvole=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if pionSurvole != None:
+            pion = pionSurvole
+        else:
+            if self.pionSelectionne() != None:
+                pion = self.pionSelectionne()
+            else:
+                pion = None
+
+        if pion != None:  
+            self.fenetre.ui.inf_pionNom.majTexte(pion.nom)
+            if len(pion.img.nomFichier) > 0:
+                pix = QPixmap(QString.fromUtf8("img\\"+pion.img.nomFichier))
+                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.inf_pionImage.setPixmap(pix)
+            self.fenetre.ui.inf_boitePion.setVisible(True)
+            self.fenetre.ui.inf_pionEffet.setVisible(False)
+        else:
+            self.fenetre.ui.inf_boitePion.setVisible(False)
+
+    def majInfosCase(self, case=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if case != None:
+            if len(case.terrain.nom) > 0:
+                self.fenetre.ui.inf_caseTerrain.majTexte(case.terrain.nom)
+            else:
+                self.fenetre.ui.inf_caseTerrain.majTexte("Case")
+            self.fenetre.ui.inf_caseCoord.majTexte("X: {}  Y: {}".format(case.x, case.y))
+            self.fenetre.ui.inf_caseAltitude.majTexte("Alt.: {}".format(case.altitude))
+            if case.effetActif != "":
+                pix = QPixmap(QString.fromUtf8("img\\"+case.imgEffet[case.effetActif]))
+                pix = pix.scaled(21, 21, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.inf_caseEffet.setPixmap(pix)                
+            else:
+                self.fenetre.ui.inf_caseEffet.clear()
+            self.fenetre.ui.inf_boiteCase.setVisible(True)
+        else:
+            self.fenetre.ui.inf_boiteCase.setVisible(False)
+
+    def majInfosDecor(self, pionDecor=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if pionDecor != None:  
+            self.fenetre.ui.inf_decorNom.majTexte(pionDecor.nom)
+            if len(pionDecor.img.nom) > 0:
+                pix = QPixmap(QString.fromUtf8("img\\"+pionDecor.img.nom))
+                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.infoDecorEnCours_image.setPixmap(pix)
+            self.fenetre.ui.inf_boiteDecor.setVisible(True)
+        else:
+            self.fenetre.ui.inf_boiteDecor.setVisible(False)
+
     ############### fonctions de calcul ################ 
     def zone(self, origine, distance, z=0, conditionFranchissable = False, conditionVisible = False):
         """renvoie un dictionnaire representant la liste des coordonnees des cases comprises dans la zone
@@ -1372,53 +1280,7 @@ class Plateau(QGraphicsScene):
         return preSelection                         
 
 
-##    def majLigneMireAttaqueDist(self, coordCible = None):
-##        """met a jour la ligne de mire representant l'attaque a distance"""
-##        if self.modeParam["cibleAttaqueDist"] != None and self.modeParam["cibleAttaqueDist"] != coordCible:
-##            self.cases[self.modeParam["cibleAttaqueDist"]].majEstCibleCurseur(False)
-##
-##        if self.modeParam["pionCibleAttaqueDist"] != None:
-##            self.modeParam["pionCibleAttaqueDist"].estCibleAttaque(False)
-##            
-##        if coordCible != None and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":
-##            if coordCible == None:
-##                coordCible = pion.position
-##                
-##            if coordCible != self.modeParam["cibleAttaqueDist"]:
-##                if self.modeParam["ligneAttaqueDist"] == None:
-##                    self.modeParam["ligneAttaqueDist"] = QGraphicsLineItem()
-##                    self.modeParam["ligneAttaqueDist"].setZValue(100)
-##                    pinceau = QPen()
-##                    pinceau.setWidth(6)
-##                    self.modeParam["ligneAttaqueDist"].setPen(pinceau)
-##                    self.modeParam["ligneAttaqueDist"].prepareGeometryChange()
-##                    self.addItem(self.modeParam["ligneAttaqueDist"])
-##
-##                z = 0
-##                pionSurCase = self.cases[coordCible].pionOccupant()
-##                if pionSurCase != None:
-##                    z = pionSurCase.z
-##                cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible, z)
-##
-##                if pionSurCase != None:
-##                    pionSurCase.estCibleAttaque(True, cibleValide)
-##                    self.modeParam["pionCibleAttaqueDist"] = pionSurCase
-##                else:
-##                    self.cases[coordCible].majEstCibleCurseur(True, cibleValide)
-##                self.modeParam["cibleAttaqueDist"] = coordCible
-##                    
-##                point1 = self.cases[self.pionSelectionne().position].centreGraphique
-##                point2 = self.cases[coordCible].centreGraphique
-##                ligne = QLineF(point1, point2)
-##                self.modeParam["ligneAttaqueDist"].setLine(ligne)
-##        else:
-##            if self.modeParam["ligneAttaqueDist"] != None:
-##                self.modeParam["ligneAttaqueDist"].prepareGeometryChange()
-##                self.removeItem(self.modeParam["ligneAttaqueDist"])
-##            self.modeParam["ligneAttaqueDist"] = None
-##            self.modeParam["cibleAttaqueDist"] = None
-            
-                
+
     def estCibleAttaqueDistValide(self, coordOrigine, coordCible, zPion = 0):
          """la case cible est elle valide pour une attaque a distance depuis la position et hauteur
             du pion selectionne? on compare pour ce faire les altitudes des cases sur la ligne de mire"""
@@ -1539,39 +1401,7 @@ class Plateau(QGraphicsScene):
     def caseCliquee(self, x, y):
         """on a clique sur la case (clic gauche)"""
         coord = (x, y)
-        self.modeActif.clic_case(coord)
-        accepte = False
-        if coord in self.cases:
-            case = self.cases[coord]
-            if self.modeActif_old == "pionDecorSelectionne":
-                if coord != self.pionDecorSelectionne().position:
-                    self.pionDeposer(coord)
-                    accepte = True
-                    
-            elif self.modeActif_old == "pionSelectionne":
-                if self.modeCombat == "combatDeplacement":
-                    if self.pionSelectionne() != None:
-                        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"]))
-                        self.majMode("pionSelectionne", None)
-                        accepte = True
-                    else:
-                        print("cette case est invalide pour une corps a corps")
-                        accepte = True
-                elif self.modeCombat == "combatAttaqueDist":
-                    self.validerAttaqueDist()
-                    accepte = True
-                        
-                elif self.modeCombat == "combatAttaqueZone":
-                    self.validerAttaqueZone()
-                    accepte = True
-                    
-        return accepte       
+        self.modeActif.clic_case(coord)     
 
     def caseSurvolClicEnfonce(self, coord):
         """une case est survolee par le curseur (le clic gauche est enfonce)"""
@@ -1579,90 +1409,39 @@ class Plateau(QGraphicsScene):
 
     def caseSurvol(self, x, y):
         """une case est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        self.majInfosCase(self.cases[(x,y)]) 
         self.modeActif.survol_case((x,y))
-        
-        case = self.cases[(x, y)]
-        self.majInfosCase(case)
-        if (self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatDeplacement") or self.modeActif_old == "pionCreation"\
-           or self.modeActif_old == "pionDecorSelectionne" or self.modeActif_old == "pionDecorCreation":
-            self.proj.majCoord((x, y))
-            
-        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)
-                self.modeParam["point2AttaqueZone"] = case.centreGraphique
-                self.majFormeAttaqueZone()                       
-
+                         
     def afficherListeCases(self, listeCases, actif):
         """met ou non en evidence les cases selectionnees"""
         for coord in listeCases:
             self.cases[coord].majEstCibleCurseur(actif)
-        
-    def majInfosCase(self, case=None):
-        """met a jour les informations d'un pion dans la zone prevue"""
-        if case != None:
-            if len(case.terrain.nom) > 0:
-                self.fenetre.ui.inf_caseTerrain.majTexte(case.terrain.nom)
-            else:
-                self.fenetre.ui.inf_caseTerrain.majTexte("Case")
-            self.fenetre.ui.inf_caseCoord.majTexte("X: {}  Y: {}".format(case.x, case.y))
-            self.fenetre.ui.inf_caseAltitude.majTexte("Alt.: {}".format(case.altitude))
-            if case.effetActif != "":
-                pix = QPixmap(QString.fromUtf8("img\\"+case.imgEffet[case.effetActif]))
-                pix = pix.scaled(21, 21, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-                self.fenetre.ui.inf_caseEffet.setPixmap(pix)                
-            else:
-                self.fenetre.ui.inf_caseEffet.clear()
-            self.fenetre.ui.inf_boiteCase.setVisible(True)
-        else:
-            self.fenetre.ui.inf_boiteCase.setVisible(False)
 
     def pionClique(self, num):
         """on a clique sur ce pion"""
         accepte = False
         if num < 10000:
             self.modeActif.clic_combattant(num)
-            
-            accepte = False
-            if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":    
-                self.validerAttaqueDist()
-                accepte = True
-
         else:
             self.modeActif.clic_decor(num)
-        
-        if self.modeActif.nom() == "Standard":
-            self.activerMode(Modes.DeplacementPion, num)
-        
-        return accepte    
 
     def pionSurvol(self, numCombattant):
         """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
         self.modeActif.survol_combattant(numCombattant)
+
         if numCombattant in self.combattants:
             pion = self.combattants[numCombattant]
         else:
             pion = None
+            
         self.majInfosPion(pion)
-        if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueCaC":
-            self.majProjectionAttaqueCaC(pion)
-            pass
+
         if numCombattant in self.combattants:
-##            case = self.cases[self.combattants[numCombattant].position]
             self.caseSurvol(self.combattants[numCombattant].position[0], self.combattants[numCombattant].position[1])
 
     def pionDoubleClic(self, numCombattant):
         """on a double-clique sur le pion"""
-        self.modeActif.doubleClic_combattant(numCombattant)
-        accepte = False
-        if self.pionSelectionne() == self.combattants[numCombattant] and self.modeCombat == "aucun":
-##            self.pionSaisir(numCombattant)
-            self.majModeCombat("combatDeplacement")
-            accepte = True
-        return accepte          
+        self.modeActif.doubleClic_combattant(numCombattant)       
 
     def creerPion(self, pionModele):
         """creer un pion (combattant ou decor) aux coordonnees indiquees"""
@@ -1710,11 +1489,6 @@ class Plateau(QGraphicsScene):
         else:
             retour = str(i)
         return retour
-    
-    def pionSaisir(self, numCombattant):
-        """on saisit un pion"""
-        if numCombattant != self.modeParam["numPionSelectionne"]:
-            self.majMode("pionSelectionne", numCombattant)
         
     def pionDeposer(self, coordCase):
         """on depose le pion sur la case voulue"""
@@ -1727,40 +1501,6 @@ class Plateau(QGraphicsScene):
            if self.proj.projectionValide():        
                pion.majPosition(self.proj.coord(), self.proj.nbRotations())
 
-    def afficherChampDeplacement(self, actif):
-        """cree et affiche ou efface et detruit le champ de deplacement du pion selectionne"""
-        if self.pionSelectionne() != None:
-            if actif:
-                self.pionSelectionne().champDeplacement = self.zone(self.pionSelectionne().position, \
-                                                                           self.pionSelectionne().deplacementRestant, \
-                                                                           True)
-            for coord in self.pionSelectionne().champDeplacement:
-                 self.cases[coord].majEstDansChampDeplacement(actif)
-             
-            if not actif:
-                self.pionSelectionne().champDeplacement = {}
-            
-    def majInfosPion(self, pionSurvole=None):
-        """met a jour les informations d'un pion dans la zone prevue"""
-        if pionSurvole != None:
-            pion = pionSurvole
-        else:
-            if self.pionSelectionne() != None:
-                pion = self.pionSelectionne()
-            else:
-                pion = None
-
-        if pion != None:  
-            self.fenetre.ui.inf_pionNom.majTexte(pion.nom)
-            if len(pion.img.nomFichier) > 0:
-                pix = QPixmap(QString.fromUtf8("img\\"+pion.img.nomFichier))
-                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-                self.fenetre.ui.inf_pionImage.setPixmap(pix)
-            self.fenetre.ui.inf_boitePion.setVisible(True)
-            self.fenetre.ui.inf_pionEffet.setVisible(False)
-        else:
-            self.fenetre.ui.inf_boitePion.setVisible(False)
-
     def majZPion(self, valeur):
         """met a jour l'altitude du pion selectionne"""
         if self.pionSelectionne() != None:
@@ -1778,18 +1518,6 @@ class Plateau(QGraphicsScene):
         if numPionDecor != self.modeParam["numPionSelectionne"]:
             self.majMode("pionDecorSelectionne", numPionDecor)
 
-    def majInfosDecor(self, pionDecor=None):
-        """met a jour les informations d'un pion dans la zone prevue"""
-        if pionDecor != None:  
-            self.fenetre.ui.inf_decorNom.majTexte(pionDecor.nom)
-            if len(pionDecor.img.nom) > 0:
-                pix = QPixmap(QString.fromUtf8("img\\"+pionDecor.img.nom))
-                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-                self.fenetre.ui.infoDecorEnCours_image.setPixmap(pix)
-            self.fenetre.ui.inf_boiteDecor.setVisible(True)
-        else:
-            self.fenetre.ui.inf_boiteDecor.setVisible(False)
-
 
     def majProjectionAttaqueCaC(self, pionCible):
         """affiche ou non la cible de l'attaque au corps a corps, selon sa validite ou non"""
@@ -1898,29 +1626,9 @@ class Plateau(QGraphicsScene):
         super(Plateau, self).mousePressEvent(event)
         if event.button() == 1:
             self.modeActif.clicGauche(event)
-        
-        if event.button() == 1 and self.fenetre.ui.cbt_vue.dragMode() != QGraphicsView.ScrollHandDrag:
-            if self.modeActif_old == "pionSupprimer":
-                for item in self.items(event.scenePos()):
-                    if item.__class__.__name__ == "PionDecor":
-                        self.pionDecorSupprimer(item.numero)
-                        break  
-                    elif item.parentItem().__class__.__name__ == "Pion":
-                        self.pionSupprimer(item.parentItem().numero)
-                        break
-                      
-            else:
-##                if not event.isAccepted():
-##                    self.caseCliquee(self.coordonneesAuPoint(event.scenePos()))
-                event.ignore()
         elif event.button() == 2:
-            if self.pionSelectionne() != None and self.modeCombat != "" and self.modeCombat != "aucun":
-                self.majModeCombat("aucun")
-            else:    
-                self.majMode("standard")
-                self.modeActif.clicDroit(event)
+            self.modeActif.clicDroit(event)
             event.accept()
-        #event.ignore()
 
     def mouseReleaseEvent(self, event):
         super(Plateau, self).mouseReleaseEvent(event)
@@ -1930,24 +1638,6 @@ class Plateau(QGraphicsScene):
         """gestion des evenements clavier"""
         toucheClavier = event.key()
         self.modeActif.toucheClavier(event)
-        
-        if self.modeActif_old == "pionCreation" or self.modeActif_old == "pionSelectionne" or self.modeActif_old == "pionDecorSelectionne" or self.modeActif_old == "pionDecorCreation":
-            #pivots de la projection du deplacement
-            if toucheClavier == Qt.Key_Right:
-                self.proj.majRotation(1)
-                event.accept()
-            elif toucheClavier == Qt.Key_Left:
-                self.proj.majRotation(-1)
-                event.accept()
-
-        if toucheClavier == Qt.Key_Delete:
-            if self.pionSelectionne() != None:
-                num = self.pionSelectionne().numero
-                if self.modeActif_old == "pionSelectionne":
-                    self.pionSupprimer(num)
-                elif self.modeActif_old == "pionDecorSelectionne":            
-                    self.pionDecorSupprimer(num)
-                self.majMode("standard")    
             
     ################