classe Deplacement terminée

lib/AEtoile.py

@@ -140,7 +140,7 @@ class Chemin():
         if not self.echec:
             while position.coord != self.origine:
                 if self.stop: return []
-                chemin.insert(0, position.coord)
+                chemin.insert(0, (position.coord, position.coutG))
                 if self.debug:
                     self.plateau.cases[position.coord].majEstCibleCurseur(False)
                     self.plateau.cases[position.coord].majEstCibleAttaque(True)

lib/Actions.py

@@ -98,7 +98,7 @@ class Deplacement(Action):
             self.creerChemin()
         else:
             if self.estValide():
-                pion.majPosition(self.proj.coord(), self.proj.nbRotations())
+                self.acteur().majPosition(self.plateau.proj.coord(), self.plateau.proj.nbRotations())
                 super(Deplacement, self).valider()
 
     def estValide(self):
@@ -126,17 +126,19 @@ class Deplacement(Action):
         self.afficherCibles(True)        
 
     def afficherCibles(self, actif):
-        for coord in self._chemin:
-            self.plateau.cases[coord].majEstDansChampDeplacement(actif)
+        for coord, cout in self._chemin:
+            valide = True
+            if actif:
+                if cout > self.acteur().deplacement: valide = False
+            else:
+                cout = 0
+            self.plateau.cases[coord].majAffichageDeplacement(cout, valide)
 
     def envoiSignal(self):
-        cout = 0
-        for coord in self._chemin:
-            cout += self.plateau.cases[coord].coutDep()
+        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"""
     def __init__(self):
@@ -146,8 +148,6 @@ class Attaque(Action):
         self.attributs = regles.listeAttributsAttaques()
         self.notes = ""
         
-
-
 class Cac(Attaque):
     """attaque au corps a corps"""
     def __init__(self):

lib/Case.py

@@ -104,6 +104,9 @@ class Case(QGraphicsPolygonItem):
         self.polygoneChampDep = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
         self.polygoneChampDep.setVisible(False)
         self.polygoneChampDep.setAcceptHoverEvents(False)
+
+        self.logoDep = LogoDep(self)
+        self.logoDep.creer()
         
         #apparence initiale de la case
         self.majCouleur(self.couleur)            
@@ -184,29 +187,29 @@ class Case(QGraphicsPolygonItem):
      
     ########################
 
-    ########## fonctions liees a l'etat de la case ###########
-    def majCouleur(self, couleur):
-        self.couleur = couleur
-        self.setBrush(couleur)
-        self.polygoneChampDep.setBrush(self.couleurDep())
-        pinceau = QPen()
-        pinceau.setColor(self.couleurBordure())
-        pinceau.setWidth(1)
-        self.setPen(pinceau)
-        
-    def majTerrain(self, terrain):
-        if terrain != None: 
-            self.terrain = terrain
-            if len(self.terrain.imgTexture) > 0:
-                self.setBrush(QBrush(QImage("img\\"+self.terrain.imgTexture)))
-            else:
-                if self.terrain.couleur.isValid():
-                     self.setBrush(QBrush(self.terrain.couleur))
-                     self.couleur = self.terrain.couleur
-                     self.polygoneChampDep.setBrush(self.couleurDep())
+
+
+
+
+    ### deplacement
+    def estFranchissable(self, z=0):
+        """la case est-elle franchissable?"""
+        retour = True
+        if self.terrain.franchissable == False:
+            retour = False
         else:
-            self.terrain = Terrain()
+            if self.estOccupee(z) == True:
+                retour = False
+        return retour
+
+    def coutDep(self):
+        #a implementer, en fonction des
+        #capacites de deplacement du pion actuellement selectionne
+        return 1
+
 
+
+    ### pour le combat
     def majOccupation(self, objet, nouveauZ = None):
         """met a jour l'occupation de la case par les pions, decors..."""
         if objet != None:
@@ -248,20 +251,7 @@ class Case(QGraphicsPolygonItem):
                 retour = objet
         return retour          
 
-    def estFranchissable(self, z=0):
-        """la case est-elle franchissable?"""
-        retour = True
-        if self.terrain.franchissable == False:
-            retour = False
-        else:
-            if self.estOccupee(z) == True:
-                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
@@ -278,6 +268,40 @@ class Case(QGraphicsPolygonItem):
                 retour = True
         return retour                
 
+
+
+
+
+    ########## fonctions de maj ###########
+    def majCouleur(self, couleur):
+        self.couleur = couleur
+        self.setBrush(couleur)
+        self.polygoneChampDep.setBrush(self.couleurDep())
+        pinceau = QPen()
+        pinceau.setColor(self.couleurBordure())
+        pinceau.setWidth(1)
+        self.setPen(pinceau)
+        
+    def majTerrain(self, terrain):
+        if terrain != None: 
+            self.terrain = terrain
+            if len(self.terrain.imgTexture) > 0:
+                self.setBrush(QBrush(QImage("img\\"+self.terrain.imgTexture)))
+            else:
+                if self.terrain.couleur.isValid():
+                     self.setBrush(QBrush(self.terrain.couleur))
+                     self.couleur = self.terrain.couleur
+                     self.polygoneChampDep.setBrush(self.couleurDep())
+        else:
+            self.terrain = Terrain()
+
+    def majAffichageDeplacement(self, cout, valide = True):
+        """lorsque cette case est sur le chemin d'un pion,
+            un disque blanc ou rouge apparait indiquant le
+            cout du deplacement jusqua cette case
+            un cout de 0 fait disparaitre ce symbole"""
+        self.logoDep.afficher(cout, valide)
+
     def majEstDansChampDeplacement(self, actif):
         """la case apparait ou pas comme etant dans le champ de deplacement d'un pion"""
         self.polygoneChampDep.setVisible(actif)
@@ -378,7 +402,9 @@ class Case(QGraphicsPolygonItem):
             self.etiquetteAltitude.setZValue(6)
         else:
             self.polygoneAffichageSpecial.setVisible(False)
-        
+
+
+    #fonctions secondaires
     def couleurDep(self):
         """renvoie une couleur secondaire utilisee pour les champs de deplacements"""
         luminositeActuelle = self.couleurEffective().lightness()
@@ -437,8 +463,8 @@ class Case(QGraphicsPolygonItem):
         b_moy = int(b / nb_pix)
         return QColor(r_moy, v_moy, b_moy)
 
-    ######### evebements souris et clavier    #################
-    #*EC
+    ######### evenements souris et clavier    #################
+
     def mousePressEvent(self, event):
         """evenement lors du clic souris"""
         super(Case, self).mousePressEvent(event)
@@ -456,6 +482,77 @@ class Case(QGraphicsPolygonItem):
     def hoverLeaveEvent(self, event):
         """met a jour l'affichage de la case au survol de la souris, si un pion est selectionne"""
         super(Case, self).hoverLeaveEvent(event)
-        #self.plateau.caseSurvol()
     
     ########################
+
+
+class LogoDep(QGraphicsEllipseItem):
+    def __init__(self, parent = None):
+        super(LogoDep, self).__init__()
+        self.parent = parent
+        
+        self.couleur = None
+        self.txt = None
+
+    def creer(self):
+        
+        hC = self.parent.plateau.hCase
+        rect = QRectF()
+        rayon = 0.4*hC
+        rect.setTopLeft(QPointF(self.parent.centreGraphique.x() - rayon, self.parent.centreGraphique.y() - rayon))
+        rect.setBottomRight(QPointF(self.parent.centreGraphique.x() + rayon, self.parent.centreGraphique.y() + rayon))
+
+        self.setRect(rect)
+        
+
+        self.txt = QGraphicsTextItem(self)
+        police = QFont("Georgia", 24)
+        police.setBold(True)
+        self.txt.setFont(police)
+        self.txt.setParentItem(self)
+        self.txt.setPos(QPointF(self.parent.centreGraphique.x() - rayon, self.parent.centreGraphique.y() - 0.6*rayon))
+
+        self.txt.setTextWidth(2*rayon)
+        self.txt.setPlainText(QString.fromUtf8(""))
+        self.centrerTexte()
+
+        self.setVisible(False)
+        self.setAcceptHoverEvents(False)
+        
+        self.setParentItem(self.parent)
+
+
+    def afficher(self, valeur, valide):
+        """lorsque cette case est sur le chemin d'un pion,
+            un disque blanc ou rouge apparait indiquant le
+            mode de deplacement (icone: 'dep_simple', 'nage', 'escalade', 'vol')
+            un cout de 0 fait disparaitre ce symbole"""
+        if valeur > 0:
+            #couleur
+            if valide:
+                couleur = QColor(255, 255, 220, 200)
+            else:
+                couleur = QColor(240, 60, 20, 200)
+
+            self.setBrush(couleur)
+            self.setPen(QPen(couleur))
+
+            #txt
+            self.txt.setPlainText(QString.fromUtf8(str(valeur)))
+            self.centrerTexte()
+
+            self.setVisible(True)
+        else:
+            self.setVisible(False)
+
+    def centrerTexte(self):
+        f = QTextBlockFormat()
+        f.setAlignment(Qt.AlignCenter)
+        cursor = self.txt.textCursor()
+        cursor.select(QTextCursor.Document)
+        cursor.mergeBlockFormat(f)
+        cursor.clearSelection()
+        self.txt.setTextCursor(cursor)
+
+
+

lib/Modes.py

@@ -190,15 +190,7 @@ class MajCases(ModeBaseCp):
     def finClicGauche(self, event):
         if self.plateau.pinceau.estActif():
             for coord in self.plateau.pinceau.selection():
-                if self._param.__class__.__name__ == "Terrain":
-                    print self._param.franchissable
-                    self.plateau.cases[coord].majTerrain(self._param)
-                elif self._param.__class__.__name__ == "QColor":
-                    if self._param.isValid():
-                         self.plateau.cases[coord].majTerrain(None)
-                         self.plateau.cases[coord].majCouleur(self._param)
-                elif self._param.__class__.__name__ == "EffetCase":
-                    self.plateau.cases[coord].majEffet(self._param)
+                self.plateau.cases[coord].majTerrain(self._param)
                 self.plateau.pinceau.reinit()
             self.reinit()
 
@@ -208,6 +200,18 @@ class MajCases(ModeBaseCp):
         elif event.key() == Qt.Key_Down:
             self.plateau.fenetre.ui.epaisseurPinceau.setValue(self.plateau.fenetre.ui.epaisseurPinceau.value()-1)
 
+class MajCasesEffet(MajCases):
+    """mode de mise a jour des cases (effets speciaux)"""
+    def __init__(self, plateau):
+        super(MajCasesEffet, self).__init__(plateau)    
+
+    def finClicGauche(self, event):
+        if self.plateau.pinceau.estActif():
+            for coord in self.plateau.pinceau.selection():
+                self.plateau.cases[coord].majEffet(self._param)
+                self.plateau.pinceau.reinit()
+            self.reinit()
+
 class Pipette(ModeBaseCp):
     """mode pipette: on preleve la couleur ou le terrain d'une case"""
     def __init__(self, plateau):

lib/Plateau.py

@@ -22,6 +22,7 @@ from Pinceau import Pinceau
 from ProjectionDep import ProjectionDep
 from Cache import Cache
 from EntreeSortie import EntreeSortie
+from Terrain import Terrain
 
 from EcranEditionCombattant import EcranEditionCombattant
 from EcranEditionDecors import EcranEditionDecors
@@ -611,7 +612,9 @@ class Plateau(QGraphicsScene):
         """enclenche le mode peinture de case a partir de la couleur selectionnee"""
         couleur = self.chercherCouleur()
         if couleur.isValid():
-            self.activerMode(Modes.MajCases, couleur)
+            terrain = Terrain()
+            terrain.couleur = couleur
+            self.activerMode(Modes.MajCases, terrain)
         else:
             self.activerMode(Modes.StandardCp)
 
@@ -622,7 +625,9 @@ class Plateau(QGraphicsScene):
         r, g, b = m_couleursRapides[index]
         couleur.setRgb(r, g, b)
         if couleur.isValid():
-            self.activerMode(Modes.MajCases, couleur)
+            terrain = Terrain()
+            terrain.couleur = couleur
+            self.activerMode(Modes.MajCases, terrain)
         else:
             self.activerMode(Modes.StandardCp)            
 
@@ -1463,159 +1468,6 @@ 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 rectEllipseCirculaire(self, centre, rayon):
-##        """renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param
-##           attention: l'ellipse n'est pas tout a fait circulaire, elle couvre horizontalement et
-##           verticalement le nombre de cases demandees"""
-##        rect = QRectF()
-##        if rayon > 0:
-##            p1 = QPointF((centre.x() - (rayon*self.hCase)), (centre.y() - (rayon*self.hCase)))
-##            p2 = QPointF((centre.x() + (rayon*self.hCase)), (centre.y() + (rayon*self.hCase)))
-##            rect.setTopLeft(p1)
-##            rect.setBottomRight(p2)
-##        else:
-##            rect = None
-##        return rect
-
-##    def polygoneCone(self, point1, point2):
-##        """renvoie le polygone du cone defini par les deux points (origine, distance)"""
-##        ligne1 = QLineF(point1, point2)
-##        longueur = ligne1.length()
-##        ligne1.setAngle(ligne1.angle() + 22.5)
-##        ligne1.setLength(1.1547*longueur)
-##        ligne2 = QLineF(point1, point2)    
-##        ligne2.setAngle(ligne2.angle() - 22.5)
-##        ligne2.setLength(1.1547*longueur)
-##        polygone = QPolygonF()
-##        polygone.append(point1)
-##        polygone.append(ligne1.p2())
-##        polygone.append(ligne2.p2())
-##        return polygone
-
-##    def majFormeAttaqueZone(self):
-##        """cree la forme de l'attaque de zone"""
-##        for coord in self.modeParam["listeCasesAttaqueZone"]:
-##            self.cases[coord].majEstCibleAttaque(False)
-##        for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
-##             self.combattants[numCombattant].estCibleAttaque(False)
-##        
-##        if self.modeCombat == "combatAttaqueZone" and self.pionSelectionne() != None:
-##            if self.modeParam["typeAttaqueZone"] == "ligne":
-##                if self.modeParam["formeAttaqueZone"] == None:
-##                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["formeAttaqueZone"] = QGraphicsLineItem()
-##                    self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
-##                    self.modeParam["formeAttaqueZone"].prepareGeometryChange()
-##                    self.addItem(self.modeParam["formeAttaqueZone"])
-##                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: 
-##                    ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
-##                    self.modeParam["formeAttaqueZone"].setLine(ligne)
-##                    self.modeParam["listeCasesAttaqueZone"] = []
-##                    lst = self.casesSousForme(self.modeParam["formeAttaqueZone"],False)
-##                    for coord in lst:
-##                        self.modeParam["listeCasesAttaqueZone"].append(coord)                
-##                    #on retire la case du pion selectionne si besoin:
-##                    if self.pionSelectionne().position in self.modeParam["listeCasesAttaqueZone"]:
-##                        self.modeParam["listeCasesAttaqueZone"].remove(self.pionSelectionne().position)
-##                                                 
-##            elif self.modeParam["typeAttaqueZone"] == "disque":
-##                if self.modeParam["ligneMireAttaqueZone"] == None:
-##                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["ligneMireAttaqueZone"] = QGraphicsLineItem()
-##                    self.modeParam["ligneMireAttaqueZone"].setPen(QPen(QColor("black")))
-##                    self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange()
-##                    self.addItem(self.modeParam["ligneMireAttaqueZone"])
-##   
-##                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: 
-##                    ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
-##                    self.modeParam["ligneMireAttaqueZone"].setLine(ligne)
-##                    coordCible = self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])
-##                    cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible)
-##                    
-##                    if cibleValide:
-##                        rayon = self.fenetre.ui.pi_rayonAttaqueZone.value()
-##                        if self.modeParam["formeAttaqueZone"] == None:
-##                            self.modeParam["formeAttaqueZone"] = QGraphicsEllipseItem()
-##                            self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
-##                            self.modeParam["formeAttaqueZone"].prepareGeometryChange()
-##                            self.addItem(self.modeParam["formeAttaqueZone"])
-##                        rect = self.rectEllipseCirculaire(self.modeParam["point2AttaqueZone"], rayon)
-##                        self.modeParam["listeCasesAttaqueZone"] = []
-##                        if rect != None and rect.bottomRight() != rect.topLeft():
-##                            self.modeParam["formeAttaqueZone"].setRect(rect)
-##                            lst = self.zone(coordCible, rayon, 0)   #zone bcp plus rapide que casesSousforme
-##                            self.modeParam["listeCasesAttaqueZone"] = lst
-##                    else:
-##                        self.cases[coordCible].majEstCibleCurseur(True, False)
-##                        self.modeParam["listeCasesAttaqueZone"] = []
-##                    
-##                    if self.modeParam["formeAttaqueZone"] != None:        
-##                        self.modeParam["formeAttaqueZone"].setVisible(cibleValide == True and rect != None)    
-##                
-##            elif self.modeParam["typeAttaqueZone"] == "cone":
-##                if self.modeParam["formeAttaqueZone"] == None:
-##                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
-##                    self.modeParam["formeAttaqueZone"] = QGraphicsPolygonItem()
-##                    self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
-##                    self.modeParam["formeAttaqueZone"].prepareGeometryChange()
-##                    self.addItem(self.modeParam["formeAttaqueZone"])
-##                    
-##                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]:
-##                    cone = self.polygoneCone(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
-##                    self.modeParam["formeAttaqueZone"].setPolygon(cone)
-##                    lst = self.casesSousForme(self.modeParam["formeAttaqueZone"], True, True)
-##                    self.modeParam["listeCasesAttaqueZone"] = []
-##                    for coord in lst:
-##                        if coord != self.pionSelectionne().position:
-##                            self.modeParam["listeCasesAttaqueZone"].append(coord)
-##
-##            for coord in self.modeParam["listeCasesAttaqueZone"]:
-##                self.cases[coord].majEstCibleAttaque(True)
-##            for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
-##                self.combattants[numCombattant].estCibleAttaque(True)
-
-
-##    def validerAttaqueZone(self):
-##        """l'attaque de zone est validee"""
-##        if self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatAttaqueZone":
-##            for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
-##                print("{} a lance une attaque de zone sur {}".format(self.pionSelectionne().nom, self.pionSelectionne().numero , \
-##                                                                     self.combattants[numCombattant].nom, self.combattants[numCombattant].numero))
-##        self.majModeCombat("aucun")        
-##
-##    def reinitAttaqueZone(self):
-##        if self.modeParam["formeAttaqueZone"] != None:
-##            self.modeParam["formeAttaqueZone"].prepareGeometryChange()
-##            self.removeItem(self.modeParam["formeAttaqueZone"])
-##            self.modeParam["formeAttaqueZone"] = None
-##        if self.modeParam["ligneMireAttaqueZone"] != None:
-##            self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange()
-##            self.removeItem(self.modeParam["ligneMireAttaqueZone"])
-##            self.modeParam["ligneMireAttaqueZone"] = None
-##        if self.modeParam["point2AttaqueZone"] != None:
-##            self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False)
-##        for coord in self.modeParam["listeCasesAttaqueZone"]:
-##            self.cases[coord].majEstCibleAttaque(False)
-##        for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
-##            self.combattants[numCombattant].estCibleAttaque(False)
                       
     def pionSurCase(self, coord):
         """renvoie le pion present sur la case, none sinon"""