Maj des effets de case restorée

lib/Actions.py

@@ -18,13 +18,14 @@ class Action(object):
     def activer(self, plateau, numPion):
         self.plateau = plateau
         self._num = numPion
+        
+        self.enfoncerBouton(True)
         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()
@@ -187,7 +188,7 @@ class Cac(Attaque):
     def maj(self):
         self.afficherCibles(False)
         pionCible = self.plateau.cases[self._coordCible].pionOccupant()
-        if pionCible != None and pionCible != self._plateau.pionSelectionne():
+        if pionCible != None and pionCible != self.plateau.pionSelectionne():
             self._pionCible = pionCible
         else:
             self._pionCible = None
@@ -221,7 +222,7 @@ class Distance(Attaque):
         super(Distance, self).majCoordCible(coord)        
 
     def valider(self):
-        if self.estValide() and self._pionCible:
+        if self.estValide() and self._pionCible != None:
             super(Distance, self).valider()
 
     def maj(self):
@@ -230,7 +231,7 @@ class Distance(Attaque):
         pionCible = self.plateau.cases[self._coordCible].pionOccupant()
 
         self.majItemsGraphiques()
-        if pionCible != None and pionCible != self._plateau.pionSelectionne():
+        if pionCible != None and pionCible != self.plateau.pionSelectionne():
             self._pionCible = pionCible
         else:
             self._pionCible = None
@@ -301,7 +302,7 @@ class Zone(Attaque):
         self._casesCibles = []
         if self.estValide():
             for coord in self.plateau.casesSousForme(self._itemCible, True, True):
-                if coord != self.plateau.pionSelectionne().position:
+                if coord!= None and coord != self.plateau.pionSelectionne().position:
                     self._casesCibles.append(coord)            
 
     def afficherCibles(self, actif):
@@ -310,9 +311,6 @@ class Zone(Attaque):
         for numCombattant in self.plateau.pionsSurListeCase(self._casesCibles):
             self.plateau.combattants[numCombattant].estCibleAttaque(actif)    
 
-    def estValide(self):
-        return self.plateau.estCibleAttaqueDistValide(self.plateau.pionSelectionne().position, self._coordCible)
-
     def creerItemsGraphiques(self):
         self._itemLigne = QGraphicsLineItem()
         self._itemLigne.setPen(QPen(QColor("black")))
@@ -337,12 +335,13 @@ class Zone(Attaque):
 
     def envoiSignal(self):
         touches = ""
-        for pion in self.plateau.pionsSurListeCase(self._casesCibles):
-            touches += "{}, ".format(pion.txtId())
+        for num in self.plateau.pionsSurListeCase(self._casesCibles):
+            touches += "{}, ".format(self.plateau.combattants[num].txtId())
         touches = touches[:-2]
         print "{} a lancé une attaque de zone. Les pions suivants sont touches: \n {}".format(self.acteur().txtId(), touches)
 
-class Ligne(Attaque):
+
+class Ligne(Zone):
     """attaque de zone de forme lineaire"""
     def __init__(self):
         super(Ligne, self).__init__()
@@ -352,13 +351,24 @@ class Ligne(Attaque):
         self._itemLigne.setLine(QLineF(self.plateau.cases[self.plateau.pionSelectionne().position].centreGraphique, \
                                        self.plateau.cases[self._coordCible].centreGraphique))
 
+    def majCibles(self):
+        """met a jour la liste des cases cibles"""
+        self._casesCibles = []
+        if self.estValide():
+            for coord in self.plateau.casesSousForme(self._itemLigne, True, True):
+                if coord!= None and coord != self.plateau.pionSelectionne().position:
+                    self._casesCibles.append(coord)  
 
-class Disque(Attaque):
+class Disque(Zone):
     """attaque de zone de forme circulaire"""
     def __init__(self):
         super(Disque, self).__init__()
         self.nom = "Attaque de zone: disque"
-        self.rayon = 1
+
+    def majCoordCible(self, coord):
+        if self._coordCible in self.plateau.cases:    
+            self.plateau.cases[self._coordCible].majEstCibleCurseur(False)
+        super(Disque, self).majCoordCible(coord)    
 
     def majCibles(self):
         self._casesCibles = self.plateau.zone(self._coordCible, self.rayon, 0)
@@ -366,17 +376,21 @@ class Disque(Attaque):
     def afficherCibles(self, actif):
         super(Disque, self).afficherCibles(actif)
         #si on affiche une attaque invalide
-        if actif and not self.estValide():
-            self.plateau.cases[self._coordCible].majEstCibleCurseur(True, False)
+        if not self.estValide():
+            self.plateau.cases[self._coordCible].majEstCibleCurseur(actif, False)
 
     def majItemsGraphiques(self):
+        self.rayon = self.plateau.fenetre.ui.pi_rayonAttaqueZone.value()
         self._itemLigne.setLine(QLineF(self.plateau.cases[self.plateau.pionSelectionne().position].centreGraphique, \
                                        self.plateau.cases[self._coordCible].centreGraphique))
         if self.estValide():
             rect = self.rectEllipseCirculaire(self.plateau.cases[self._coordCible].centreGraphique, self.rayon)
             if rect != None:
                 self._itemCible.setRect(rect)
-            self._itemCible.setVisible(self.estvalide() and rect != None)
+            self._itemCible.setVisible(self.estValide() and rect != None)
+
+    def estValide(self):
+        return self.plateau.estCibleAttaqueDistValide(self.plateau.pionSelectionne().position, self._coordCible)
 
     def rectEllipseCirculaire(self, centre, rayon):
         """renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param
@@ -384,8 +398,8 @@ class Disque(Attaque):
            verticalement le nombre de cases demandees"""
         rect = None
         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)))
+            p1 = QPointF((centre.x() - (rayon*self.plateau.hCase)), (centre.y() - (rayon*self.plateau.hCase)))
+            p2 = QPointF((centre.x() + (rayon*self.plateau.hCase)), (centre.y() + (rayon*self.plateau.hCase)))
             if p1 != p2:
                 rect = QRectF()
                 rect.setTopLeft(p1)
@@ -393,7 +407,7 @@ class Disque(Attaque):
         return rect
 
 
-class Cone(Attaque):
+class Cone(Zone):
     """attaque de zone de forme conique"""
     def __init__(self):
         super(Cone, self).__init__()

lib/Case.py

@@ -247,12 +247,10 @@ class Case(QGraphicsPolygonItem):
         """si un pion occupe cette case, le renvoie"""
         retour = None
         for objet in self.occupeePar:
-            if objet.__class__.__name__ == "Pion":
+            if objet.__class__.__name__ == "Combattant":
                 retour = objet
         return retour          
 
-
-
     def estObstacleVision(self, hauteurObs):
         """renvoie vrai si la case et l'eventuel decor qui l'occupe bloquent le champ de
            vision d'un observateur situe a la hauteur precisee"""

lib/Modes.py

@@ -331,7 +331,8 @@ class CreationPion(ModeBaseCp):
 
     def clic_case(self, coord):
         if self._pion:
-            self.plateau.creerPion(self._pion)
+            if not self.plateau.cases[coord].pionOccupant:
+                self.plateau.creerPion(self._pion)
 
     def toucheClavier(self, event):
         if self._pion:
@@ -452,6 +453,9 @@ class PionSelectionne(ModeBasePi):
         super(PionSelectionne, self).desactiver()
 
     def nouvelleAction(self, action):
+        if self._action:
+            self._action.desactiver()
+            self._action = None            
         self._action = action()
         self._action.activer(self.plateau, self._num)
         
@@ -461,7 +465,8 @@ class PionSelectionne(ModeBasePi):
 
     def clic_case(self, coord):
         if self._action:
-            self._action.valider()        
+            self._action.valider()
+            self._action = None
            
     def clicDroit(self, event):
         if self._action != None:

lib/Plateau.py

@@ -66,11 +66,6 @@ class Plateau(QGraphicsScene):
         self.nbCasesX = 0
         self.nbCasesY = 0
         self.hCase = 0
-        self.modePrincipal = "creation"
-        self.modeCombat = ""
-        
-        #interface
-        self.epaisseurpinceau = 0
 
         #objets
         self.pinceau = Pinceau(self)
@@ -97,8 +92,7 @@ class Plateau(QGraphicsScene):
         
     def __getstate__(self):
         self.dateSvg = time()
-        state = {key:value for key, value in self.__dict__.items() if not key in ["fenetre", "modeActif", "listMode", "cacheEnCours", \
-                                                                                  "modeParam", "epaisseurPinceau", \
+        state = {key:value for key, value in self.__dict__.items() if not key in ["fenetre", "modeActif", "cacheEnCours", \
                                                                                   "editionTerrain", "editionCreature", "editionDecor", \
                                                                                   "polygoneZonePlacement", "gestionCombat", "polygonesCaches", \
                                                                                   "editionAttaques", "pinceau"]}
@@ -107,6 +101,9 @@ class Plateau(QGraphicsScene):
     def __setstate__(self, state):
         self.__dict__ = state
 
+    def vue(self):
+        return self.fenetre.ui.cbt_vue
+
     def creer(self, idPlateau, nom, chapitre, formeCases, nbCasesX, nbCasesY, couleur = QColor(0, 255, 0, 80)):
         """cree le plateau"""
         self.id = idPlateau
@@ -124,9 +121,6 @@ class Plateau(QGraphicsScene):
         #cree les cases hexagonales
         for x in range(nbCasesX):
             for y in range(nbCasesY):
-##                if formeCases == "H":
-##                     if 1 == (x % 2):
-##                          y += 0.5
                 c = Case(self)
                 c.creer(x, y, couleur)
                 self.cases[(x,y)] = c
@@ -245,7 +239,8 @@ class Plateau(QGraphicsScene):
         self.fenetre.connect(self.fenetre.ui.cp_formeEllipsePlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.cp_formeRectVide, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.cp_formeRectPlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
-
+        self.fenetre.connect(self.fenetre.ui.cp_effets, SIGNAL("activated (int)"), self.modeCaseEffet, Qt.UniqueConnection)
+        
 ##        self.fenetre.connect(self.fenetre.ui.effFeu, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
 ##        self.fenetre.connect(self.fenetre.ui.effEau, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
 ##        self.fenetre.connect(self.fenetre.ui.effGlace, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
@@ -255,13 +250,10 @@ class Plateau(QGraphicsScene):
         self.fenetre.connect(self.fenetre.ui.pi_deplacement, SIGNAL("clicked()"), self.majModeCombatDeplacement, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.pi_attaqueCac, SIGNAL("clicked()"), self.majModeCombatAttaqueCaC, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.pi_attaqueDist, SIGNAL("clicked()"), self.majModeCombatAttaqueDist, Qt.UniqueConnection)
-##        self.fenetre.connect(self.fenetre.ui.combatAttaqueZone, SIGNAL("clicked()"), self.fenetre.barreCombatZone, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.pi_attaqueZone, SIGNAL("clicked()"), self.majModeCombatZone, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.pi_formeAttaqueZone, SIGNAL("activated (int)"), self.majModeCombatZone, Qt.UniqueConnection)
 ##        self.fenetre.connect(self.fenetre.ui.pi_vol, SIGNAL("clicked()"), self.fenetre.barreCombatVol, Qt.UniqueConnection)
-##        self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("valueChanged(int)"), self.majZPion, Qt.UniqueConnection)
-##        self.fenetre.connect(self.fenetre.ui.combatZone_ligne, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
-##        self.fenetre.connect(self.fenetre.ui.combatZone_disque, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
-##        self.fenetre.connect(self.fenetre.ui.combatZone_cone, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
+        
         self.fenetre.connect(self.fenetre.ui.pi_finTour, SIGNAL("clicked()"), self.pionSuivant, Qt.UniqueConnection)
         #self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("editingFinished()"), self.majVisibiliteBarreCombat)
 
@@ -274,14 +266,12 @@ class Plateau(QGraphicsScene):
             kx = 0.866
         marge = 240    
         self.setSceneRect(0 - marge, 0 - marge, (kx*self.hCase*(self.nbCasesX+2)) + marge, (self.hCase*(self.nbCasesY+2)) + marge)
-        self.fenetre.ui.cbt_vue.setScene(self)
-        self.fenetre.ui.cbt_vue.scale(0.25, 0.25)
-        self.fenetre.ui.cbt_vue.centerOn(QPointF(0,0))
-        self.fenetre.ui.cbt_vue.setDragMode(1)
+        self.vue().setScene(self)
+        self.vue().scale(0.25, 0.25)
+        self.vue().centerOn(QPointF(0,0))
+        self.vue().setDragMode(1)
         self.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
         
-        #self.setItemIndexMethod(QGraphicsScene.NoIndex)
-        self.epaisseurPinceau = 1
         self.polygoneZonePlacement = None
         self.polygonesCaches = {}
         for i in range(1,5):
@@ -290,14 +280,8 @@ class Plateau(QGraphicsScene):
 
         #gestion du mode d'interaction avec le plateau
         self.modeActif = Modes.StandardCp(self)
-        self.modeActif_old = ""
         self.pinceau = Pinceau(self)
         self.proj = ProjectionDep(self)
-        self.modeParam = {"numPionSelectionne": 0, "creature": None, "decor": None, \
-                          "formeCoordEnCours": (0,0), \
-                          "zoneAttaqueCaC": [], "cibleAttaqueCaC": None, "cibleAttaqueDist": None, "pionCibleAttaqueDist": None, "ligneAttaqueDist": None, \
-                          "typeAttaqueZone": "", "formeAttaqueZone": None, "origineAttaqueZone": None, "point2AttaqueZone": None, \
-                          "listeCasesAttaqueZone": [], "ligneMireAttaqueZone": None}
   
         #mise a jour de l'interface de creation
         self.fenetre.majVisibilitePanneauxPlateau("creation")
@@ -316,7 +300,6 @@ class Plateau(QGraphicsScene):
         
         self.initListeOrdreJeu()
         self.initListeAttaques()
-##        self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(self.notes))
 
         self.fenetre.ui.pi_deplacement.setCheckable(True)
         self.fenetre.ui.pi_attaqueCac.setCheckable(True)
@@ -362,18 +345,12 @@ class Plateau(QGraphicsScene):
 ##        QApplication.processEvents()
         pass
 
-##    def majNotesPlateau(self):
-##        """les notes du plateau ont ete maj a l'ecran"""
-##        self.notes = str(self.fenetre.ui.notesMjPlateau.toPlainText().toUtf8())
-
     def agrandirNotesMjPlateau(self):
         """affiche les notes du plateau dans une QDialog, puis recupere les donnees qui y sont saisies"""
         affichageTexte = EcranAffichageTexte(self.notes)
         affichageTexte.setAttribute(Qt.WA_DeleteOnClose)
         r = affichageTexte.exec_()
         self.notes = affichageTexte.recupererTexte()
-##        self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(affichageTexte.recupererTexte()))
-
         
     ##### affichage de la liste des terrains enregistres, et fonctions d'acces aux donnees""""     
     def afficheEcranEditionTerrains(self, terrain = None):
@@ -541,44 +518,13 @@ class Plateau(QGraphicsScene):
                 
         self.majInfosAttaqueEC()
 
-
-    ########### affichage des curseurs personnalises ########
-    def curseurGomme(self):
-        self.fenetre.ui.cbt_vue.setDragMode(0)
-        curseurPix = QPixmap("img\\gomme.png")#.scaledToHeight(55, Qt.FastTransformation)
-        curseurGomme = QCursor(curseurPix, 0, 0)
-        self.fenetre.ui.cbt_vue.setCursor(curseurGomme)
-
-    def curseurEpee(self, valide = True):
-        self.fenetre.ui.cbt_vue.setDragMode(0)
-        if valide:
-            curseurPix = QPixmap("img\\curseurEpee.png")
-        curseurSeringue = QCursor(curseurPix, 0, 0)
-        self.fenetre.ui.cbt_vue.setCursor(curseurSeringue)
-
-    def curseurArc(self):
-        self.fenetre.ui.cbt_vue.setDragMode(0)
-        curseurPix = QPixmap("img\\arc.png")
-        curseurSeringue = QCursor(curseurPix, curseurPix.width(), 0)
-        self.fenetre.ui.cbt_vue.setCursor(curseurSeringue)
-
-    def curseurBaguette(self):
-        self.fenetre.ui.cbt_vue.setDragMode(0)
-        curseurPix = QPixmap("img\\baguette.png")
-        curseurBaguette = QCursor(curseurPix, curseurPix.width(), 0)
-        self.fenetre.ui.cbt_vue.setCursor(curseurBaguette)
-        
-    ############
-
     ##### activation des differents modes d'interaction avec le plateau et mises a jour des principaux parametres  #######
     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):
@@ -633,20 +579,10 @@ class Plateau(QGraphicsScene):
         """enclenche le mode copie de case"""
         self.activerMode(Modes.Pipette)
 
-    def modeCaseEffet(self):
-        """enclenche le mode de mise a jour de l'ffet actif des cases"""
-        origine = self.sender().objectName()
-        if origine == "effFeu":
-            effet = "brule"
-        elif origine == "effEau":
-            effet = "eau"
-        elif origine == "effGlace":
-            effet = "glace"   
-        elif origine == "effPoison":
-            effet = "poison"   
-        elif origine == "effEffacer":
-            effet = "aucun"   
-        self.activerMode(ModesCaseMaj, effet)
+    def modeCaseEffet(self, index):
+        """enclenche le mode de mise a jour de l'effet actif des cases"""
+        effets = ["brule", "eau", "glace", "poison", "aucun"]
+        self.activerMode(Modes.MajCasesEffet, effets[index])
 
     def modeCreationPion(self):
         """enclenche le mode de creation de pions simples"""
@@ -711,8 +647,14 @@ class Plateau(QGraphicsScene):
         self.modeActif.nouvelleAction(Actions.Distance)
 
     def majModeCombatZone(self):
-        if not len(self.modeParam["typeAttaqueZone"]) > 0: self.modeParam["typeAttaqueZone"] = "ligne"
-        self.modeActif.nouvelleAction(Actions.Ligne)      
+        if self.fenetre.ui.pi_formeAttaqueZone.currentIndex() == 0:
+            action = Actions.Ligne
+        elif self.fenetre.ui.pi_formeAttaqueZone.currentIndex() == 1:
+            action = Actions.Disque
+        elif self.fenetre.ui.pi_formeAttaqueZone.currentIndex() == 2:
+            action = Actions.Cone
+        if action:    
+            self.modeActif.nouvelleAction(action)      
 
     def majModeDefinirEntree(self):
         entree = EntreeSortie(self, "E")
@@ -1347,7 +1289,7 @@ class Plateau(QGraphicsScene):
         return retour        
 
     def pionsSurListeCase(self, listeCases):
-        """renvoie la liste des pions presents sur la liste de cases"""
+        """renvoie la liste des num des pions presents sur la liste de cases"""
         retour = []
         for coord in listeCases:
             pion = self.cases[coord].pionOccupant()