Fonctionnement de la classe ProjectionDep validée

lib/Plateau.py

@@ -18,7 +18,7 @@ from Combattant import Combattant
 from Decor import Decor
 from Forme import Forme
 from Pinceau import Pinceau
-
+from ProjectionDep import ProjectionDep
 from Cache import Cache
 from EntreeSortie import EntreeSortie
 
@@ -133,7 +133,7 @@ class Plateau(QGraphicsScene):
     def recreer(self, fenetre):
         self.fenetre = fenetre
         self.gestionCombat = None
-        self.pinceau = Pinceau(self)
+        
         super(Plateau, self).__init__()
         self.connexions()
 
@@ -290,8 +290,10 @@ class Plateau(QGraphicsScene):
         #gestion du mode d'interaction avec le plateau
         self.modeActif = Modes.Standard(self)
         self.modeActif_old = ""
+        self.pinceau = Pinceau(self)
+        self.proj = ProjectionDep(self)
         self.modeParam = {"numPionSelectionne": 0, "pionNouveau": None, "creature": None, "decor": None, \
-                          "coordProjectionPosition": (0,0), "formeProjectionPosition": None, "nbRotations": 0, "formeCoordEnCours": (0,0), \
+                          "formeCoordEnCours": (0,0), \
                           "zoneAttaqueCaC": [], "cibleAttaqueCaC": None, "cibleAttaqueDist": None, "pionCibleAttaqueDist": None, "ligneAttaqueDist": None, \
                           "typeAttaqueZone": "", "formeAttaqueZone": None, "origineAttaqueZone": None, "point2AttaqueZone": None, \
                           "listeCasesAttaqueZone": [], "ligneMireAttaqueZone": None}
@@ -648,10 +650,7 @@ class Plateau(QGraphicsScene):
 
         if self.modeActif_old == "pionSelectionne" or self.modeActif_old == "pionCreation" or \
            self.modeActif_old == "pionDecorSelectionne" or self.modeActif_old == "pionDecorCreation":  
-            self.majProjectionPosition(False)
-            self.modeParam["formeProjectionPosition"] = None
-            self.modeParam["coordProjectionPosition"] = None
-            self.modeParam["nbRotations"] = 0
+            self.proj.desactiver()
                 
         if self.modeActif_old[0:7] == "caseMaj" or self.modeActif_old == "cachePlacer" or self.modeActif_old == "majZonePlacement":
             self.pinceau.reinit()
@@ -708,12 +707,11 @@ class Plateau(QGraphicsScene):
                 #curseur 'plus', on cree de nouveaux decors
                 self.modeParam["decor"] = None
                 self.fenetre.ui.cbt_vue.setDragMode(0)
-                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
-                self.modeParam["nbRotations"] = 0
+                
                 if param != None:
                     if param.__class__.__name__ == "Decor":
                          self.modeParam["decor"] = param
-                         self.modeParam["formeProjectionPosition"].definirForme(self.modeParam["decor"].formeDef[self.formeCases])
+                         self.proj.creer(param)
 
             elif mode == "pionDecorSelectionne":
                 #un pion decor est selectionne
@@ -721,20 +719,16 @@ class Plateau(QGraphicsScene):
                     self.modeParam["numPionSelectionne"] = param
                     self.pionDecorSelectionne().afficheOmbreSelection(True)
                     self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-                    self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
-                    self.modeParam["formeProjectionPosition"].definirForme(self.pionDecorSelectionne().forme.formeDef)
-                    self.modeParam["nbRotations"] = self.pionDecorSelectionne().nbRotations 
+                    self.proj.creer(self.pionDecorSelectionne())
 
             elif mode == "pionCreation":
                 #curseur 'plus', on cree de nouveaux pions
                 self.modeParam["creature"] = None
                 self.fenetre.ui.cbt_vue.setDragMode(0)
-                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
-                self.modeParam["nbRotations"] = 0
                 if param != None:
                     if param.__class__.__name__ == "Combattant":
                          self.modeParam["creature"] = param
-                         self.modeParam["formeProjectionPosition"].definirForme(self.modeParam["creature"].formeDef[self.formeCases])
+                         self.proj.creer(param)
                 
             elif mode == "pionSupprimer":
                 #mode suppression de pions/pions decors
@@ -785,10 +779,7 @@ class Plateau(QGraphicsScene):
             #le champ de deplacement
             if self.modePrincipal == "combat":
                 self.afficherChampDeplacement(False)
-            self.majProjectionPosition(False)
-            self.modeParam["formeProjectionPosition"] = None
-            self.modeParam["coordProjectionPosition"] = None
-            self.modeParam["nbRotations"] = 0    
+            self.proj.desactiver()
                 
         elif self.modeCombat == "combatAttaqueCaC":        
             #la zone d'attaque au cac
@@ -820,9 +811,7 @@ class Plateau(QGraphicsScene):
             
             if mode == "combatDeplacement":
                 self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))
-                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
-                self.modeParam["formeProjectionPosition"].definirForme(self.pionSelectionne().forme.formeDef)
-                self.modeParam["nbRotations"] = self.pionSelectionne().nbRotations
+                self.proj.creer(self.pionSelectionne())
 
                 if self.modePrincipal == "combat":
                     #si mode combat, affichage de la zone de deplacement
@@ -1729,9 +1718,8 @@ class Plateau(QGraphicsScene):
         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.majProjectionPosition(False)
-            self.modeParam["coordProjectionPosition"] = (case.x, case.y)
-            self.majProjectionPosition(True)
+            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":
@@ -1802,13 +1790,9 @@ class Plateau(QGraphicsScene):
     def pionCreer(self, coordCase):
         """creer un jeton aux coordonnees indiquees"""
         valide = True
-        for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase):
-            if not coord in self.cases:
-                valide = False
-            else:    
-                 if not self.cases[coord].estFranchissable():
-                      valide = False
-        if valide:
+        self.proj.majCoord(coordCase)
+
+        if self.proj.projectionValide():
             numero = 1
             if len(self.combattants) > 0:
                 numero = max(self.combattants) + 1
@@ -1816,9 +1800,9 @@ class Plateau(QGraphicsScene):
             combattant = self.modeParam["creature"]
             numComplementaire = self.numeroterNom(combattant.nom)
             combattant.numero = numero
-            combattant.position = coordCase
+            combattant.position = self.proj.coord()
             combattant.numComplementaire = numComplementaire
-            combattant.nbRotations = self.modeParam["nbRotations"]
+            combattant.nbRotations = self.proj.nbRotations()
             combattant.ajouterAuPlateau(self)
             
             self.combattants[numero] = combattant
@@ -1849,24 +1833,10 @@ class Plateau(QGraphicsScene):
             pion = self.pionDecorSelectionne()
         
         if pion != None:
-           valide = True
-           for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase, self.modeParam["nbRotations"]):
-               if coord in self.cases:
-                    if not self.cases[coord].estFranchissable(pion.z):
-                        if not self.cases[coord].estOccupeePar(pion.z) == pion:
-                             #si la case est occupee par le pion qu'on depose, elle est donc valide pour un deplacement  
-                             valide = False
-               else:
-                   valide = False
-           if valide:        
-##               positionPrecedente = pion.position 
-               #mise a jour de la position du pion selon le mode
+           if self.proj.deplacementValide():        
                if self.modePrincipal == "combat":
-##                   if coordCase in pion.champDeplacement:
-##                       print("le pion a ete deplace de {} vers {} \n    -> soit une distance de {} cases"\
-##                             "".format(positionPrecedente, coordCase, self.pionSelectionne().champDeplacement[coordCase]))
                    self.majInfosPion()
-               pion.majPosition(coordCase, self.modeParam["nbRotations"])
+               pion.majPosition(self.proj.coord(), self.proj.nbRotations())
                self.majModeCombat("aucun")
            else:
                print("Deplacement impossible!")
@@ -1934,32 +1904,6 @@ class Plateau(QGraphicsScene):
         else:
             self.fenetre.ui.inf_boiteDecor.setVisible(False)
 
-    def majProjectionPosition(self, activer, z=0):
-        """maj l'affichage de la projection de la position d'un objet avant creation ou deplacement (pion, decor...)"""
-        valide = True
-        possible = True
-
-        if self.modeParam["formeProjectionPosition"] != None and self.modeParam["coordProjectionPosition"] != None:
-            proj = self.modeParam["formeProjectionPosition"].listeCases(self.modeParam["coordProjectionPosition"], self.modeParam["nbRotations"])
-                 
-            for coord in proj:
-                if not coord in self.cases:
-                    valide = False   #deplacement valide? (pas d'occupation d'une case hors plateau)
-    
-            if valide == True:
-                for coord in proj:
-                    if self.cases[coord].estFranchissable(z) or self.cases[coord].estOccupeePar(z) == self.pionSelectionne():
-                    #la case est franchissable, ou elle ne l'est pas mais est occupée par le pion meme qu'on deplace
-                        self.cases[coord].majEstCibleCurseur(activer, True)
-                             
-                        #on affiche la distance correspondante en bulle-info
-                        if activer and self.modeActif_old == "pionSelectionne" and self.modePrincipal == "combat":
-                             if coord in self.pionSelectionne().champDeplacement:
-                                  msg = "Distance {}".format(self.pionSelectionne().champDeplacement[coord])
-                                  QToolTip.showText(QCursor.pos(), msg, self.fenetre.ui.cbt_vue)
-                    else:
-                        self.cases[coord].majEstCibleCurseur(activer, False)
-
 
     def majProjectionAttaqueCaC(self, pionCible):
         """affiche ou non la cible de l'attaque au corps a corps, selon sa validite ou non"""
@@ -1981,18 +1925,18 @@ class Plateau(QGraphicsScene):
 
     def pionDecorCreer(self, coordCase):
         """creer un jeton aux coordonnees indiquees"""
-        valide = True
-        for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase, self.modeParam["nbRotations"]):
-            if not self.cases[coord].estFranchissable():
-                 valide = False
-        if valide:  
+        if self.proj.deplacementValide:  
             numero = 10001
             if len(self.decors) > 0:
                 numero = max(self.decors) + 10001 
-            pionDecor = PionDecor(self, numero)
-            pionDecor.creer(coordCase[0], coordCase[1], self.modeParam["decor"], self.modeParam["nbRotations"])
-            self.decors[numero] = pionDecor
- 
+            decor = self.modeParam["decor"]
+            decor.numero = numero
+            decor.position = self.proj.coord()
+            decor.nbRotations = self.proj.nbRotations()
+            decor.ajouterAuPlateau(self)
+            self.decors[numero] = decor
+
+            
     def pionSupprimer(self, num):
         """supprime le pion entre en parametre"""
         #settrace(trace_calls)
@@ -2118,14 +2062,10 @@ class Plateau(QGraphicsScene):
         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.majProjectionPosition(False)
-                self.modeParam["nbRotations"] += 1
-                self.majProjectionPosition(True)
+                self.proj.majRotation(1)
                 event.accept()
             elif toucheClavier == Qt.Key_Left:
-                self.majProjectionPosition(False)
-                self.modeParam["nbRotations"] -= 1
-                self.majProjectionPosition(True)
+                self.proj.majRotation(-1)
                 event.accept()
 
         if toucheClavier == Qt.Key_Delete:

lib/ProjectionDep.py

@@ -10,13 +10,18 @@ class ProjectionDep():
     def __init__(self, plateau):
         self.plateau = plateau
         self._pion = None
+        self._active = False
         
         self._coord = (-1,-1)
         self._forme = Forme(self.plateau.formeCases)
         self._nbRotations = 0
 
     def creer(self, pion):
+        self_pion = pion
         self._forme.definirForme(pion.formeDef[self.plateau.formeCases])
+        self._coord = pion.position
+        self._nbRotations = pion.nbRotations
+        self._active = True
 
     def majCoord(self, coord):
         self.desactiver()
@@ -28,10 +33,18 @@ class ProjectionDep():
         self._nbRotations += modRotation
         self.maj()
 
+    def coord(self):
+        return self._coord
+
+    def nbRotations(self):
+        return self._nbRotations
+
     def desactiver(self):
         for coord in self._forme.listeCases(self._coord, self._nbRotations):
-            self.plateau.cases[coord].majEstCibleCurseur(False)
-    
+            if coord in self.plateau.cases:
+                self.plateau.cases[coord].majEstCibleCurseur(False)
+        self.active = False
+
     def projectionValide(self):
         """la projection est valide si toutes les cases de la forme existent"""
         valide = True
@@ -49,22 +62,32 @@ class ProjectionDep():
         if self.projectionValide():
             for coord in self._forme.listeCases(self._coord, self._nbRotations):
                 compte += 1
-                if self.plateau.cases[coord].estFranchissable(self._pion.z):
+                if self.plateau.cases[coord].estFranchissable(self.z()):
                     ok += 1
                 else:
                     #si la case est occupee par le pion lui-meme
-                    if self.plateau.cases[coord].estOccupeePar(self._pion.z) == self._pion:
+                    if self.plateau.cases[coord].estOccupeePar(self.z()) == self._pion:
                         ok += 1
         valide = (ok == compte and compte > 0)
         return valide        
 
     def maj(self):
+        self._active = True
         if self.projectionValide():
             depValide = self.deplacementValide()
             for coord in self._forme.listeCases(self._coord, self._nbRotations):
                 self.plateau.cases[coord].majEstCibleCurseur(True, depValide)
             
-
+            
+    def z(self):
+        """renvoie l'altitude du pion qu'on deplace"""
+        z = 0
+        try:
+            z = self._pion.z
+        except:
+            pass
+        return z
+