Refonte de la gestion de l'espace ok

Lignes de mires fonctionnelles
Panneaux d'info retravailles

Signed-off-by: olinox14 <olinox14@dmonde.fr>

.settings/org.eclipse.core.resources.prefs

@@ -14,9 +14,11 @@ encoding//lib/EcranEditionTerrain.py=utf-8
 encoding//lib/EcranFondPlateau.py=utf-8
 encoding//lib/EcranGestionCombat.py=utf-8
 encoding//lib/EcranSelectionPj.py=utf-8
+encoding//lib/EcranVol.py=utf-8
+encoding//lib/EntreeSortie.py=utf-8
 encoding//lib/Forme.py=utf-8
 encoding//lib/Modes.py=utf-8
-encoding//lib/Occupation.py=utf-8
+encoding//lib/ObjetAction.py=utf-8
 encoding//lib/Partie.py=utf-8
 encoding//lib/Pion.py=utf-8
 encoding//lib/Plateau.py=utf-8

lib/Actions.py

@@ -2,14 +2,14 @@
 # -*- coding: utf-8 -*-
 import sys
 
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from PyQt4.QtCore import Qt, QLineF, QPointF, QRectF, SIGNAL
+from PyQt4.QtGui import QPixmap, QCursor, QToolButton, QIcon, QGraphicsLineItem, \
+    QPen, QColor, QGraphicsEllipseItem, QGraphicsPolygonItem, QPolygonF, QDialog, \
+    QApplication
 
 import AEtoile
-from Combattant import Combattant
-from Decor import Decor
-from Pion import Pion
 import br
+from lib.dialogues import dmVol
 from lib.ui.ecran_attaqueZone import Ui_zne_fenetre
 import regles
 
@@ -189,7 +189,7 @@ class Deplacement(Action):
             self.recupZCible()
             self.creerChemin() 
         else:
-            if self.estValide() and self.plateau.proj.projectionValide():
+            if self.estValide() and self.plateau.proj.valide():
                 self.acteur().majPosition(self.plateau.proj.coord(), self.plateau.proj.nbRotations())
                 self.acteur().majZ(self._zCible)
                 super(Deplacement, self).valider()
@@ -215,8 +215,8 @@ class Deplacement(Action):
             self._chercheurChemin.arreter()
             self._chercheurChemin = None
             
-        if self.plateau.cases[self._coordCible].terrain.franchissable and not self.plateau.cases[self._coordCible].occupeeParCombattant():
-            self._chercheurChemin = AEtoile.Chemin(self.plateau, self.coordActeur(), self._coordCible, self.acteur().z, self._zCible)
+        if self.plateau.cases[self._coordCible].terrain.franchissable and not (self.plateau.cases[self._coordCible].occupant() > 0):
+            self._chercheurChemin = AEtoile.Chemin(self.plateau, self.coordActeur(), self._coordCible, self.acteur().zR, self._zCible)
             self._chemin = self._chercheurChemin.liste()
         self.afficherCibles(True)        
 
@@ -226,16 +226,16 @@ class Deplacement(Action):
             
     def afficherCibles(self, actif):
         compte = 0 ; coutTotal = 0 ; valide = True
-        z = self.plateau.cases[self.acteur().position].zDep()
+        z = self.plateau.cases[self.acteur().position].z1()
         for coord, cout in self._chemin:
             compte += 1 ; coutTotal += cout
             if actif:
                 if int(coutTotal) > self.acteur().pM(): valide = False
-                dz = self.plateau.cases[coord].zDep() - z
+                dz = self.plateau.cases[coord].z1() - z
                 self.plateau.cases[coord].majAffichageDeplacement(compte, valide, dz)
             else:
                 self.plateau.cases[coord].majAffichageDeplacement(0)
-            z = self.plateau.cases[coord].zDep()
+            z = self.plateau.cases[coord].z1()
             
     def envoiSignal(self):
         coutTotal = 0
@@ -244,7 +244,7 @@ class Deplacement(Action):
         print "{} s'est deplacé et a utilisé {} points de mouvement".format(self.acteur().txtId(), cout)
 
     def recupZCible(self):
-        self._zCible = self.acteur().z    
+        self._zCible = self.acteur().zR    
 
 
 class Vol(Deplacement):
@@ -264,7 +264,8 @@ class Vol(Deplacement):
         return "vol"
         
     def recupZCible(self):
-        nouveauZ = self.plateau.dialogueVol(self.acteur().z)
+        maxi = ((self.plateau.zP - self.acteur().h) if self.plateau.zP else None)
+        nouveauZ = dmVol(self.acteur().zR, maxi)
         self._zCible = nouveauZ 
 
 class Attaque(Action):
@@ -336,7 +337,26 @@ class Attaque(Action):
 
     def icone(self):
         return QIcon(self._icone)
- 
+
+    def ldmValide(self):
+        x0, y0 = self.acteur().position
+        z0 = self.plateau.cases[self.acteur().position].zA(self._num) + self.acteur().h
+        origine = (x0,y0,z0)
+        
+        #on essaie de cibler toutes les cases de la hauteur de la cible si c'est un pion
+        cibles = []
+        x1, y1 = self._coordCible
+        if self._pionCible:
+            for zA in self.plateau.cases[self._coordCible].hOcc(self._pionCible.numero):
+                cibles.append( (x1, y1, zA) )
+        else:
+            cibles = [(x1, y1, self.plateau.cases[self._coordCible].z0)]
+            
+        for cible in cibles:
+            if self.plateau.ldmValide(origine, cible): return True
+        return False
+
+
 class Cac(Attaque):
     """attaque au corps a corps"""
     def __init__(self):
@@ -415,7 +435,8 @@ class Distance(Attaque):
     def maj(self):
         """met a jour la ligne de mire representant l'attaque a distance"""
         self.afficherCibles(False)
-        pionCible = self.plateau.cases[self._coordCible].occupant()
+        numCible = self.plateau.cases[self._coordCible].occupant()
+        pionCible = self.plateau.pions[numCible]
         self.majItemsGraphiques()
         if pionCible != None and pionCible != self.plateau.pionSelectionne():
             self._pionCible = pionCible
@@ -424,12 +445,10 @@ class Distance(Attaque):
         self.afficherCibles(True)
 
     def estValide(self):
-        return self.plateau.estCibleAttaqueDistValide(self._coordCible)
+        return self.ldmValide()
 
     def afficherCibles(self, actif):
-        valide = True
-        if actif: valide = self.estValide()
-        
+        valide = self.estValide() if actif else True
         if self._pionCible:
             self._pionCible.estCibleAttaque(actif, valide)
         else:
@@ -437,11 +456,7 @@ class Distance(Attaque):
             self.plateau.cases[self._coordCible].majEstCibleCurseur(actif, valide)            
 
     def creerItemsGraphiques(self):
-        self._itemLigne = QGraphicsLineItem()
-        self._itemLigne.setZValue(100)
-        pinceau = QPen()
-        pinceau.setWidth(6)
-        self._itemLigne.setPen(pinceau)
+        self._itemLigne = itemLdm()
         self._itemLigne.prepareGeometryChange()
         self.plateau.addItem(self._itemLigne)
 
@@ -561,12 +576,12 @@ class Ligne(Zone):
         if not self._desactivationDemandee:
             self._casesCibles = []
             x1, y1 = self.acteur().position
-            z1 = self.acteur().zAbs() + self.acteur().hauteur
+            z1 = self.acteur().zA() + self.acteur().h
             x2, y2 = self._coordCible
             if self.plateau.cases[(x2, y2)].estOccupee():
-                z2 = self.plateau.cases[(x2, y2)].occupant().zAbs()
+                z2 = self.plateau.cases[(x2, y2)].occupant().zA()
             else:
-                z2 = self.plateau.cases[(x2, y2)].altitude   
+                z2 = self.plateau.cases[(x2, y2)].z0   
              
             for coord in br.ligne((x1, y1, z1), (x2, y2, z2)):
                 if coord != (x1, y1, z1):
@@ -575,14 +590,10 @@ class Ligne(Zone):
             if not self.estValide(): self._casesCibles = []
         
     def estValide(self):
-        retour = True
-        for coord in self._casesCibles:
-            x, y, z = coord
-            if not self.plateau.cases[(x, y)].estFranchissable(z):
-                if not isinstance(self.plateau.cases[(x, y)].occupant(z), Combattant):
-                    retour = False
-                    break
-        return retour
+        """la ligne est valide si toutes les cases cibles ne sont pas occupees par autre chose que des combattants"""
+        for x, y, zA in self._casesCibles:
+            if self.plateau.cases[(x, y)].occupant(zA) <= 0: return False 
+        return True
             
 class Disque(Zone):
     """attaque de zone de forme circulaire"""
@@ -616,9 +627,9 @@ class Disque(Zone):
     @autorise
     def majCibles(self):
         if self.plateau.cases[self._coordCible].estOccupee():
-            zCible = self.plateau.cases[self._coordCible].occupant().zAbs()
+            zCible = self.plateau.cases[self._coordCible].occupant().zA()
         else:
-            zCible = self.plateau.cases[self._coordCible].altitude   
+            zCible = self.plateau.cases[self._coordCible].z0   
         self._casesCibles = self.plateau.zone3d(self._coordCible, self._rayon, zCible)
 
     def afficherCibles(self, actif):
@@ -644,7 +655,7 @@ class Disque(Zone):
         self._itemCible.setVisible(self.estValide() and rect != None)
 
     def estValide(self):
-        return self.plateau.estCibleAttaqueDistValide(self._coordCible)
+        return self.ldmValide()
 
     @autorise
     def rectEllipseCirculaire(self, centre, rayon):
@@ -675,11 +686,11 @@ class Cone(Zone):
 
     def majCibles(self):
         if self.plateau.cases[self._coordCible].estOccupee():
-            zCible = self.plateau.cases[self._coordCible].occupant().zAbs()
+            zCible = self.plateau.cases[self._coordCible].occupant().zA()
         else:
-            zCible = self.plateau.cases[self._coordCible].altitude   
+            zCible = self.plateau.cases[self._coordCible].z0   
         self._casesCibles = self.plateau.cone3d(self.acteur().position, self._coordCible, \
-                                                (self.acteur().z + self.acteur().hauteur), zCible)
+                                                (self.acteur().zR + self.acteur().h), zCible)
         
     def creerItemsGraphiques(self):
         self._itemCible = QGraphicsPolygonItem()
@@ -745,9 +756,17 @@ class EcranAttaqueZone(QDialog):
     def annuler(self):
         self.done(0)     
 
-
-
-
+def itemLdm():
+    """retourne l'item graphique utilise pour les lignes de mire"""
+    item = QGraphicsLineItem()
+    item.setZValue(100)
+    pinceau = QPen()
+    pinceau.setColor(QColor(249, 249, 249))
+    pinceau.setStyle(Qt.DashDotLine)
+    pinceau.setWidth(6)
+    item.setPen(pinceau)
+    return item
+    
 
 
 if __name__ == "__main__":

lib/Case.py

@@ -3,16 +3,15 @@
 from __future__ import division
 
 from PyQt4.QtCore import Qt, SIGNAL, QPointF, QString, QRectF
-from PyQt4.QtGui import QGraphicsPolygonItem, QColor, QGraphicsItem, QPolygonF, \
+from PyQt4.QtGui import QGraphicsPolygonItem, QColor, QGraphicsItem, \
     QGraphicsSimpleTextItem, QBrush, QPen, QRadialGradient, QFont, qRed, \
     qGreen, qBlue, QGraphicsEllipseItem, QGraphicsTextItem, QTextBlockFormat, \
     QTextCursor
 
 import Modes
 from Pion import Pion
-from Decor import Decor
-from Combattant import Combattant
 from Terrain import Terrain
+from lib.dmF import DmPile
 
 
 class Case(QGraphicsPolygonItem):
@@ -25,12 +24,13 @@ class Case(QGraphicsPolygonItem):
         #attributs
         self.x = 0
         self.y = 0        
-        self.altitude = 0                   
+        self.z0 = 0                   
         self.terrain = Terrain()                       #terrain par defaut 
         self.bordure = QColor(85, 85, 85, 85)          #couleur de la bordure par defaut
         self.centreGraphique = None
 
-        self.occupation = {}    #z: num pion
+#         self._occ = {}   #zA: num du pion
+        self._occ = DmPile()
         self.caches = []       #liste des caches places par le MJ sur la case (cache le terrain, les decors, les pions aux joueurs...)
 
         #effet sur la case 
@@ -45,14 +45,14 @@ class Case(QGraphicsPolygonItem):
 
     def __getstate__(self):
         """selectionne les attributs qui seront sauvegardes"""
-        state = {key:value for key, value in self.__dict__.items() if key in ["x", "y", "altitude","terrain","bordure","couleur", \
+        state = {key:value for key, value in self.__dict__.items() if key in ["x", "y", "z0","terrain","bordure","couleur", \
                                                                               "ombre", "effetActif", "caches"]}
-
         return (state)
 
     def __setstate__(self, state):
         """recupere les attributs sauvegardes"""
         self.__dict__ = state
+#         if self.z0 == None: self.z0 = 0
         
     ######## fonctions de base : geometrie, aspect graphique      ######
     def creer(self, x, y, couleur = QColor(0, 255, 0, 80)):
@@ -71,7 +71,8 @@ class Case(QGraphicsPolygonItem):
 
         #enregistrement des cases voisines: 
         self.voisins = self.lstVoisins(self.x, self.y)
-        self.occupation = {}
+#         self._occ = {}
+        self._occ = DmPile()
    
         #enregistrement du centre
         if self.plateau.formeCases == "H":  #refPlateau
@@ -82,7 +83,7 @@ class Case(QGraphicsPolygonItem):
             self.centreGraphique = QPointF((self.x+0.5)*self.plateau.hCase, (self.y+0.5)*self.plateau.hCase)
         
         #cree le polygone de la case
-        self.setPolygon(self.polygone(self.x, self.y))
+        self.setPolygon(self.polygone())
         self.plateau.addItem(self)  #refPlateau
         
         #interactions graphiques:
@@ -103,10 +104,14 @@ class Case(QGraphicsPolygonItem):
         self.majTerrain(self.terrain)            
 
         #polygone utilise pour afficher la cible du curseur
-        self.polygoneCible = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
-        self.polygoneCible.setVisible(False)
-        self.polygoneCible.setAcceptHoverEvents(False)
-        
+        self.maille = Maille(self)
+        self.maille.creer()
+#         self.polygoneCible = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
+#         self.polygoneCible = QGraphicsPolygonItem(self.polygone(self.x, self.y))
+#         self.polygoneCible.setVisible(False)
+#         self.polygoneCible.setAcceptHoverEvents(False)
+#         self.polygoneCible.setZValue(100)
+#         self.plateau.addItem(self.polygoneCible)
         #cache
         self.polygoneCache = PolygoneCache(self)
         self.polygoneCache.creer()
@@ -125,25 +130,28 @@ class Case(QGraphicsPolygonItem):
         self.majTerrain(self.terrain)   
         self.majEffet(self.effetActif)
 
-    def polygone(self, x, y):
-        """renvoie l'objet graphique hexagone de la case"""
-        polygone = QPolygonF()
-        if self.plateau.formeCases == "H":
-            #si x est impair sur un plateau a cases hexagonales, le y est augmente de 0.5
-            if 1 == (x % 2):
-                y += 0.5
-            polygone  << QPointF(((x*0.866)+0.2886)*self.plateau.hCase,  y*self.plateau.hCase) \
-                      << QPointF(((x*0.866)+0.866)*self.plateau.hCase,   y*self.plateau.hCase) \
-                      << QPointF(((x*0.866)+1.1547)*self.plateau.hCase, (y+0.5)*self.plateau.hCase) \
-                      << QPointF(((x*0.866)+0.866)*self.plateau.hCase,  (y+1)*self.plateau.hCase) \
-                      << QPointF(((x*0.866)+0.2886)*self.plateau.hCase, (y+1)*self.plateau.hCase)  \
-                      << QPointF( (x*0.866)*self.plateau.hCase,         (y+0.5)*self.plateau.hCase)
-        else:
-            polygone  << QPointF(x*self.plateau.hCase,      y*self.plateau.hCase) \
-                      << QPointF((x+1)*self.plateau.hCase,  y*self.plateau.hCase) \
-                      << QPointF((x+1)*self.plateau.hCase,  (y+1)*self.plateau.hCase) \
-                      << QPointF(x*self.plateau.hCase,      (y+1)*self.plateau.hCase)          
-        return polygone
+    def polygone(self):
+        return self.plateau.polygone(self.x, self.y)
+
+#     def polygone(self, x, y):
+#         """renvoie l'objet graphique hexagone de la case"""
+#         polygone = QPolygonF()
+#         if self.plateau.formeCases == "H":
+#             #si x est impair sur un plateau a cases hexagonales, le y est augmente de 0.5
+#             if 1 == (x % 2):
+#                 y += 0.5
+#             polygone  << QPointF(((x*0.866)+0.2886)*self.plateau.hCase,  y*self.plateau.hCase) \
+#                       << QPointF(((x*0.866)+0.866)*self.plateau.hCase,   y*self.plateau.hCase) \
+#                       << QPointF(((x*0.866)+1.1547)*self.plateau.hCase, (y+0.5)*self.plateau.hCase) \
+#                       << QPointF(((x*0.866)+0.866)*self.plateau.hCase,  (y+1)*self.plateau.hCase) \
+#                       << QPointF(((x*0.866)+0.2886)*self.plateau.hCase, (y+1)*self.plateau.hCase)  \
+#                       << QPointF( (x*0.866)*self.plateau.hCase,         (y+0.5)*self.plateau.hCase)
+#         else:
+#             polygone  << QPointF(x*self.plateau.hCase,      y*self.plateau.hCase) \
+#                       << QPointF((x+1)*self.plateau.hCase,  y*self.plateau.hCase) \
+#                       << QPointF((x+1)*self.plateau.hCase,  (y+1)*self.plateau.hCase) \
+#                       << QPointF(x*self.plateau.hCase,      (y+1)*self.plateau.hCase)          
+#         return polygone
 
     def lstVoisins(self, x, y):
         """renvoie la liste des cases voisines
@@ -175,91 +183,87 @@ class Case(QGraphicsPolygonItem):
         else:
             self.etiquette.setText(QString().fromUtf8(str(txt)))
       
-    
      
     ########################
-
-    ### deplacement
-#     def coutDep(self):
-#         #a implementer, en fonction des
-#         #capacites de deplacement du pion actuellement selectionne
-#         return 1
-
-    def zDep(self):
-        """retourne le z utilise pour le calcul des deplacements, 
-        cad l'altitude de la case plus la hauteur d'un eventuel decor pose au sol"""
-        decor = self.occupant(0, Decor)
-        zDecor = decor.hauteur if decor else 0 
-        return self.altitude + zDecor
         
     ### occupation
-    def occuper(self, numPion, z = 0):
-        """un pion vient occuper la case a l'altitude z"""
-        self.occupation[z] = numPion
-
-    def liberer(self, z):
-        """aucun pion n'occupe plus la case a l'altitude z"""
-        if z in self.occupation:
-            del self.occupation[z]
-            
-    def estOccupee(self, z=None):
-        """renvoie vrai si la case correspondant a la hauteur z est occupee"""
-        if z:
-            retour = (z in self.occupation) 
-        else:
-            retour = len(self.occupation) > 0
-        return retour       
-
-    def occupant(self, z=None, classe = Pion):
-        """si la case correspondant a la hauteur z est occupee, renvoie l'objet en question
-           sinon renvoie None"""
-        num = None
-        if z:
-            if z in self.occupation:
-                num = self.occupation[z]   
-        else:
-            #si aucune altitude n'est donnee, renvoie le premier occupant
-            for z in self.occupation:
-                num = self.occupation[z]
-                break
-        retour = None
-        if num:
-            retour = self.plateau.pions[num]
-
-        if retour:
-            if not isinstance(retour, classe): retour = None        
-        return retour                          
-
-    def occupeeParCombattant(self):
-        """la case est occupee par un combattant - on ne peut pas s'y deplacer"""
-        for idPion in self.occupation.values():
-            if idPion < 10000: return True
-        return False
-
-    def estFranchissable(self, zAbs = None):
-        """a l'altitude absolue demandee, 
-        la case est-elle franchissable ** pour une ligne de mire **"""
-        if not zAbs: zAbs = self.altitude
-        return (not self.estOccupee( (zAbs - self.altitude) ) and (zAbs >= self.altitude))
+    def z0(self):
+        """altitude du terrain nu """
+        if self.terrain.hPlafond: return None
+        return self.z0
 
+    def zP(self):
+        return self.plateau.zP if self.plateau.zP != None else 100 
+    
+    def z1(self):
+        """premiere altitude ABSOLUE disponible
+           altitude z0 de la case, augmentee de la hauteur des decors empiles dessus;
+           None si aucune altitude disponible"""
+        if self.terrain.hPlafond: return None
+        z1 = (self.z0 + self._occ.hauteur())
+        if z1 >= self.zP(): return None
+        return z1
+
+    def occuper(self, num, h):
+        """un pion vient occuper la case a l'altitude relative zR"""
+        if h == 100: h = self.zP() - self.z0
+        self._occ.ajouter(num, h)
+
+    def liberer(self, num):
+        """aucun pion n'occupe plus la case a l'altitude relative zR"""
+        self._occ.retirer(num)
+
+    def occupants(self):
+        """renvoie la liste des occupants de la case"""
+        return self._occ.pile()
+
+    def occupant(self, zA = None):
+        """renvoie l'occupant de la case a l'altitude ABSOLUE zA: 
+            - le numero du pion s'il y en a un
+            - 0 si sous le sol ou au dessus du plafond
+            - sinon None"""
+        #1 - si pas d'altitude, on renvoie l'occupant du dessus s'il existe
+        if not zA: return self._occ.premier()
+        #2 - si au dessous du sol ou au dessus du plafond:
+        if zA < self.z0 or zA >= self.zP(): return 0
+        #3 - on renvoie l'objet de la pile s'il existe 
+        #    (!!! attention, la pile fonctionne avec des altitudes relatives)
+        return self._occ[(zA - self.z0)]
+            
+    def estOccupee(self, zA):
+        """renvoie vrai si la case est occupee a l'altitude absolue zA"""
+        return (self.occupant(zA) != None)
+    
+    def occupation(self):
+        return self._occ
+    
+    def zA(self, num):
+        """renvoie l'altitude absolue de l'occupant s'il existe, None sinon"""
+        if not num in self.occupants(): return None
+        return self.z0 + self._occ.zR(num)
+    
+    def hOcc(self, num):
+        """renvoie la liste des altitudes absolues occupees poar le pion s'il existe,
+           une liste vide sinon"""
+        zA = self.zA(num)
+        if not zA != None: return []
+        return range(zA, (zA + self._occ.hDe(num)))
+    
     ########## fonctions de maj ###########
     def majTerrain(self, terrain = Terrain()):
         """met a jour le terrain de la case"""
         self.terrain = terrain
-        if self.terrain.imgTexture.estValide():
-            self.setBrush(QBrush(self.terrain.imgTexture.pix()))
-        else:
-            if self.terrain.couleur.isValid():
-                self.setBrush(QBrush(self.terrain.couleur))
+        if self.terrain.couleur.isValid():
+            self.setBrush(QBrush(self.terrain.couleur))
         pinceau = QPen()
         pinceau.setColor(self.couleurBordure())
         pinceau.setWidth(1)
         self.setPen(pinceau)
 
-    def majAltitude(self, altitude):
+    def majAltitude(self, z0):
         """met a jour l'altitude de la case"""
-        self.altitude = altitude  
-#         self.afficherEtiquette(altitude)   
+        if z0 > self.zP(): z0 = self.zP()
+        self.z0 = z0  
 
     def majAffichageDeplacement(self, cout, valide = True, dz = 0):
         """lorsque cette case est sur le chemin d'un pion,
@@ -270,25 +274,23 @@ class Case(QGraphicsPolygonItem):
 
     def majEstCibleCurseur(self, actif, valide=True):
         """affiche la case comme etant la cible du curseur (lors d'une creation de pion, d'un deplacement...)"""
-        if actif:
-            pinceau = QPen()
-            pinceau.setWidth(5)
-            brush = QBrush()
-            brush.setStyle(13)
-            pinceau.setColor(self.couleurProj(valide))
-            brush.setColor(self.couleurProj(valide))
-            self.polygoneCible.setPen(pinceau)
-            self.polygoneCible.setBrush(brush)
-            self.setZValue(99)
-        else:
-            self.setZValue(0)
-        self.polygoneCible.setVisible(actif)    
+        self.maille.afficher(actif, valide)
+#         if actif:
+#             pinceau = QPen()
+#             pinceau.setWidth(5)
+#             brush = QBrush()
+#             brush.setStyle(13)
+#             pinceau.setColor(self.couleurProj(valide))
+#             brush.setColor(self.couleurProj(valide))
+#             self.polygoneCible.setPen(pinceau)
+#             self.polygoneCible.setBrush(brush)
+#         self.polygoneCible.setVisible(actif)    
             
     def majEffet(self, effet):
         """met a jour l'effet actif sur la case"""       
         if self.polygoneEffet == None:
             #on cree le polygone utilise pour afficher les effets
-            self.polygoneEffet = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
+            self.polygoneEffet = QGraphicsPolygonItem(self.polygone(), parent=self)
             pinceau = QPen()
             pinceau.setColor(self.bordure)
             pinceau.setWidth(1)
@@ -396,26 +398,110 @@ class Case(QGraphicsPolygonItem):
         return QColor(r_moy, v_moy, b_moy)
 
     ######### evenements souris et clavier    #################
-    def mousePressEvent(self, event):
+    #recuperes  depuis la maille
+    #la case recoit d'abord l'evenement
+    #si elle ne l'a pas accepte, les pions le recoivent par ordre d'empilement,
+    def _mousePressEvent(self, event):
         """evenement lors du clic souris"""
-        super(Case, self).mousePressEvent(event)
+#         super(Case, self).mousePressEvent(event)
+        if event.button() == 1:
+            if self.plateau.clic_case((self.x, self.y)): return True
+            for num in self.occupants():                
+                if self.plateau.clic_pion(num): return True
+        return False
+ 
+    def _hoverEnterEvent(self, event):
+        """met a jour l'affichage de la case au survol de la souris, si un pion est selectionne"""
+#         super(Case, self).hoverEnterEvent(event)
+        if not self.estCachee() or issubclass(self.plateau.modeActif.__class__, Modes.ModeBaseCp):
+            if self.plateau.survol_case((self.x, self.y)): return True
+            for num in self.occupants():
+                if self.plateau.survol_pion(num): return True
+        return False
+ 
+    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)
+        if not self.estCachee() or issubclass(self.plateau.modeActif.__class__, Modes.ModeBaseCp):
+            if self.plateau.finSurvol_case((self.x, self.y)): return True
+            for num in self.occupants():
+                if self.plateau.finSurvol_pion(num): return True            
+        return False
+
+    def _mouseDoubleClickEvent(self, event):
+        """evenement lors du double-clic souris"""
+        super(Pion, self).mouseDoubleClickEvent(event)
         if event.button() == 1: #sur clic gauche
-            accepte = self.plateau.caseCliquee(self.x, self.y)  #refPlateau
-            if accepte: event.accept()
+            if self.plateau.doubleClic_pion(self.numero): return True
+        return False
+
+    ########################
+
+
+class Maille(QGraphicsPolygonItem):
+    """clone de la case place au dessus des autres items, 
+    et permettant aux cases de recevoir prioritairement certains signaux, 
+    meme lorsqu'elles sont cachees sous des pions, caches...Etc"""
+    def __init__(self, case, parent = None):
+        super(Maille, self).__init__()    
+        self._case = case
+        self._actif = False
+
+    def coord(self):
+        return (self._case.x, self._case.y)
+
+    def paint(self, *args):
+        if not self._actif: return
+        return super(Maille, self).paint(*args)
+    
+    def creer(self):    
+        self.setPolygon(self._case.polygone())
+#         self.setVisible(False)
+        self.setAcceptHoverEvents(True)
+        self.setZValue(100)
+        self._case.plateau.addItem(self)
+        self.afficher(False)
+
+    def afficher(self, actif, valide = True):
+        self._actif = actif
+        pinceau = QPen()
+        brush = QBrush()
+        if actif:
+            pinceau.setWidth(5)
+            pinceau.setColor(self._case.couleurProj(valide))
+            brush.setStyle(13)
+            brush.setColor(self._case.couleurProj(valide))
+        self.setPen(pinceau)
+        self.setBrush(brush)
+
+    def mousePressEvent(self, event):
+        """evenement lors du clic souris"""
+        accepte = self._case._mousePressEvent(event)
+        if accepte:
+            event.accept()
         else:
             event.ignore()
-
+        super(Maille, self).mousePressEvent(event)
+ 
     def hoverEnterEvent(self, event):
         """met a jour l'affichage de la case au survol de la souris, si un pion est selectionne"""
-        super(Case, self).hoverEnterEvent(event)
-        if not self.estCachee() or issubclass(self.plateau.modeActif.__class__, Modes.ModeBaseCp):
-            self.plateau.caseSurvol(self.x, self.y)
-
+        accepte = self._case._hoverEnterEvent(event)
+        if accepte:
+            event.accept()
+        else:
+            event.ignore()
+        super(Maille, self).hoverEnterEvent(event)
+ 
     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)
+        accepte = self._case._hoverLeaveEvent(event)
+        if accepte:
+            event.accept()
+        else:
+            event.ignore()
+        super(Maille, self).hoverLeaveEvent(event)
     
-    ########################
+      
 
 class LogoDep(QGraphicsEllipseItem):
     """logo utilise pour afficher le chemin que va suivre le pion lors d'un deplacement"""
@@ -494,11 +580,11 @@ class PolygoneCache(QGraphicsPolygonItem):
         self.case.plateau.fenetre.connect(self.case.plateau.fenetre.ui.cbt_vue, SIGNAL("zoomChange(int)"), self.zoomChange)
         
     def creer(self):
-        polygone = self.case.polygone(self.case.x, self.case.y)
+        polygone = self.case.polygone()
         self.setPolygon(polygone)
         self.majTransparence()
         self.setTransformOriginPoint(self.case.centreGraphique)
-        self.setZValue(100)
+        self.setZValue(98)
         self.setVisible(False)
         self.setScale(1.05)
 #         self.setAcceptHoverEvents(True)

lib/Combattant.py

@@ -17,6 +17,8 @@ class Combattant(Pion, Materiel):
         self.depVol = regles.valeurDefaut("depVol")
         self.saut = regles.valeurDefaut("saut")
         
+        self.enVol = False   #mode vol active?
+        
         self.attaques = []   #liste des attaques pre-parametrees du pion
         self.listeAttributs = regles.listeAttributs()
         self.inventaire = []
@@ -24,8 +26,31 @@ class Combattant(Pion, Materiel):
         self.notes = ""        
 
         #caracs liees au combat:
-        self.etat = ""
         self.deplacementRestant = 0        
+        
+    def ajouterAuPlateau(self, plateau):
+#         self.plateau = plateau
+        super(Combattant, self).ajouterAuPlateau(plateau)
+        self.majEtiquette()
+
+    def projectionValide(self, proj):
+        if not super(Combattant, self).projectionValide(proj): return False
+        #on ajoute des criteres de validite supplementaires lies aux combattants
+        lst = proj.listeCases()
+        lstH = []
+        for case in lst:
+            lstH.append(case.z1())
+            #4- si le pion vole, c'est ok ici:
+            if self.enVol: return True
+            #5- sinon, selon possibilites de deplacement au sol du pion
+            if not case.terrain.franchissable: return False
+            if case.terrain.nage:
+                if not self.depNage > 0: return False
+            else:
+                if not self.depMarche > 0: return False
+        #fin: la difference de hauteur entre les cases n'excede pas la hauteur du pion -1
+        if (max(lstH) - min(lstH)) > (self.h - 1): return False
+        return True
 
     def pM(self):
         """les points de mouvement"""
@@ -33,47 +58,37 @@ class Combattant(Pion, Materiel):
 
     def coutDep(self, typeDep, dist = 1):
         """renvoie le cout en PM pour effectuer ce deplacement"""
-        retour = 1
-        if typeDep in self.__dict__:
-            dep = self.__dict__[typeDep]
-            if dep > 0:
-                cout = self.pM() / dep
-                retour = dist * cout
-            else:
-                retour = -1
-        return retour
+        if not typeDep in self.__dict__: return 1
+        dep = self.__dict__[typeDep] if typeDep in self.__dict__ else 0
+        if dep > 0:
+            cout = self.pM() / dep
+            return dist * cout
+        else:
+            return -1
             
     def listeAttaques(self):
         return self.attaques
- 
-
-    
-    def ajouterAuPlateau(self, plateau):
-        self.plateau = plateau
-        super(Combattant, self).ajouterAuPlateau(self.plateau)
-        self.majEtiquette()
 
     def estCache(self):
-        """met a jour le combattant selon qu'il est cache ou non"""
-        for x, y, z in self.casesOccupees():
-            coord = (x, y)
-            if not self.plateau.cases[coord].estCachee(): return False
+        """met a jour le combattant selon qu'il soit cache ou non"""
+        for x, y in self.coordOccupees():
+            if not self.plateau.cases[(x, y)].estCachee(): return False
         return True
 
     def hoverEnterEvent(self, event):
         """evenement lors du survol de la souris (en entree)"""
-        self.plateau.combattantSurvol(self.numero)
-        event.ignore()
+        self.plateau.survol_combattant(self.numero)
+#         event.ignore()
 
     def hoverLeaveEvent(self, event):
         """evenement lors du survol de la souris (en entree)"""
-        self.plateau.combattantFinSurvol(self.numero)
+        self.plateau.finSurvol_combattant(self.numero)
 
     def mousePressEvent(self, event):
         """evenement lors du clic souris"""
         super(Pion, self).mousePressEvent(event)
         if event.button() == 1: #sur clic gauche
-            accepte = self.plateau.pionClique(self.numero)
+            accepte = self.plateau.clic_combattant(self.numero)
             if accepte: event.accept()
         else:
             event.ignore()
@@ -82,7 +97,7 @@ class Combattant(Pion, Materiel):
         """evenement lors du clic souris"""
         super(Pion, self).mouseDoubleClickEvent(event)
         if event.button() == 1: #sur clic gauche
-            accepte = self.plateau.pionDoubleClic(self.numero)
+            accepte = self.plateau.doubleClic_combattant(self.numero)
             if accepte: event.accept()
         else:
             event.ignore()

lib/Decor.py

@@ -12,26 +12,23 @@ class Decor(Pion, Materiel):
         self.numero = -1
         self.escalade = False            #peut etre escalade
         self.inflammable = False               #peut prendre feu
-        self.hauteurMax = False          #la hauteur doit etre calculee pour atteindre le plafond (s'il existe)
         self.inventaire = []
         self.details = {}
 
     def ajouterAuPlateau(self, plateau):
         self.plateau = plateau
+        #s'il y a un plafond et que le decor a la prop hauteurMax, sa hauteur est mise a jour en consequence
+        if plateau.zP and self.hMax: self.h = 100
         super(Decor, self).ajouterAuPlateau(self.plateau)
-        
-    def hoverEnterEvent(self, event):
-        """evenement lors du survol de la souris (en entree)""" 
-        self.plateau.caseSurvol(self.position[0], self.position[1])
-        self.plateau.decorSurvol(self.numero)
+        self.setZValue(10)
 
-    def hoverLeaveEvent(self, event):
-        """evenement lors du survol de la souris (en sortie)"""
-        self.plateau.decorFinSurvol(self.numero)
-
-    def mousePressEvent(self, event):
-        """evenement lors du clic souris"""
-        if event.button() == 1: #sur clic gauche
-            self.plateau.pionClique(self.numero)
-        else:
-            event.ignore()       
+    def projectionValide(self, proj):
+        if not super(Decor, self).projectionValide(proj): return False
+        #on ajoute des criteres de validite supplementaires lies aux decors
+        #les decors doivent etre sur des cases d'altitudes egales
+        lst = proj.listeCases()
+        z1 = None
+        for case in lst:
+            if z1 == None: z1 = case.z1()
+            if case.z1() != z1: return False   
+        return True    

lib/EcranAltitude.py

@@ -1,42 +0,0 @@
-#from __future__ import unicode_literals
-# -*- coding: utf-8 -*-
-import sys
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from ui.ecran_altitude import Ui_alt_fenetre
-
-class EcranAltitude(QDialog):
-    """interface de gestion du vol d'un pion
-        renvoie la nouvelle altitude du pion"""
-    def __init__(self, parent=None):
-        """initialisation de la fenetre"""
-        super (EcranAltitude, self).__init__(parent)
-        self._resultat = 0
-        self.createWidgets()
-          
-    def createWidgets(self):
-        """construction de l'interface"""
-        #construction de l'interface
-        self.ui = Ui_alt_fenetre()
-        self.ui.setupUi(self)                                                          
-        self.connect(self.ui.alt_ok, SIGNAL("clicked()"), self.ok)
-        self.ui.alt_valeur.selectAll()
-
-    def resultat(self):
-        return self._resultat
-
-    def ok(self):
-        """enregistre le terrain cree/edite"""
-        self._resultat = self.ui.alt_valeur.value()
-        self.done(1)
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    ecran = EcranAltitude()
-    ecran.show()
-    r = app.exec_()
-    print ecran.resultat()
-    exit(r)  
-
-
- 

lib/EcranCreerPlateau.py

@@ -29,6 +29,7 @@ class EcranCreerPlateau(QDialog):
         self.connect(self.ui.crp_largeur, SIGNAL("valueChanged(int)"), self.majListeDimensions)
         self.connect(self.ui.crp_hauteur, SIGNAL("valueChanged(int)"), self.majListeDimensions)
         
+        self.connect(self.ui.crp_plafond, SIGNAL("toggled(bool)"), self.majAffichage)
         self.connect(self.ui.crp_nom, SIGNAL("textEdited(QString)"), self.majAffichage)
         
         self.connect(self.ui.crp_ok, SIGNAL("clicked()"), self.finir)
@@ -38,8 +39,10 @@ class EcranCreerPlateau(QDialog):
         """affiche la fenetre avec le plateau en parametre, ou un nouveau plateau sinon"""
         self.ui.crp_nom.majTexte(plateau.nom())
         self.ui.crp_chapitre.setValue(int(plateau.chapitre))
-        self.ui.crp_description.majTexte(plateau.description)
         self.ui.crp_presentation.majTexte(plateau.presentation)
+        if plateau.zP != None:
+            self.ui.crp_plafond.setChecked(True)
+            self.ui.crp_zP.setValue(plateau.zP)
         
         nouveau = (plateau.nbCasesX == 0)
         self.ui.crp_formes.setEnabled(nouveau)
@@ -58,7 +61,6 @@ class EcranCreerPlateau(QDialog):
         """renvoie le plateau ainsi parametre"""
         self._retour.majNom(self.ui.crp_nom.texte())
         self._retour.chapitre = str(self.ui.crp_chapitre.value())
-        self._retour.description = self.ui.crp_description.texte()
         self._retour.presentation = self.ui.crp_presentation.texte()
         self._retour.couleurInit = self.couleur
         
@@ -77,13 +79,16 @@ class EcranCreerPlateau(QDialog):
                                                QMessageBox.No, QMessageBox.No)
                 if reponse == QMessageBox.No: return
 
+        if self.ui.crp_plafond.isChecked():
+            self._retour.zP = self.ui.crp_zP.value()
+
         return self._retour
        
     def majAffichage(self):
+        self.ui.crp_zP.setEnabled(self.ui.crp_plafond.isChecked())
         self.ui.crp_ok.setEnabled(len(self.ui.crp_nom.texte()) > 0)
         self.ui.crp_ok.setDefault(len(self.ui.crp_nom.texte()) > 0)
         
-        
     def selectionCouleur(self):
         """selectionne la couleur dans la boite de dialogue dediee"""
         couleur = QColorDialog(self).getColor(QColor("white"), self)
@@ -113,4 +118,7 @@ class EcranCreerPlateau(QDialog):
             self._majEnCours = False
 
     def finir(self):
-        self.done(1)
+        self.done(1)
+        
+        
+        

lib/EcranEditionMateriel.py

@@ -178,12 +178,12 @@ class EdEnTete(EdSectionBase):
         self._filtre = ["cb", "dc"]
         
     def construire(self):
-        self.ecran.connect(self.ui().edm_nom, SIGNAL("textEdited(QString)"), self.ecran.nomModifie)
-        self.ecran.connect(self.ui().edm_logo, SIGNAL("clicked()"), self.selectionnerLogo)
+        if self.ecran.mode() == "creation":
+            self.ecran.connect(self.ui().edm_logo, SIGNAL("clicked()"), self.selectionnerLogo)
+            self.ecran.connect(self.ui().edm_nom, SIGNAL("textEdited(QString)"), self.ecran.nomModifie)
+        else:
+            self.ui().edm_nom.setEnabled(False)
         self.majLibelleMode()
-#         couleur = "rgb(250,100,50)" if self.ecran.mode() == "combat" else "rgb(20,100,250)"
-#         self.ui().edm_enTete.setStyleSheet(QString("#edm_enTete {border-bottom: 3px solid "+couleur+";}"))
-#         self.ui().edm_enTete.setStyleSheet(QString("#edm_enTete {background-color: "+couleur+";}"))
 
     def majLibelleMode(self):
         if self.mat().typ() == "cb":
@@ -252,7 +252,7 @@ class EdPageCreation(EdSectionBase):
         self.vueForme.chargerEtiquetteDef(self.mat().etiquette)
 
     def logoModifie(self):
-        self.vueForme.nouvelleImageDef(self.ui.edm_logo.image())
+        self.vueForme.nouvelleImageDef(self.ui().edm_logo.image())
 
     def selectionImage(self):
         """selectionne le fichier image dans la boite de dialogue dediee"""
@@ -262,7 +262,7 @@ class EdPageCreation(EdSectionBase):
         
     def selectionCouleur(self):
         """selectionne la couleur dans la boite de dialogue dediee"""
-        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        couleur = QColorDialog(self.ecran).getColor(QColor("white"), self.ecran)
         if couleur.isValid():
             self.mat().couleur = couleur
             self.vueForme.majCouleur(couleur)
@@ -308,6 +308,7 @@ class EdPageCombat(EdSectionBase):
         #statuts
         if self.mat().typ() == "dc":
             self.ui().edm_statut0.setVisible(False)
+            self.ui().edm_statut1.setVisible(False)
             self.ui().edm_statut2.setVisible(False)
             self.ui().edm_statut3.setVisible(False)
             self.ui().edm_effets.setVisible(False);self.ui().edm_effets_lbl.setVisible(False)
@@ -340,7 +341,7 @@ class EdPageDeplacement(EdSectionBase):
         self._filtre = ["cb"]
         
     def charger(self):
-        self.ui().edm_taille.setValue(self.mat().hauteur)
+        self.ui().edm_taille.setValue(self.mat().h)
         self.ui().edm_depMarche.setValue(self.mat().depMarche)
         self.ui().edm_depNage.setValue(self.mat().depNage)
         self.ui().edm_depEscalade.setValue(self.mat().depEscalade)
@@ -348,7 +349,7 @@ class EdPageDeplacement(EdSectionBase):
         self.ui().edm_saut.setValue(self.mat().saut)      
     
     def enregistrer(self):
-        self.mat().hauteur = self.ui().edm_taille.value()
+        self.mat().h = self.ui().edm_taille.value()
         self.mat().depMarche = self.ui().edm_depMarche.value()
         self.mat().depNage = self.ui().edm_depNage.value()
         self.mat().depEscalade = self.ui().edm_depEscalade.value()
@@ -361,14 +362,14 @@ class EdPageProprietes(EdSectionBase):
         self._filtre = ["dc"]
         
     def charger(self):
-        self.ui().edm_hauteur.setValue(self.mat().hauteur)
-        self.ui().edm_hauteurPlafond.setChecked(self.mat().hauteurMax)
+        self.ui().edm_hauteur.setValue(self.mat().h)
+        self.ui().edm_hauteurPlafond.setChecked(self.mat().hMax)
         self.ui().edm_escalade.setChecked(self.mat().escalade)
         self.ui().edm_inflammable.setChecked(self.mat().inflammable)
     
     def enregistrer(self):
-        self.mat().hauteur = self.ui().edm_hauteur.value()
-        self.mat().hauteurMax = self.ui().edm_hauteurPlafond.isChecked()
+        self.mat().h = self.ui().edm_hauteur.value()
+        self.mat().hMax = self.ui().edm_hauteurPlafond.isChecked()
         self.mat().escalade = self.ui().edm_escalade.isChecked()
         self.mat().brule = self.ui().edm_inflammable.isChecked()
               

lib/EcranEditionTerrain.py

@@ -30,8 +30,7 @@ class EcranEditionTerrain(QDialog):
         self.connect(self.ui.et_enregistrer, SIGNAL("clicked()"), self.enregistrer)
         self.connect(self.ui.et_annuler, SIGNAL("clicked()"), self.annuler)
         self.connect(self.ui.et_nom, SIGNAL("textEdited(QString)"), self.majAffichage)
-        self.connect(self.ui.et_selectionCouleur, SIGNAL("clicked()"), self.selectionCouleur)
-        self.connect(self.ui.et_selectionFichier, SIGNAL("clicked()"), self.selectionFichier)
+        self.connect(self.ui.et_apercu, SIGNAL("clicked()"), self.selectionCouleur)
 
     def mat(self):
         """retourne le materiel de la fenetre"""
@@ -40,16 +39,17 @@ class EcranEditionTerrain(QDialog):
     def accesEdition(self):
         """ouverture en mode edition"""
         self.ui.et_nom.majTexte(self.terrain.nom())
-        if self.terrain.imgTexture.estValide():
-            self.ui.et_apercu.chargerImage(self.terrain.imgTexture)
-        else:    
-            if self.terrain.couleur.isValid():
-                self.ui.et_apercu.setText(QString(""))
-                self.ui.et_apercu.setStyleSheet("QLabel {backGround:%s}" %(self.terrain.couleur.name()))
+#         if self.terrain.imgTexture.estValide():
+#             self.ui.et_apercu.chargerImage(self.terrain.imgTexture)
+#         else:    
+        if self.terrain.couleur.isValid():
+            self.ui.et_apercu.setText(QString(""))
+            self.ui.et_apercu.setStyleSheet("QLabel {backGround:%s}" %(self.terrain.couleur.name()))
         if self.terrain.nage:
             self.ui.et_depNage.setChecked(True)
         elif not self.terrain.franchissable:
             self.ui.et_depAucun.setChecked(True)
+        self.ui.et_paroi.setChecked(self.terrain.hPlafond)
 
     def majAffichage(self):
         """verifie la validite des saisies"""
@@ -64,19 +64,20 @@ class EcranEditionTerrain(QDialog):
             self.ui.et_apercu.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
             self.terrain.couleur = couleur    
 
-    def selectionFichier(self):
-        """selectionne le fichier de texture dans la boite de dialogue dediee"""
-        img = rsc.selectionImage()
-        if img:
-            self.ui.et_apercu.chargerImage(img)
+#     def selectionFichier(self):
+#         """selectionne le fichier de texture dans la boite de dialogue dediee"""
+#         img = rsc.selectionImage()
+#         if img:
+#             self.ui.et_apercu.chargerImage(img)
            
     def enregistrer(self):
         """enregistre le terrain cree/edite"""
         self.terrain.majNom(self.ui.et_nom.texte())
-        if self.ui.et_apercu.image():
-            self.terrain.imgTexture = self.ui.et_apercu.image()
+#         if self.ui.et_apercu.image():
+#             self.terrain.imgTexture = self.ui.et_apercu.image()
         self.terrain.franchissable = (not self.ui.et_depAucun.isChecked())
         self.terrain.nage = self.ui.et_depNage.isChecked()
+        self.terrain.hPlafond = self.ui.et_paroi.isChecked()
         self.done(1)
 
     def annuler(self):

lib/EcranGestionCombat.py

@@ -163,7 +163,7 @@ class EcranGestionCombat(QFrame):
             #...
 
             #altitude
-            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].z))))
+            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].zR))))
 
             ### parametres supplementaires (issus des regles)
             for elt in self.plateau.combattants[numCombattant].listeAttributs:

lib/EcranVol.py

@@ -1,52 +0,0 @@
-#from __future__ import unicode_literals
-# -*- coding: utf-8 -*-
-import os, sys
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from ui.ecran_vol import Ui_vol_fenetre
-
-class EcranVol(QDialog):
-    """interface de gestion du vol d'un pion
-        renvoie la nouvelle altitude du pion"""
-    def __init__(self, actuelle = 0, parent=None):
-        """initialisation de la fenetre"""
-        super (EcranVol, self).__init__(parent)
-        self._resultat = 0
-        self.createWidgets()
-        self.ouverture(actuelle)
-          
-    def createWidgets(self):
-        """construction de l'interface"""
-        #construction de l'interface
-        self.ui = Ui_vol_fenetre()
-        self.ui.setupUi(self)                                                          
-        self.connect(self.ui.vol_ok, SIGNAL("clicked()"), self.ok)
-        self.ui.vol_valeur.selectAll()
-        
-    def ouverture(self, actuelle):
-        """ouverture en mode edition"""
-        self._resultat = actuelle
-        self.ui.vol_valeur.setValue(actuelle)
-
-    def resultat(self):
-        return self._resultat
-
-    def ok(self):
-        """enregistre le terrain cree/edite"""
-        self._resultat = self.ui.vol_valeur.value()
-        self.done(1)
-
-    def keyPressEvent(self, event):
-        if event.key() == Qt.Key_Return:
-            self.ok()
-
-if __name__ == "__main__":
-   app = QApplication(sys.argv)
-   ecran = EcranVol(2)
-   ecran.show()
-   r = app.exec_()
-   print ecran.resultat()
-   exit(r)  
-
-
- 

lib/ListePions.py

@@ -47,32 +47,13 @@ class ListePions(object):
     def pnjs(self):
         return {key:value for key, value in self._pions.items() if key > 0 and key <= 10000}
 
-    def nouvelId(self, nomClasse):
-        if nomClasse == "Combattant":
-            if not len(self.pnjs()) > 0: return 1
-            num = max(self.pnjs()) + 1
-        elif nomClasse == "PJ":
-            if not len(self.pjs()) > 0: return 10001
-            num = max(self.pjs()) + 1            
-        else:
-            if not len(self.decors()) > 0: return -1
-            num = min(self._pions) - 1
-        return num
-
-    def numeroterNom(self, nom):
-        """renvoie le nom du pion avec un numero complementaire si necessaire """
-        i = 1
-        for num in self.combattants():
-            if self._pions[num].nom() == nom: i += 1     
-        return str(i) if i > 1 else ""
-
     def nouveau(self, modele):
         """creer un pion (combattant ou decor) aux coordonnees indiquees"""
-        if self.plateau.proj.projectionValide():
+        if self.plateau.proj.valide():
             #instanciation du nouveau pion
             instance = modele.__class__
             pion = instance()
-            #recup de ses attributs
+            #on duplique le modele
             for elt in modele.__dict__:
                 pion.__dict__[elt] = modele.__dict__[elt]
             #nouvel Id
@@ -88,10 +69,28 @@ class ListePions(object):
             pion.nbRotations = self.plateau.proj.nbRotations()
             pion.ajouterAuPlateau(self.plateau)
             
-            if pion.__class__.__name__ == "PJ": self.plateau.majListePJ()
+            if pion.numero >= 10000 : self.plateau.majListePJ()
             self.plateau.gC.reinitialiser()
         return True    
 
+    def nouvelId(self, nomClasse):
+        if nomClasse == "Combattant":
+            if not len(self.pnjs()) > 0: return 1
+            return max(self.pnjs()) + 1
+        elif nomClasse == "PJ":
+            if not len(self.pjs()) > 0: return 10001
+            return max(self.pjs()) + 1            
+        else:
+            if not len(self.decors()) > 0: return -1
+            return min(self._pions) - 1
+
+    def numeroterNom(self, nom):
+        """renvoie le nom du pion avec un numero complementaire si necessaire """
+        i = 1
+        for num in self.combattants():
+            if self._pions[num].nom() == nom: i += 1     
+        return str(i) if i > 1 else ""
+
     def supprimer(self, num):
         """supprime le pion entre en parametre"""
         pionSuppr = self._pions.pop(num)

lib/Modes.py

@@ -18,6 +18,7 @@ from Pion import Pion
 from dialogues import dmSaisie
 import dmK
 from lib.EcranAltitude import EcranAltitude
+from lib.dialogues import dmAltitude, dmVol
 import regles
 
 
@@ -214,7 +215,7 @@ class StandardCp(ModeBaseCp):
     def clic_es(self, es):
         self.plateau.activerMode(EditionEntreeSortie, es)
         return True
- 
+  
 class MajCases(ModeBaseCp):
     """mode de mise a jour des cases (terrain, couleur, effet special)"""
     def __init__(self, plateau):
@@ -282,11 +283,7 @@ class MajCases(ModeBaseCp):
 
     def saisieAltitude(self):
         """affiche la fenetre de dialogue de saisie de l'altitude et renvoie la valeur saisie"""
-        ecran = EcranAltitude()
-        ecran.show()
-        ecran.exec_()
-        retour = ecran.resultat()
-        return retour
+        return dmAltitude(self.plateau.zP)
     
 class MajCasesEffet(MajCases):
     """mode de mise a jour des cases (effets speciaux)"""
@@ -352,8 +349,13 @@ class ZonePlacement(ModeBaseCp):
     
     def finClicGauche(self, coord):
         if self.plateau.pinceau.estActif():
-            if len(self.plateau.pinceau.selection()) > 0:
-                self.plateau.majZonePlacement(self.plateau.pinceau.selection())
+            lst = []
+            #on enleve d'eventuelles cases cachees
+            for coord in self.plateau.pinceau.selection():
+                if not self.plateau.cases[coord].estCachee():
+                    lst.append(coord)
+            if len(lst) > 0:
+                self.plateau.majZonePlacement(lst)
                 self.plateau.activerMode(StandardCp)
         return True        
 
@@ -404,9 +406,14 @@ class PlacerCaches(ModeBaseCp):
         #si la liste de cases peintes est valide, on demande le nom du cache et on le cree
         accepte = False
         if self.plateau.pinceau.estActif():
-            if len(self.plateau.pinceau.selection()) > 0:
+            lst = []
+            #on enleve d'eventuelles cases sur la zone de placement
+            for coord in self.plateau.pinceau.selection():
+                if not coord in self.plateau.listeCasesZonePlacement:
+                    lst.append(coord)
+            if len(lst) > 0:               
                 nom = dmSaisie("Entrez le nom du cache à créer:")
-                self.creerCache(self.plateau.pinceau.selection(), nom)
+                self.creerCache(lst, nom)
                 self.plateau.activerMode(StandardCp)
             accepte = True
         return accepte
@@ -521,22 +528,20 @@ class CreationPion(ModeBaseCp):
         super(CreationPion, self).desactiver()
 
     def survol_case(self, coord):
-        accepte = False
         if self._pion:
             self.plateau.proj.majCoord(coord)
-            accepte = True
-        return accepte
+            return True
+        return False
 
     def clic_case(self, coord):
-        accepte = False
         if self._pion:
-            if not self.plateau.cases[coord].estOccupee():
-                if isinstance(self._pion, Combattant) and dmK.touchesEnfoncees() == ["maj"]:
-                    nouveauZ = self.plateau.dialogueVol(self._pion.z)
-                    self._pion.majZ(nouveauZ)
+            if self.plateau.proj.valide():
+#                 if isinstance(self._pion, Combattant) and dmK.touchesEnfoncees() == ["maj"]:
+#                     nouveauZ = self.plateau.dialogueVol(self._pion.zR)
+#                     self._pion.majZ(nouveauZ)
                 self.plateau.pions.nouveau(self._pion)
-                accepte = True
-        return accepte
+                return True
+        return False
     
     def toucheClavier(self, event):
         if self._pion:
@@ -573,14 +578,7 @@ class SuppressionPion(ModeBaseCp):
     def clicGauche(self, event):
         """supprime le pion sous le clic. S'il y en a plusieurs,
             supprime le premier de la pile"""
-        num = None
-        item = self.plateau.itemAt(event.scenePos())
-        if issubclass(item.parentItem().__class__, Pion):
-            num = item.parentItem().numero
-        else:
-            if item.parentItem() != None: 
-                if issubclass(item.parentItem().parentItem().__class__, Pion):
-                    num = item.parentItem().parentItem().numero
+        num = self.plateau.pionAuPoint(event.scenePos())
         if num:
             self.plateau.pions.supprimer(num)
             return True
@@ -626,26 +624,24 @@ class DeplacementPion(ModeBaseCp):
         super(DeplacementPion, self).desactiver()
 
     def survol_case(self, coord):
-        accepte = False
-        if self._num > 0:
+        if self._num != 0:
             self.plateau.proj.majCoord(coord)
             self.deplace = True
-            accepte = True
-        return accepte
+            return True
+        return False
     
     def clic_case(self, coord):
-        accepte = False
-        if self.plateau.cases[coord].occupeeParCombattant(): return
-        if self._num > 0:
+        if self._num !=0 and self.plateau.proj.valide():
             if self.deplace:
                 pion = self.plateau.pions[self._num]
                 if self._num > 0 and dmK.touchesEnfoncees() == ["maj"]:
-                    nouveauZ = self.plateau.dialogueVol(pion.z)
+                    maxi = ((self.plateau.zP - pion.h) if self.plateau.zP else None)
+                    nouveauZ = dmVol(pion.zR, maxi)
                     pion.majZ(nouveauZ)
                 pion.majPosition(self.plateau.proj.coord(), self.plateau.proj.nbRotations())
-                self.plateau.gC.reinitialiser() #-> au cas ou le pion serait deplace vers ou depuis un cache
-                accepte = True
-        return accepte
+                if self._num > 0: self.plateau.gC.reinitialiser() #-> au cas ou le pion serait deplace vers ou depuis un cache
+                return True
+        return False
     
     def toucheClavier(self, event):
         accepte = False
@@ -739,11 +735,10 @@ class PionSelectionne(ModeBasePi):
         return self._action
         
     def survol_case(self, coord):
-        accepte = False
         if self._action:
             self._action.majCoordCible(coord)
-            accepte = True
-        return accepte
+            return True
+        return False
     
     def clic_case(self, coord):
         accepte = False

lib/Occupation.py

@@ -1,41 +0,0 @@
-# -*- coding: utf-8 -*-
-"""outils de gestion de l'occupation de l'espace sur le plateau
-"""
-
-class Occupation():
-    def __init__(self, plateau):
-        self.plateau = plateau             
-
-    def altitudeCase(self, coord):
-        """altitude de la case"""
-        return self.plateau.cases[coord].altitude
-    
-    def premiereAltitudeDispo(self, coord):
-        pass
-    
-    
-
-    def occupant(self, coord, zAbs = None):
-        """renvoie l'occupant de la case a l'altitude precisee, a celle du sol sinon"""
-        if not zAbs: zAbs = self._altitudeCase(coord)
-        return (self._mO[coord][zAbs] if zAbs in self._mO[coord] else None)
-        
-    def estOccupee(self, coord, zAbs = None):
-        return (self.occupant(coord, zAbs) != None)   
-
-    def estOccupeeParCbt(self, coord, zAbs = None):
-        pass
-    
-    
-    
-
-o = Occupation()
-o.majMo({(0,0): {0: 0, 2: 1}, (1,1): {0: 0, 2: 1}})
-o.majAltitudes([(1,1)], 10)
-print o.mo()                    
-            
-    
-
-
-
-

lib/Occupation2.py

@@ -1,96 +0,0 @@
-# -*- coding: utf-8 -*-
-"""outils de gestion de l'occupation de l'espace sur le plateau
-- la matrice occupation [mO] est de la forme {(x,y):{z0: 0, z1:N, z2:N, z3:N...}} 
-ou N est le numero du pion, et 0 le niveau du sol, et zi est l'altitude ABSOLUE de la case
-"""
-
-class Occupation():
-    def __init__(self):
-        self._mO = {}
-        
-    def majMo(self, mo):
-        self._mO = mo
-
-    def mo(self):
-        return self._mO
-        
-    def generer(self, plateau):
-        """genere la matrice"""
-        self._mO = {key:{value.altitude:0} for key, value in plateau.cases.items()}
-
-        for num in plateau.pions:
-            pion = plateau.pions[num]
-            for x, y in pion.forme.listeCases(pion.position, pion.nbRotations):
-                for z in range(1, pion.hauteur + 1):
-                    zAbs = (plateau.cases[(x,y)].altitude + pion.z + z)
-                    self._mO[(x,y)][zAbs] = num
-            
-    
-    def maj(self, *args):
-        """met a jour l'occupation, selon ce qui est apsse en parametre:
-           - si (liste de coord, altitude), met a jour l'altitude des cases correspondantes et celle des pions qui les occupent
-           - si (pion), met a jour l'occupation en fonction de sa nouvelle situation (deplace, pivote, supprime, nouveau)
-           - si (plateau), regenere
-        """   
-        if len(args) == 1:
-            if args[0].__class__.__name__ == "Plateau":
-                self.generer(args[0])
-            
-            else:
-                print "pion"
-        
-        elif len(args) == 2:   
-            self._majAltitudes(args[0], args[1])
-             
-    def _altitudeCase(self, coord):
-        for key, val in self._mO[coord].items():
-            if val == 0: return key
-        return 0
-       
-    def _majAltitudes(self, lstCoord, altitude):
-        
-        for coord in lstCoord:
-            ancien = self._mO[coord]
-            self._mO[coord] = {}
-            
-            for z in ancien:
-                if ancien[z] == 0:
-                    dz = altitude - z
-
-            for z in ancien:
-                self._mO[coord][(z + dz)] = ancien[z]
-
-    def _majPion(self, pion):
-        #on efface son ancienne occupation
-        num = pion.numero
-        for coord in self._mO:
-            for key, val in self._mO[coord].items():
-                if val == num: del self._mO[coord][key]
-        
-        #on l'ajoute la ou il se trouve maintenant
-        for x, y in pion.forme.listeCases(pion.position, pion.nbRotations):
-            for z in range(1, pion.hauteur + 1):
-                zAbs = (self._altitudeCase((x,y)) + pion.z + z)
-                self._mO[(x,y)][zAbs] = num                    
-
-    def occupant(self, coord, zAbs = None):
-        """renvoie l'occupant de la case a l'altitude precisee, a celle du sol sinon"""
-        if not zAbs: zAbs = self._altitudeCase(coord)
-        return (self._mO[coord][zAbs] if zAbs in self._mO[coord] else None)
-        
-    def estOccupee(self, coord, zAbs = None):
-        return (self.occupant(coord, zAbs) != None)   
-
-    
-    
-
-o = Occupation()
-o.majMo({(0,0): {0: 0, 2: 1}, (1,1): {0: 0, 2: 1}})
-o.majAltitudes([(1,1)], 10)
-print o.mo()                    
-            
-    
-
-
-
-

lib/Pinceau.py

@@ -251,9 +251,15 @@ class Pinceau():
         return retour    
 
     def ontTerrainsSimilaires(self, coord1, coord2):
-        return (self.plateau.cases[coord1].terrain.nom() == self.plateau.cases[coord2].terrain.nom() and \
-                self.plateau.cases[coord1].terrain.couleur.rgb() == self.plateau.cases[coord2].terrain.couleur.rgb() and \
-                self.plateau.cases[coord1].terrain.imgTexture.idR() == self.plateau.cases[coord1].terrain.imgTexture.idR())
+        if len(self.plateau.cases[coord1].terrain.idM()) > 0:
+            if self.plateau.cases[coord1].terrain.idM() == \
+               self.plateau.cases[coord2].terrain.idM(): 
+                return True
+        else:
+            if self.plateau.cases[coord1].terrain.couleur.rgb() == \
+               self.plateau.cases[coord2].terrain.couleur.rgb(): 
+                return True
+        return False
 
 
 

lib/Pion.py

@@ -1,12 +1,13 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 
-from PyQt4.QtCore import QPointF, Qt, QRectF
+from PyQt4.QtCore import QPointF, Qt, QRectF, QString
 from PyQt4.QtGui import QGraphicsItem, QColor, QGraphicsPolygonItem, QPen, \
     QGraphicsDropShadowEffect, QGraphicsPixmapItem, QGraphicsSimpleTextItem, \
     QFont, QGraphicsObject
 
 from Forme import Forme
+from lib import dmF
 from lib.rsc import RImage
 
 
@@ -16,41 +17,44 @@ class Pion(QGraphicsObject):
         super(Pion, self).__init__()
         #caracteristiques du pion
         self.numero = -1
+        self.pion = PolygonePion()
         self.couleur = QColor(200, 200, 200)
         self.logo = RImage()
         self.img = ImgPion()
         self.etiquette = EtiquettePion()
+        self.brillance = BrillancePion()
 
         #infos liees au plateau (forme et position)
         self.plateau = None
         self.numComplementaire = ""    #numero complementaire si necessaire
                                         #(si plusieurs pions portent le meme nom)
         self.position = (-1, -1)
-        self.z = 0
-        self.hauteur = 1
+        self.zR = 0   #altitude relative du pion par rapport aux cases qu'il occupe (vol slt)
+        self.h = 1
+        self.hMax = False          #[decors slt] la hauteur doit etre calculee pour atteindre le plafond (s'il existe)
+        self.posPile = 0 #position du pion dans la pile des pions (pour l'ordre de re-creation des pions)
+        self._place = False #le pion est place sur le plateau
+        
         self.forme = None
         self.formeDef = {"H":[], "C":[]}
         self.etat = 0       #de 0 (indemne) a 4 (mort ou hors combat)
         self.statuts = []     
 
         #objets et parametres graphiques
-        self.pixGraphique = None
         self.etiquetteGraphique = None
-        self._l0 = 0
-        self._h0 = 0
-        self.polygoneGraphique = None
         self.nbRotations = 0
 
-
     def __getstate__(self):
-        nePasSvg = ["plateau", "brillance", "shadow", "creature", "polygonesForme", "pixGraphique", "etiquetteGraphique"]
+        nePasSvg = ["_place", "plateau", "brillance", "pion", "etiquetteGraphique"]
         state = {key:value for key, value in self.__dict__.items() if not key in nePasSvg}
         return (state)
     
     def __setstate__(self, state):
         self.__dict__ = state
-        self.pixGraphique = None
+        self.pion = PolygonePion()
+        self.brillance = BrillancePion()
         self.etiquetteGraphique = None
+        self._place = False
         super(Pion, self).__init__()
 
     def paint(self, painter, option, widget = None):
@@ -59,7 +63,8 @@ class Pion(QGraphicsObject):
 
     def txtId(self):
         """renvoie le nom et le numero complementaire du pion"""
-        return "{} {}".format(self._nom, self.numComplementaire)
+        txt = dmF.contractTxt(self._nom, 20)
+        return "{} {}".format(txt, self.numComplementaire)
 
     def icone(self):
         """renvoie l'image a afficher dans les listes"""
@@ -78,23 +83,61 @@ class Pion(QGraphicsObject):
         """retourne la position actuelle du pion"""
         return self.position
 
-    def casesOccupees(self):
-        """retourne la liste des cases occupees sur le plateau par le pion (x,y,z)"""
+    def projectionValide(self, proj):
+        """prend en parametre la projection en cours, et renvoie vrai si celle-ci est valide
+           attention: cette fonction peut etre appellee avant la creation du pion
+           *** reimplemente dans les classes heritees ***"""
+        lst = proj.listeCases()
+        for case in lst:
+            #1- la case est occupee par un autre combattant
+            if (case.occupant() > 0): return False
+            #2- z1 retourne None
+            z1 = case.z1()
+            if z1 == None: return False
+            #3- la hauteur sous le plafond est insuffisante : (zP - z1) < h
+            if case.zP() and not self.hMax:
+                if case.zP() - z1 < self.h: return False
+        
+        return True
+
+    def coordOccupees(self):
+        """retourne la liste des cases occupees sur le plateau par le pion (x,y)"""
         retour = []
-        if self.plateau:
+        if self.position != (-1, -1):
             for x, y in self.forme.listeCases(self.position, self.nbRotations):
-                for z in range(1, self.hauteur + 1):
-                    retour.append((x, y, (self.plateau.cases[(x, y)].altitude + self.z + z)))
+#                 for z in range(0, self.h):
+#                     retour.append((x, y, (self.plateau.cases[(x, y)].z0 + self.zR + z)))
+                retour.append((x, y))
         return retour
 
-    def majZ(self, valeur):
-        """met a jour l'altitude Z du pion"""
-        if valeur != self.z:
-            self.z = valeur    
+    def espaceOccupe(self):
+        """retourne l'espace occupe sur le plateau par le pion 
+           sous la forme de coordonnees (x, y, zA)"""
+        retour = []
+        if self.position != (-1, -1):
+            for x, y in self.forme.listeCases(self.position, self.nbRotations):
+                zA = self.plateau.cases[(x, y)].zA(self.numero)
+                for z in range(0, (self.h if self.h > 0 else 1)):
+                    retour.append((x, y, (zA + z)))
+        return retour
+    
+    def occuper(self):
+        """signale aux cases qu'il occupe cet espace"""
+        for x, y in self.coordOccupees():
+            self.plateau.cases[(x,y)].occuper(self.numero, self.h)
+        
+    def liberer(self):
+        """signale aux cases qu'il n'occupe plus cet espace"""
+        for x, y in self.coordOccupees():
+            self.plateau.cases[(x,y)].liberer(self.numero)
+
+    def majZ(self, zR):
+        """met a jour l'altitude relative zR du pion"""
+        if zR != self.zR: self.zR = zR    
 
-    def zAbs(self):
+    def zA(self):
         """retourne la coord z absolue du pion"""
-        return (self.plateau.cases[self.position].altitude + self.z)
+        return (self.plateau.cases[self.position].z0 + self.zR)
 
     ########### fonctions graphiques et geometriques   ##############
     def ajouterAuPlateau(self, plateau):
@@ -106,61 +149,33 @@ class Pion(QGraphicsObject):
         if len(self.formeDef[self.plateau.formeCases]) > 0:
             self.forme.definirForme(self.formeDef[self.plateau.formeCases])        
 
-        #creation du polygone
-        polygone = self.plateau.polygoneAgglo(self.forme.listeCases((0,0)))
-        self.polygoneGraphique = QGraphicsPolygonItem()
-        self.polygoneGraphique.setPolygon(polygone)
-        self.polygoneGraphique.setAcceptHoverEvents(True)
-        self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
-        self.polygoneGraphique.setParentItem(self)
-        self.polygoneGraphique.setPos(QPointF(0,0))
-        if self.plateau.formeCases == "H":
-            self.polygoneGraphique.setTransformOriginPoint(QPointF(2*0.2886*self.plateau.hCase, 0.5*self.plateau.hCase))
-        else:
-            self.polygoneGraphique.setTransformOriginPoint(QPointF(0.5*self.plateau.hCase,0.5*self.plateau.hCase))
-
         #parametres de l'objet graphique
-        self.setZValue(10)
         self.setFlag(QGraphicsItem.ItemHasNoContents)
-        self.setHandlesChildEvents(True)
-         
-        pinceau = QPen()
-        pinceau.setColor(self.couleur.darker(130))
-        pinceau.setWidth(10)
-        self.polygoneGraphique.setPen(pinceau)
-
-        if self.couleur.isValid():
-            self.polygoneGraphique.setBrush(self.couleur)
-        else:
-            self.polygoneGraphique.setBrush(QColor(255, 0, 0, 150))
+#         self.setHandlesChildEvents(True)
+        self.setFiltersChildEvents(True)
+        self.setAcceptHoverEvents(True)
 
-        self.shadow = QGraphicsDropShadowEffect()
-        self.shadow.setColor(QColor(50, 50, 50)) 
-        self.shadow.setXOffset(1) 
-        self.shadow.setYOffset(2) 
-        self.shadow.setBlurRadius(3)  
-        self.shadow.setEnabled(True)
-        self.polygoneGraphique.setGraphicsEffect(self.shadow)
+        ### ajout des items enfants (dans l'ordre d'empilement)
+        #creation du polygone
+        polygone = self.plateau.polygoneAgglo(self.forme.listeCases((0,0)))
+        self.pion.creer(self, polygone)
+        #image:
+        self.img.creer(self)
+        #brillance (au survol)
+        self.brillance.creer(self)
         
-        self.polygoneBrillance = QGraphicsPolygonItem()
-        self.polygoneBrillance.setPolygon(self.polygoneGraphique.polygon())
-        self.polygoneBrillance.setVisible(False)
-        self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)
-        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
-        self.polygoneBrillance.setParentItem(self.polygoneGraphique)
-
         #on ajoute l'objet au plateau
         self.plateau.addItem(self)
+        self.setZValue(90)
         self.majPosition(self.position, self.nbRotations)
+        self._place = True
+        
 
     def majPosition(self, nouvellePosition, nbRotations = 0):
         """met a jour la position de l'objet graphique et de sa forme en fonction de sa position enregistree"""
         if self.plateau:
             #on met a jour l'occupation des cases
-            if self.position != (-1,-1):
-                for coord in self.forme.listeCases(self.position, self.nbRotations):
-                    for z in range(self.z, (self.z + self.hauteur)):
-                        self.plateau.cases[coord].liberer(z)
+            if self._place: self.liberer()
 
             #on met a jour la position du pion        
             self.position = nouvellePosition
@@ -168,65 +183,32 @@ class Pion(QGraphicsObject):
 
             #on replace
             if self.plateau.formeCases == "H":
-                angleRotation = 60
-                positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.yReel() * self.plateau.hCase)
+                positionGraphique = QPointF(self.position[0] * 0.866 * 120, self.yReel() * 120)
             else:
-                angleRotation = 90
-                positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
+                positionGraphique = QPointF(self.position[0] * 120, self.position[1] * 120)
             self.prepareGeometryChange()
             self.setPos(positionGraphique)
-            self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)
+            self.pion.maj()
             
             #maj de l'image
-            self.majImage()
+            self.img.maj()
             
             #on met a jour l'occupation des cases
-            for coord in self.forme.listeCases(self.position, self.nbRotations):
-                for z in range(self.z, (self.z + self.hauteur)):
-                    self.plateau.cases[coord].occuper(self.numero, z)
-                    
-                 
-    def majImage(self):
-        """met a jour la taille, la position et l'orientation de l'image"""
-        if self.img.rimage.estValide():
-            pix = self.img.rimage.pix()
-            if not pix.isNull():
-                if not self.pixGraphique:
-                    self.pixGraphique = QGraphicsPixmapItem()
-                    self.pixGraphique.setZValue(10) 
-                    if pix.height() >= pix.width():
-                        pix = pix.scaledToHeight(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    else:
-                        pix = pix.scaledToWidth(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    self._l0 = pix.width()
-                    self._h0 = pix.height()
-                    pix = pix.scaled((self.img.kx/10)*pix.width(), \
-                                     (self.img.ky/10)*pix.height(), \
-                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-                    self.pixGraphique.setPixmap(pix)
-
-##                deltaX = self.img.dx + 0.5*(self.plateau.hCase*1.1544 - self._l0)
-##                deltaY = self.img.dy + 0.5*(self.plateau.hCase - self._h0)
-                deltaX = self.img.dx + 0.5*(self.plateau.hCase*1.1544 - self.pixGraphique.pixmap().width())
-                deltaY = self.img.dy + 0.5*(self.plateau.hCase - self.pixGraphique.pixmap().height())
-
-                if self.img.rimage.idR() == self.logo.idR():
-                    #si l'image est le logo, elle ne doit pas pivoter
-                    self.pixGraphique.setParentItem(self)
-                else:
-                    self.pixGraphique.setParentItem(self.polygoneGraphique)
-                self.pixGraphique.setRotation(self.img.rotation)
-                self.pixGraphique.setPos(QPointF(deltaX, deltaY))
+            self.occuper()
+            
+            #gestion de la pile du plateau
+            self.posPile = self.plateau.incrementerPile()
 
     def majEtiquette(self):
         """met a jour la taille, le format et l'orientation de l'etiquette"""
-        self.etiquetteGraphique = QGraphicsSimpleTextItem("{}".format(self.txtId()))
+        self.etiquetteGraphique = QGraphicsSimpleTextItem(QString().fromUtf8(self.txtId()))
         self.etiquetteGraphique.setPos(QPointF(self.etiquette.dx - 0.112*self.plateau.hCase, \
                                                 self.etiquette.dy - 0.5*self.plateau.hCase))
         police = QFont("Verdana", self.etiquette.taille_police)
         police.setBold(self.etiquette.gras)
         self.etiquetteGraphique.setFont(police)
-        self.etiquetteGraphique.setParentItem(self)        
+        self.etiquetteGraphique.setParentItem(self)     
+        self.etiquetteGraphique.setZValue(94)   
                 
     def majNbRotation(self, nbRotations):
         """ajoute/retranche le nombre au nombre total de rotations du pion"""
@@ -243,42 +225,29 @@ class Pion(QGraphicsObject):
 
     def retirerDuPlateau(self):
         """'deconnecte' les items enfants avant de supprimer du pion du plateau"""
-        for coord in self.forme.listeCases(self.position, self.nbRotations):
-            for z in range(self.z, (self.z + self.hauteur)):
-                self.plateau.cases[coord].liberer(z)
-
-        self.polygoneBrillance.prepareGeometryChange()
-        self.polygoneBrillance.setParentItem(None)
-        if self.pixGraphique != None:
-            self.pixGraphique.prepareGeometryChange()
-            self.pixGraphique.setParentItem(None)
-        self.polygoneGraphique.prepareGeometryChange()
-        self.polygoneGraphique.setParentItem(None)
+        self.liberer()
+        self.setVisible(False)
+        self.brillance.supprimer()
+        self.plateau.removeItem(self.brillance)
+        self.img.supprimer()
+        self.plateau.removeItem(self.img)
+        self.pion.supprimer()
+        self.plateau.removeItem(self.pion)
         if self.etiquetteGraphique:
             self.etiquetteGraphique.prepareGeometryChange()
             self.etiquetteGraphique.setParentItem(None)
+            self.plateau.removeItem(self.etiquetteGraphique)
         self.plateau.removeItem(self)
         self.plateau = None
 
     ###effets graphiques 
     def afficheOmbreSelection(self, actif = False):
         """modifie l'ombre du pion en fonction de si celui-ci est selectionne ou non"""
-        if actif:
-            self.shadow.setXOffset(3) 
-            self.shadow.setYOffset(3)
-        else:
-            self.shadow.setXOffset(1) 
-            self.shadow.setYOffset(2)
+        self.pion.ombre(actif)
             
     def surbrillance(self, active, opacite = 0.7, couleur = "white"):
         """active/desactive la surbrillance"""
-        if active:
-            self.polygoneBrillance.setOpacity(opacite)
-            couleur = self.couleurSurbrillance(couleur)
-            pinceau = self.polygoneGraphique.pen()
-            self.polygoneBrillance.setBrush(couleur)
-            self.polygoneBrillance.setPen(pinceau)
-        self.polygoneBrillance.setVisible(active)
+        self.brillance.activer(active, opacite, self.couleurSurbrillance(couleur))
         
     def estCibleAttaque(self, estCible, possible = True):
         """le pion s'affiche comme etant cible d'une attaque"""
@@ -291,9 +260,9 @@ class Pion(QGraphicsObject):
     def couleurSurbrillance(self, couleur = "white"):
         """renvoie une QColor visible pour la surbrillance, selon la couleur du pion"""
         retour = QColor(couleur)
-        if self.polygoneGraphique.brush().color().lightness() > 220:
+        if self.pion.brush().color().lightness() > 220:
             retour = retour.darker(140)
-        elif self.polygoneGraphique.brush().color().lightness() < 80:
+        elif self.pion.brush().color().lightness() < 80:
             retour = retour.lighter(140)
         return retour
 
@@ -305,8 +274,99 @@ class Pion(QGraphicsObject):
         
     #######################
 
-class ImgPion():
+class PolygonePion(QGraphicsPolygonItem):
+    """polygone representant le pion"""
     def __init__(self):
+        super(PolygonePion, self).__init__()    
+        
+    def __setstate__(self, state):
+        self.__dict__ = state
+        super(PolygonePion, self).__init__()
+        
+    def numero(self):
+        return self._pion.numero
+        
+    def creer(self, pion, polygone):
+        self._pion = pion
+        self.setPolygon(polygone)
+        self.setAcceptHoverEvents(True)
+        self.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
+        self.setPos(QPointF(0,0))
+        origine = QPointF(2*0.2886*120, 0.5*120) if self._pion.plateau.formeCases == "H" else QPointF(0.5*120, 0.5*120)
+        self.setTransformOriginPoint(origine)
+        
+        pinceau = QPen()
+        pinceau.setWidth(10)
+        couleur = self._pion.couleur if self._pion.couleur.isValid() else QColor(150, 150, 150)
+        pinceau.setColor(couleur.darker(130))
+        self.setPen(pinceau)
+        self.setBrush(couleur)
+          
+        #ombre
+        self.shadow = QGraphicsDropShadowEffect()
+        self.shadow.setColor(QColor(50, 50, 50)) 
+        self.shadow.setXOffset(1) 
+        self.shadow.setYOffset(2) 
+        self.shadow.setBlurRadius(3)  
+        self.shadow.setEnabled(True)
+        self.setGraphicsEffect(self.shadow)
+        
+        self.setParentItem(self._pion)
+        
+#         self.setZValue(91)
+
+    def maj(self):
+        angleRotation = 60 if self._pion.plateau.formeCases == "H" else 90
+        self.setRotation(self._pion.nbRotations * angleRotation)
+
+    def ombre(self, actif):
+        if actif:
+            self.shadow.setXOffset(3) 
+            self.shadow.setYOffset(3)
+        else:
+            self.shadow.setXOffset(1) 
+            self.shadow.setYOffset(2)
+            
+    def supprimer(self):
+        self.prepareGeometryChange()
+        self.setParentItem(None)        
+
+class BrillancePion(QGraphicsPolygonItem):
+    """polygone representant le pion"""
+    def __init__(self):
+        super(BrillancePion, self).__init__()    
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        super(BrillancePion, self).__init__()
+        
+    def numero(self):
+        return self._pion.numero
+        
+    def creer(self, pion):
+        self._pion = pion
+        self.setPolygon(self._pion.pion.polygon())
+        self.setVisible(False)
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.setAcceptHoverEvents(True) 
+        self.setParentItem(self._pion.pion)
+#         self.setZValue(93)
+
+    def activer(self, actif, opacite, couleur):
+        if actif:
+            self.setOpacity(opacite)
+            self.setBrush(couleur)
+            self.setPen(self._pion.pion.pen())
+        self.setVisible(actif)
+
+    def supprimer(self):
+        self.prepareGeometryChange()
+        self.setParentItem(None)
+
+class ImgPion(QGraphicsPixmapItem):
+    def __init__(self):
+        super(ImgPion, self).__init__()
+        self._pion = None
         self.rimage = RImage()        #ressource: image
         self.kx = 10                 #coeff d'agrandissement horizontal
         self.ky = 10                 #coeff d'agrandissement vertical
@@ -315,6 +375,52 @@ class ImgPion():
         self.rotation = 0           #rotation(en degres)
         self.pivote = False         #l'image pivote avec le pion?
         self.masqueAuto = False     #creer un masque automatiquement
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        super(ImgPion, self).__init__()
+
+    def numero(self):
+        num = self._pion.numero if self._pion else -1
+        return num
+    
+    def creer(self, pion):
+        self._pion = pion
+        if not self.rimage.estValide(): return
+        pix = self.rimage.pix()
+        if pix.isNull(): return
+                
+        self.setAcceptedMouseButtons(Qt.NoButton)
+        if pix.height() >= pix.width():
+            pix = pix.scaledToHeight( 120 * 0.9, Qt.SmoothTransformation)
+        else:
+            pix = pix.scaledToWidth( 120 * 0.9, Qt.SmoothTransformation)
+
+        pix = pix.scaled( (self.kx / 10) * pix.width(), \
+                          (self.ky / 10) * pix.height(), \
+                           Qt.IgnoreAspectRatio, Qt.SmoothTransformation )
+        self.setPixmap(pix)      
+        
+        if self.rimage.idR() == self._pion.logo.idR():
+            #si l'image est le logo, elle ne doit pas pivoter
+            self.setParentItem(self._pion)
+        else:
+            self.setParentItem(self._pion.pion)
+#         self.setZValue(92)
+      
+    def maj(self):
+        """met a jour la taille, la position et l'orientation de l'image"""
+        pix = self.pixmap()
+        if pix.isNull(): return        
+        deltaX = self.dx + 0.5 * ( (120 * 1.1544) - pix.width() )
+        deltaY = self.dy + 0.5 * (  120           - pix.height())
+
+        self.setRotation(self.rotation)
+        self.setPos(QPointF(deltaX, deltaY))
+                
+    def supprimer(self):
+        self.prepareGeometryChange()
+        self.setParentItem(None)
         
 class EtiquettePion():
     def __init__(self):

lib/Plateau.py

@@ -18,7 +18,6 @@ from Decor import Decor
 from EcranAffichageTexte import EcranAffichageTexte
 from EcranCreerPlateau import EcranCreerPlateau
 from EcranGestionCombat import EcranGestionCombat
-from EcranVol import EcranVol
 import Modes
 from Pinceau import Pinceau
 from ProjectionDep import ProjectionDep
@@ -27,6 +26,8 @@ import br
 from lib.Actions import EcranAttaqueZone
 from lib.EcranEditionMateriel import EcranEditionMateriel
 from lib.ListePions import ListePions
+from lib.commun import lstLibEtats
+from lib.dmF import inverser, contractTxt
 from lib.gC import GestionCombat
 from lib.gM import GestionMateriel
 from lib.mat import Materiel, chargerMat
@@ -51,14 +52,14 @@ class Plateau(QGraphicsScene, Materiel):
         self.dateSvg = ""
         self.notes = ""
         self.presentation = ""
-        self.description = ""
         
         #carac 
         self.nbCasesX = 0
         self.nbCasesY = 0
         self.hCase = 0
         self.couleurInit = QColor(0, 255, 0, 80)
-        self.plafond = None
+        self.zP = None   #plafond
+        self._compteurPile = 0 #compteur d'empilement, pour gerer l'ordre de recreation des pions
 
         #objets
         self.pinceau = Pinceau(self)
@@ -122,6 +123,10 @@ class Plateau(QGraphicsScene, Materiel):
 
         self.plateauModeCreation()
 
+    def incrementerPile(self):
+        self._compteurPile += 1
+        return self._compteurPile
+
     def recreer(self, fenetre):
         self.fenetre = fenetre
         self.gestionCombat = None
@@ -140,9 +145,12 @@ class Plateau(QGraphicsScene, Materiel):
         self.majCaches()
 
         #recreation des pions 
-        for num in self.pions:
-            self.pions[num].ajouterAuPlateau(self)
-        self.gC.maj()    
+        #on recree les pions par ordre d'empilement (du bas vers le haut)
+        ordre = [pion for pion in self.pions.pions().values()]
+        ordre.sort(key=lambda x: x.posPile)
+        for pion in ordre:
+            pion.ajouterAuPlateau(self)
+        self.gC.reinitialiser()
 
         #recreation des marqueurs entree/sortie
         for entreeSortie in self.entreesSorties:
@@ -268,8 +276,8 @@ class Plateau(QGraphicsScene, Materiel):
         self.fenetre.ui.act_attaqueZone.setCheckable(True)
 
         #mise a jour de l'interface d'informations
-        self.majInfosCombattant(None)
-        self.majInfosDecor(None)
+        self.majInfoCb(None)
+        self.majInfoDc(None)
 
     def estCree(self):
         """renvoie vrai si des cases ont ete creees"""
@@ -408,10 +416,9 @@ class Plateau(QGraphicsScene, Materiel):
     def afficherFichePion(self):
         if self.pionSelectionne():
             fen = EcranEditionMateriel(self.pionSelectionne())
-            fen.afficher(0, self.formeCases)
+            fen.afficher()
             fen.exec_()
             
-        
     ############### maj des infos du panneau Pi a la selection/deselection d'un pion
         #voir a balancer tout ca dans une classe a part
 
@@ -454,7 +461,7 @@ class Plateau(QGraphicsScene, Materiel):
                 #maj des donnees de base    
                 self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom()))))
                 self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat))))
-                self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z))))
+                self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().zR))))
                 
                 #attributs issus des regles utilisees    
                 ordre = regles.ordreAttributs()
@@ -884,195 +891,118 @@ class Plateau(QGraphicsScene, Materiel):
             
     ###############
 
-    ### panneau d'info
-    
-    def majInfosCombattant(self, combattant=None):
-        self.fenetre.ui.inf_boitePion.maj(combattant)
+    ######### gestion des evenements souris et clavier ###############
+
+    def clic_pion(self, num):
+        if num > 0:
+            return self.clic_combattant(num)
+        else:
+            return self.clic_decor(num)
+
+    def clic_combattant(self, num):
+        return self.modeActif.clic_combattant(num)
+ 
+    def clic_decor(self, num):
+        return self.modeActif.clic_decor(num)
+
+    def clic_case(self, coord):
+        return self.modeActif.clic_case(coord)     
+  
+    def survol_pion(self, num):
+        if num > 0:
+            return self.survol_combattant(num)
+        else:
+            return self.survol_decor(num) 
+ 
+    def survol_combattant(self, num):
+        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        return self.modeActif.survol_decor(num)        
+
+    def survol_decor(self, num):
+        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        return self.modeActif.survol_decor(num)
+
+    def survol_case(self, coord):
+        self.majInfoTr(self.cases[coord]) 
+        self.majInfoPion(self.pions[self.cases[coord].occupant()])
+        return self.modeActif.survol_case(coord)
 
-    def majInfosDecor(self, decor=None):
-        self.fenetre.ui.inf_boiteDecor.maj(decor)
+    def finSurvol_pion(self, num):
+        self.majInfoPion(None)
+        if num > 0:
+            return self.finSurvol_combattant(num)
+        else:
+            return self.finSurvol_decor(num) 
+
+    def finSurvol_combattant(self, num):
+        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        return self.modeActif.finSurvol_combattant(num) 
+
+    def finSurvol_decor(self, num):
+        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        return self.modeActif.finSurvol_decor(num)
+
+    def finSurvol_case(self, coord):
+        return self.modeActif.finSurvol_case(coord)
+
+    def survolClic_case(self, coord):
+        return self.modeActif.survolClic_case(coord)
 
-    def majInfosCase(self, case=None):
-        self.fenetre.ui.inf_boiteCase.maj(case)        
+    def doubleClic_pion(self, num):
+        if num > 0:
+            return self.doubleClic_combattant(num)
 
-    ###
+    def doubleClic_combattant(self, num):
+        return self.modeActif.doubleClic_combattant(num)       
     
-                       
-    def pionSurCase(self, coord):
-        """renvoie le pion present sur la case, none sinon"""
-        for num in self.combattants():
-            if self.pions[num].position == coord: return num
-        return None        
-
-    def pionsSurListeCase(self, listeCases):
-        """renvoie la liste des num des pions presents sur la liste de cases"""
-        retour = []
-        for coord in listeCases:
-            pion = self.cases[coord].occupant()
-            if pion != None and not pion.numero in retour:
-                retour.append(pion.numero)
-        return retour   
+    def mouseMoveEvent(self, event):
+        super(Plateau, self).mouseMoveEvent(event)
+        if event.buttons() == Qt.LeftButton and self.vue().dragMode() != QGraphicsView.ScrollHandDrag:
+            coord = self.coordonneesAuPoint(event.scenePos())
+            if coord != None:
+                self.survolClic_case(coord)  
+        else:
+            self.modeActif.mouvementSouris(event)
+            event.ignore() 
 
+    def mousePressEvent(self, event):
+        super(Plateau, self).mousePressEvent(event)
+        if event.button() == 1:
+            self.modeActif.clicGauche(event)
+        elif event.button() == 2:
+            self.modeActif.clicDroit(event)
+            event.accept()
 
+    def mouseReleaseEvent(self, event):
+        super(Plateau, self).mouseReleaseEvent(event)
+        self.modeActif.finClicGauche(event)
 
-#     def materialiserPions(self,actif):
-#         """avtive/desactive la reception par les pions (autres que le pion selectionne) des hover events"""
-#         for numCombattant in self.combattants:
-#             if numCombattant != self.modeParam["numPionSelectionne"]:
-#                 self.combattants[numCombattant].setAcceptsHoverEvents(actif)
-#                 self.combattants[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif)
-#         for numCombattant in self.decors:
-#             self.decors[numCombattant].setAcceptsHoverEvents(actif)
-#             self.decors[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif)
-                
-    #######################
+    def keyPressEvent(self, event):
+        """gestion des evenements clavier"""
+        self.modeActif.toucheClavier(event)
+
+    ################   
+
+    ############### Fonctions diverses
 
-    ######## interaction avec les cases, decors et pions  #############
     def pionSelectionne(self):
         """renvoie le pion actuellement selectionne"""
         if self.modeActif.__class__.__name__ == "PionSelectionne": return self.modeActif.pion()
         return None    
 
-    def caseCliquee(self, x, y):
-        """on a clique sur la case (clic gauche)"""
-        return self.modeActif.clic_case((x, y))     
-
-    def caseSurvolClicEnfonce(self, coord):
-        """une case est survolee par le curseur (le clic gauche est enfonce)"""
-        return self.modeActif.survolClic_case(coord)
-    
-    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)]) 
-        return self.modeActif.survol_case((x,y))
-                             
     def afficherListeCases(self, listeCases, actif):
         """met ou non en evidence les cases selectionnees"""
         for coord in listeCases:
             self.cases[coord].majEstCibleCurseur(actif)
 
-    def pionClique(self, num):
-        """on a clique sur ce pion"""
-        if num > 0:
-            accepte = self.modeActif.clic_combattant(num)
-        else:
-            accepte = self.modeActif.clic_decor(num)
-        return accepte
-    
-    def combattantSurvol(self, num):
-        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
-        accepte = self.modeActif.survol_combattant(num)
-        pion = self.pions[num]
-        self.majInfosCombattant(pion)
-        if not accepte: 
-            accepte = self.caseSurvol(pion.position[0], pion.position[1])
-        return accepte        
-
-    def combattantFinSurvol(self, num):
-        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
-        accepte = self.modeActif.finSurvol_combattant(num)
-        self.majInfosCombattant(None)
-        return accepte 
-
-    def decorSurvol(self, num):
-        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
-        accepte = self.modeActif.survol_decor(num)
-        pion = self.pions[num]
-        self.majInfosDecor(pion)
-        if not accepte: 
-            accepte = self.caseSurvol(pion.position[0], pion.position[1])
-        return accepte
-    
-    def decorFinSurvol(self, num):
-        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
-        accepte = self.modeActif.finSurvol_decor(num)
-        self.majInfosDecor(None)
-        return accepte
-                
-    def pionDoubleClic(self, numCombattant):
-        """on a double-clique sur le pion"""
-        accepte = self.modeActif.doubleClic_combattant(numCombattant)       
-        return accepte
-    
-#     def creerPion(self, pionModele):
-#         """creer un pion (combattant ou decor) aux coordonnees indiquees"""
-#         cree = False
-#         if self.proj.projectionValide():
-# 
-#             if pionModele.__class__.__name__ == "Combattant":
-#                 pion = Combattant()
-#             elif pionModele.__class__.__name__ == "Decor":
-#                 pion = Decor()
-# 
-#             for elt in pionModele.__dict__:
-#                 pion.__dict__[elt] = pionModele.__dict__[elt]
-#             
-#             if pionModele.__class__.__name__ == "Combattant":
-#                 numero = 1
-#                 if len(self.combattants) > 0:
-#                     numero = max(self.combattants) + 1
-#                 pion.numero = numero    
-#                 pion.numComplementaire = self.numeroterNom(pion.nom())    
-#                 self.combattants[numero] = pion
-#                 self.pionDeplacerDansOrdreJeu(numero, len(self.ordreJeu) + 2)
-#                 
-#             elif pionModele.__class__.__name__ == "Decor":
-#                 numero = 10001
-#                 if len(self.decors) > 0:
-#                     numero = max(self.decors) + 10001
-#                 pion.numero = numero
-#                 self.decors[numero] = pion
-# 
-#             pion.position = self.proj.coord()
-#             pion.nbRotations = self.proj.nbRotations()
-#             pion.ajouterAuPlateau(self)
-# 
-#             cree = True
-#         return cree            
-
-#     def numeroterNom(self, nom):
-#         """renvoie le nom du pion avec un numero complementaire si necessaire """
-#         i = 1
-#         for numCombattant in self.combattants:
-#             if self.combattants[numCombattant].nom() == nom: i += 1     
-#         retour = str(i) if i > 1 else ""
-#         return retour
-        
     def pionDeposer(self, coordCase):
         """on depose le pion sur la case voulue"""
         if self.pionSelectionne() != None:
             pion = self.pionSelectionne()
         if pion != None:
-            if self.proj.projectionValide():        
+            if self.proj.valide():        
                 pion.majPosition(self.proj.coord(), self.proj.nbRotations())
 
-    def majZPion(self, valeur):
-        """met a jour l'altitude du pion selectionne"""
-        if self.pionSelectionne() != None:
-            self.pionSelectionne().majZ(valeur)
-
-    def dialogueVol(self, actuelle):
-        ecran = EcranVol(actuelle)
-        ecran.exec_() 
-        nouvelle = ecran.resultat()
-        del ecran
-        return nouvelle   
-            
-#     def pionSupprimer(self, num):
-#         """supprime le pion entre en parametre"""
-#         #settrace(trace_calls)
-#         if num in self.combattants:    
-#             self.pionDeplacerDansOrdreJeu(num, 0)
-#             pionSuppr = self.combattants.pop(num)
-#         elif num in self.decors:    
-#             pionSuppr = self.decors.pop(num)
-#             
-#         pionSuppr.retirerDuPlateau()
-            
-    ###############
-
-    ######### caches ###############
-
     def nouveauCache(self, listeCases):
         nouvelId = 0
         if len(self.caches) > 0:
@@ -1094,40 +1024,6 @@ class Plateau(QGraphicsScene, Materiel):
         del self.caches[idCache]
 
 
-    ###############"
-        
-    ######### gestion des evenements souris et clavier ###############
-    
-    def mouseMoveEvent(self, event):
-        super(Plateau, self).mouseMoveEvent(event)
-        if event.buttons() == Qt.LeftButton and self.vue().dragMode() != QGraphicsView.ScrollHandDrag:
-            coord = self.coordonneesAuPoint(event.scenePos())
-            if coord != None:
-                self.caseSurvolClicEnfonce(coord)  
-        else:
-            self.modeActif.mouvementSouris(event)
-            event.ignore() 
-
-    def mousePressEvent(self, event):
-        super(Plateau, self).mousePressEvent(event)
-        if event.button() == 1:
-            self.modeActif.clicGauche(event)
-        elif event.button() == 2:
-            self.modeActif.clicDroit(event)
-            event.accept()
-
-    def mouseReleaseEvent(self, event):
-        super(Plateau, self).mouseReleaseEvent(event)
-        self.modeActif.finClicGauche(event)
-
-    def keyPressEvent(self, event):
-        """gestion des evenements clavier"""
-        self.modeActif.toucheClavier(event)
-
-    ################   
-
-    ############### Fonctions diverses
-
     def centrerSur(self, num):
         """centre la vue sur le pion"""
         self.vue().centerOn(self.cases[self.pions[num].position].centreGraphique)
@@ -1148,39 +1044,24 @@ class Plateau(QGraphicsScene, Materiel):
             voisins = [(x, y-1), (x+1, y), (x,   y+1), (x-1, y)]
         return voisins      
 
-    def zone(self, origine, rayon, z=0, conditionFranchissable = False, conditionVisible = False):
+    def zone(self, origine, rayon, zR = 0):
         """renvoie un dictionnaire representant la liste des coordonnees des cases comprises dans la zone
            la zone en question est la liste des cases situees a une distance d des coordonnees d'origine
-           z = 0 -> hauteur z de l'origine par rapport a l'altitude de la case
-           conditionFranchissable = Vrai -> les cases infranchissables ne sont pas prises en compte
-           conditionVisible = Vrai -> les cases bloquant la visibilite ne sont pas prises en compte"""
-        aVerifier = []
-        aVerifier2 = []
+           zR -> altitude relative de l'origine de la zone"""
+        if not self.coordonneesValides(origine) or not rayon >= 0: return {}
+        if rayon == 0: return {origine: 0}
         resultat = {}
-        k = 0        
+        aVerifier = [] ; aVerifier2 = [] ; k = 0        
         #on part de la premiere case, puis on itere a partir de chaque nouveau depart sur les voisins
-        if origine in self.cases:
-            aVerifier.append(origine)
-            while k <= rayon:
-                for depart in aVerifier:
-                    for coord in self.cases[depart].voisins:
-                        if not coord in aVerifier and not coord in aVerifier2 and not coord in resultat:
-                            if conditionFranchissable and not conditionVisible:
-                                if self.cases[coord].estFranchissable(z):
-                                    aVerifier2.append(coord)
-                                elif not conditionFranchissable and conditionVisible:          
-                                    if self.cases[coord].terrain.visibilite:
-                                        aVerifier2.append(coord)
-                            elif conditionFranchissable and conditionVisible:          
-                                if self.cases[coord].estFranchissable(z) and self.cases[coord].terrain.visibilite:
-                                    aVerifier2.append(coord)
-                            else:
-                                aVerifier2.append(coord)      
-                for elt in aVerifier:
-                    resultat[elt] = k
-                aVerifier = aVerifier2
-                aVerifier2 = []
-                k += 1
+        aVerifier.append(origine)
+        while k <= rayon:
+            for depart in aVerifier:
+                for coord in self.cases[depart].voisins:
+                    if not coord in aVerifier and not coord in aVerifier2 and not coord in resultat:
+                        aVerifier2.append(coord)      
+            for elt in aVerifier:
+                resultat[elt] = k
+            aVerifier = aVerifier2 ; aVerifier2 = [] ; k += 1
         return resultat
 
     def zone3d(self, origine, rayon, zCible=0):
@@ -1197,8 +1078,7 @@ class Plateau(QGraphicsScene, Materiel):
     def cone(self, coord1, coord2):
         """renvoie les coord des cases composant le cone (en 2d)"""
         retour = []
-        x1, y1 = coord1
-        x2, y2 = coord2
+        x1, y1 = coord1 ; x2, y2 = coord2
         if x1 % 2 == 1: y1 += 0.5
         if x2 % 2 == 1: y2 += 0.5
         
@@ -1214,7 +1094,6 @@ class Plateau(QGraphicsScene, Materiel):
                     if abs( angleRef - angle ) <= 0.5 and ( (x - x1)**2 + (y - y1)**2 ) <= dist2Ref \
                     and ( (x - x1) * (x2 - x1) ) > 0:
                         retour.append(coord)                
-        
         else:
             #secteur vertical
             angleRef = (x2 - x1) / (y2 - y1)
@@ -1251,14 +1130,34 @@ class Plateau(QGraphicsScene, Materiel):
             tmp1 = tmp2
         return retour 
     
+
+    def polygone(self, x, y):
+        """renvoie l'objet graphique hexagone de la case de coordonnees (x, y)"""
+        polygone = QPolygonF()
+        if self.formeCases == "H":
+            #si x est impair sur un plateau a cases hexagonales, le y est augmente de 0.5
+            if 1 == (x % 2):
+                y += 0.5
+            polygone  << QPointF(((x*0.866)+0.2886)*120,  y*120) \
+                      << QPointF(((x*0.866)+0.866)*120,   y*120) \
+                      << QPointF(((x*0.866)+1.1547)*120, (y+0.5)*120) \
+                      << QPointF(((x*0.866)+0.866)*120,  (y+1)*120) \
+                      << QPointF(((x*0.866)+0.2886)*120, (y+1)*120)  \
+                      << QPointF( (x*0.866)*120,         (y+0.5)*120)
+        else:
+            polygone  << QPointF(x*120,      y*120) \
+                      << QPointF((x+1)*120,  y*120) \
+                      << QPointF((x+1)*120,  (y+1)*120) \
+                      << QPointF(x*120,      (y+1)*120)          
+        return polygone
+    
     def polygoneAgglo(self, listeCases):
         """renvoie un polygone contruit par agglomeration des polygones des cases de la liste
            les cases doivent etre adjacentes (cases hexagonales ou carrees)"""
         segments = []
-        case = Case(self)
         #on parcourt les faces des polygones des cases, et on ne garde que ceux qui n'ont pas de case 'en face'
         for coord in listeCases:
-            polygone = case.polygone(coord[0], coord[1])
+            polygone = self.polygone(coord[0], coord[1])
             voisins = self.lstCoordAdjacentes(coord[0], coord[1])
             
             for i in range(0, len(voisins)):
@@ -1305,148 +1204,61 @@ class Plateau(QGraphicsScene, Materiel):
 
     def coordonneesAuPoint(self, point):
         """renvoie les coordonnees de la case situee au QPointF entre en parametre"""
-        coord = None
-        if point != None:
-            lstObjets = self.vue().scene().items(point)
-            for objet in lstObjets:
-                if objet:
-                    if objet.__class__.__name__ == "Case":
-                        coord = (objet.x, objet.y)
-                        break       
-        return coord            
-
-    def casesSousForme(self, forme, plein = True, epaisseur = 0):
-        """renvoie la liste des cases en collision avec un QGraphicsItem en parametre
-            plein = False: pas le contenu de la forme
-            epaisseur = renvoie aussi les cases voisines jusqu'a la distance demandee"""
-        tmp = []
-        listeCases = []
-        point1 = None
-        point2 = None
-        #point 1 et 2
-        if forme.__class__.__name__ == "QGraphicsLineItem":
-            point1 = forme.line().p1()
-            point2 = forme.line().p2()
-        elif forme.__class__.__name__ == "QGraphicsRectItem" or forme.__class__.__name__ == "QGraphicsEllipseItem":
-            point1 = forme.rect().topLeft()
-            point2 = forme.rect().bottomRight()
-        else:
-            point1 = forme.boundingRect().topLeft()
-            point2 = forme.boundingRect().bottomRight()            
+        item = self.itemAt(point)
+        try:
+            coord = item.coord()
+        except:
+            coord = None
+        return coord       
+
+    def pionAuPoint(self, point):
+        """retourne le premier pion de la pile s'il y en a plusieurs"""
+        coord = self.coordonneesAuPoint(point)
+        if not coord: return None
+        pions = self.cases[coord].occupants()
+        if len(pions) == 0: return None
+        return pions[0]
+
+    def ldmValide(self, origine, cible):
+        """la ligne de mire entre les deux points est elle valide
+           origine et cible sont toutes deux de la forme (x,y,z)"""
+        if not cible != origine: return False
+        ldm = br.ligne(origine, cible, self.formeCases)
+        if len(ldm) == 0: return False
+        ldm.remove(origine) ; ldm.remove(cible)
+        x0, y0, z0 = origine ; x1, y1, z1 = cible
+        for coord in ldm:
+            x, y, z = coord
+            occupant = self.cases[(x, y)].occupant(z)
+            if occupant:
+                #si une case de la ligne est occupee par autre chose que le tireur et sa cible
+                if occupant != self.cases[(x0, y0)].occupant(z0) and \
+                   occupant != self.cases[(x1, y1)].occupant(z1): 
+                    return False
+        return True       
  
-        #preselection des cases (meilleures perf)    
-        if point1 != None and point2 != None and point1 != point2:
-            preSelection = self.preSelectionCollision(point1, point2)
-        else:
-            preSelection = []
-            for coord in self.cases:
-                preSelection.append(coord)
-       
-        #on liste les cases en collision avec la forme 
-        for coord in preSelection:
-            if self.cases[coord].collidesWithItem(forme, Qt.IntersectsItemShape):
-                if plein:
-                    tmp.append(coord) 
-                else:
-                    contenu = True
-                    for i in range(0,len(self.cases[coord].polygon())):
-                        if not forme.contains(self.cases[coord].polygon().at(i)):
-                            contenu = False
-                            break
-                    if contenu == False:
-                        tmp.append(coord)    
-        #on applique l'epaisseur du pinceau (lignes ou formes vides seulement) si necessaire
-        if not plein and epaisseur > 0:
-            for coord in tmp:
-                zone = self.zone(coord, epaisseur)
-                for coord2 in zone:
-                    if not coord2 in listeCases:
-                        listeCases.append(coord2)
-        else:
-            listeCases = tmp
-        #si la liste est vide, on ajoute l'origine de la forme
-        if len(listeCases) == 0:
-            listeCases = [self.coordonneesAuPoint(point1)]    
-        return listeCases                
-
-    def preSelectionCollision(self, point1, point2):
-        """renvoie une liste des cases qui peuvent etre concernees par une collision avec
-           un graphicsItem (pour des raisons de performance)"""
-        preSelection = []
-        coord1 = self.coordonneesAuPoint(point1)  
-        coord2 = self.coordonneesAuPoint(point2)
-        if coord1 != None and coord2 != None:
-            minX = min(coord1[0], coord2[0]) - 1
-            maxX = max(coord1[0], coord2[0]) + 1
-            minY = min(coord1[1], coord2[1]) - 1
-            maxY = max(coord1[1], coord2[1]) + 1
-            for coord in self.cases:
-                if coord[0] >= minX and coord[0] <= maxX and coord[1] >= minY and coord[1] <= maxY :
-                    preSelection.append(coord)
-        else:
-            preSelection = self.cases
-        return preSelection
-    
-    def listeZCible(self, coord):
-        """retourne l'altitude absolue a prendre en compte en fonction de la case ciblee
-            c'est l'altitude la case si aucun pion n'occupe la case
-            c'est la liste des cases occupees en hauteur par le pion sinon
-            'coord' est de la forme (x, y)"""
-        if self.cases[coord].estOccupee():
-            retour = range(self.cases[coord].occupant().zAbs(), \
-                            self.cases[coord].occupant().zAbs() + self.cases[coord].occupant().hauteur)
-        else:
-            retour = [self.cases[coord].altitude]             
-        return retour
-
-    def estCibleAttaqueDistValide(self, coordCible):
-        """la case cible est elle valide pour une attaque a distance depuis la position et hauteur
-            du pion selectionne
-            les coord sont de la forme (x, y)"""
-        valide = False
-        x1, y1 = self.pionSelectionne().position
-        coordOrigine = (x1, y1, (self.pionSelectionne().zAbs() + self.pionSelectionne().hauteur))
-        
-        x2, y2 = coordCible
-        cible = self.cases[coordCible].occupant()
-        listeZ2 = self.listeZCible(coordCible)      
-        if coordOrigine[0] != coordCible[0] or coordOrigine[1] != coordCible[1]:
-            for z2 in listeZ2:
-                zValide = True
-                casesLigneMire = br.ligne(coordOrigine, (x2, y2, z2), self.formeCases)
-                casesLigneMire.remove(coordOrigine)
-                casesLigneMire.remove((x2, y2, z2))
-                for coord in casesLigneMire:
-                    if zValide:
-                        x, y, z = coord
-                        if self.cases[(x,y)].estOccupee(z): 
-                            if self.cases[(x,y)].occupant(z) not in [self.pionSelectionne(), cible]:
-                                zValide = False
-                if zValide: 
-                    valide = True #si au moins un des z cibles est valide, la ligne de mire est valide
-                    break
-                
-        return valide       
- 
-    def coutDep(self, coord1, coord2, z2 = 0):
+    def coutDep(self, coord1, coord2, z2 = None):
         """renvoie le cout de deplacement de la case 1 a la case 2 
         pour le pion actuellement selectionne /
         un cout egal a -1 implique un deplacement impossible"""
         retour = 0
         dist = 1
         if not self.cases[coord2].terrain.franchissable: return -1
-        if self.cases[coord2].occupant(z2, Combattant): return -1
+        
+        if self.cases[coord2].z1(): return -1
+        if z2 == None: z2 = self.cases[coord2].z1()
+        if self.cases[coord2].occupant(z2): return -1
 
-        if self.pionSelectionne().z == 0:
-            dz = self.cases[coord2].zDep() - self.cases[coord1].zDep()
+        if self.pionSelectionne().zR == 0:
+            dz = self.cases[coord2].z1() - self.cases[coord1].z1()
             if dz < (-1 * self.pionSelectionne().saut): return -1
    
-            if dz > self.pionSelectionne().hauteur:
+            if dz > self.pionSelectionne().h:
                 #si la diff de hauteur est superieure a la hauteur du combattant, il escalade
                 if not self.pionSelectionne().depEscalade > 0: return -1
                 retour += self.pionSelectionne().coutDep("depEscalade", dz)
            
-            elif 0 < dz <= self.pionSelectionne().hauteur:
+            elif 0 < dz <= self.pionSelectionne().h:
                 dist += dz
 
             if self.cases[coord2].terrain.nage:
@@ -1489,8 +1301,52 @@ class Plateau(QGraphicsScene, Materiel):
             self.polygoneZonePlacement.setPolygon(polygone)
             self.listeCasesZonePlacement = listeCases
 
-
-
+    ####### maj des panneaux d'info
+    def majInfoPion(self, pion = None):
+        self.majInfoCb((pion if pion.numero > 0 else None) if pion else None)
+        self.majInfoDc((pion if pion.numero < 0 else None) if pion else None)
+    
+    def majInfoCb(self, cb = None):
+        self.fenetre.ui.icb_panneau.setVisible((cb != None))
+        if cb:
+            self.fenetre.ui.icb_image.chargerImage(cb.icone())
+            self.fenetre.ui.icb_nom.majTexte(contractTxt(cb.nom(), 25))
+            self.fenetre.ui.icb_mort.setVisible((cb.etat == 4))
+            self.fenetre.ui.icb_image.setEnabled((cb.etat != 4))
+            self.fenetre.ui.icb_etourdi.setVisible(0 in cb.statuts)
+            self.fenetre.ui.icb_brule.setVisible(4 in cb.statuts)
+            self.fenetre.ui.icb_paralyse.setVisible(2 in cb.statuts)
+            self.fenetre.ui.icb_empoisonne.setVisible(3 in cb.statuts)
+            self.fenetre.ui.icb_gele.setVisible(1 in cb.statuts)
+            self.fenetre.ui.icb_etat.majTexte(lstLibEtats("cb")[cb.etat])
+            self.fenetre.ui.icb_hauteur.majTexte("Hauteur: {}".format(cb.h))
+            self.fenetre.ui.icb_vol.majTexte("En vol: {}".format(cb.zR) if cb.enVol else "")
+    
+    def majInfoDc(self, dc = None):
+        self.fenetre.ui.idc_panneau.setVisible((dc != None))
+        if dc:
+            self.fenetre.ui.idc_image.chargerImage(dc.icone())
+            self.fenetre.ui.idc_nom.majTexte(contractTxt(dc.nom(), 25))
+            self.fenetre.ui.idc_detruit.setVisible((dc.etat == 4))
+            self.fenetre.ui.idc_image.setEnabled((dc.etat != 4))
+            self.fenetre.ui.idc_brule.setVisible(4 in dc.statuts)
+            self.fenetre.ui.idc_verrouille.setVisible(5 in dc.statuts)
+            self.fenetre.ui.idc_etat.majTexte(lstLibEtats("dc")[dc.etat])            
+            self.fenetre.ui.idc_hauteur.majTexte("Hauteur: {}".format(dc.h) if not (self.zP and dc.hMax) else "")
+        
+    def majInfoTr(self, case = None):
+        if case:
+            self.fenetre.ui.ic_coord.majTexte("X{} Y{}".format(case.x, case.y))
+            self.fenetre.ui.ic_terrain.majTexte(case.terrain.nom() if (len(case.terrain.nom()) > 0) else "Case")
+            self.fenetre.ui.ic_altitude.majTexte("{}".format(case.z0))
+
+            if case.effetActif not in ["", "aucun"]:
+                imgEffet = {"brule": "feu_16.png", "eau": "eau_16.png","glace": "glace_16.png","poison": "poison_16.png"}
+                pix = QPixmap(":/interface/16/ressource/{}".format(imgEffet[case.effetActif]))
+                self.fenetre.ui.ic_effet.setPixmap(pix)          
+            else:
+                self.fenetre.ui.ic_effet.clear()  
+        
 
 
 

lib/ProjectionDep.py

@@ -1,22 +1,18 @@
 """Projection du deplacement d'un pion"""
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
 from Forme import Forme
-from Combattant import Combattant
 
 class ProjectionDep():
     def __init__(self, plateau):
         self.plateau = plateau
-        self._pion = None
         self._active = False
+        self._pion = None
         
         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
@@ -38,50 +34,39 @@ class ProjectionDep():
     def nbRotations(self):
         return self._nbRotations
 
+    def listeCoord(self):
+        return self._forme.listeCases(self._coord, self._nbRotations)
+
+    def listeCases(self):
+        return [self.plateau.cases[coord] for coord in self.listeCoord()]
+                
     def desactiver(self):
         for coord in self._forme.listeCases(self._coord, self._nbRotations):
             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"""
+    def existe(self):
+        """la projection est valide si toutes les cases de la forme existent
+           si non, elle n'apparait pas"""
         for coord in self._forme.listeCases(self._coord, self._nbRotations):
             if not coord in self.plateau.cases: return False
         return True
 
-    def deplacementValide(self):
-        """le deplacement est valide si toutes les cases de la forme sont franchissables
-           et pas occupees par un combattant"""
-        if self.projectionValide():
-            for coord in self._forme.listeCases(self._coord, self._nbRotations):
-                if not self.plateau.cases[coord].terrain.franchissable: return False
-                
-                if self.plateau.cases[coord].occupant(None, Combattant) != None:
-                    if self.plateau.cases[coord].occupant() != self._pion: return False
-
-        return True        
-
+    def valide(self):
+        """le deplacement est valide si toutes les cases de la forme 
+           sont franchissables par le pion"""
+        if not self.existe(): return False  
+        return self._pion.projectionValide(self)
+        
     def maj(self):
         self._active = True
-        if self.projectionValide():
-            depValide = self.deplacementValide()
-            i = 0
+        if self.existe():
+            depValide = self.valide()
             for coord in self._forme.listeCases(self._coord, self._nbRotations):
-                i += 1
                 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
-            
 
 
 

lib/Terrain.py

@@ -2,7 +2,8 @@
 # -*- coding: utf-8 -*-
 from PyQt4.QtGui import QColor
 from lib.mat import Materiel
-import rsc
+from lib.rsc import RImage
+
 
 class Terrain(Materiel):
     """terrain a affecter a une case"""
@@ -11,10 +12,11 @@ class Terrain(Materiel):
         self._type = "tr"
 
         self.couleur = QColor("")       #couleur si pas de texture
-        self.imgTexture = rsc.RImage()        #image source de la texture
+#         self.imgTexture = rsc.RImage()        #image source de la texture
         self.nage = False                   #cette case se franchit a la nage
         self.franchissable = True           #peut on franchir cette case
         self.visibilite = True              #peut on voir au travers 
+        self.hPlafond = False              #altitude egale a celle du plafond (paroi, mur) 
         self.modDeplacement = 1.00         #modificateur a appliquer au deplacement   
 
     def __getstate__(self):
@@ -26,4 +28,11 @@ class Terrain(Materiel):
 
     def icone(self):
         """renvoie l'image a afficher dans les listes"""
-        return self.imgTexture
+#         return self.imgTexture
+        img = RImage()
+        img.gomette(self.couleur)
+        return img
+    
+    
+    
+    

lib/VueEditionForme.py

@@ -8,6 +8,7 @@ from PyQt4.QtGui import QGraphicsScene, QColor, QGraphicsPolygonItem, \
     QGraphicsSimpleTextItem, QFont
 
 from Pion import ImgPion, EtiquettePion
+from lib import dmF
 
 
 class VueEditionForme(QGraphicsScene):
@@ -369,7 +370,8 @@ class VefEtiquette(QGraphicsSimpleTextItem):
 
     def _maj(self):
         if len(self._def.txt) > 0:
-            self.setText(QString.fromUtf8(self._def.txt))
+            txt = dmF.contractTxt(self._def.txt, 20)
+            self.setText(QString.fromUtf8(txt))
             self.setPos(QPointF(self._def.dx - 0.112*120, self._def.dy - 0.5*120))
 
             police = QFont("Verdana", self._def.taille_police)

lib/commun.py

@@ -5,15 +5,8 @@ Fonctions communes
 import os
 from random import randint
 import time
-
-from PyQt4.QtCore import SIGNAL, Qt, QString
-from PyQt4.QtGui import QDialog, QApplication
-
+from PyQt4.QtGui import QApplication
 import cPickle as pickle
-from ui.ecran_confirmation import Ui_cfrm_fenetre
-from ui.ecran_saisie import Ui_saisi_fenetre  
-from ui.ecran_message import Ui_msg_fenetre 
-
 
 ppal = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))
 

lib/dialogues.py

@@ -5,9 +5,11 @@ boites de dialogues
 from PyQt4.QtCore import SIGNAL, Qt, QString
 from PyQt4.QtGui import QDialog
 
+from lib.ui.ecran_altitude import Ui_alt_fenetre
 from lib.ui.ecran_confirmation import Ui_cfrm_fenetre
 from lib.ui.ecran_message import Ui_msg_fenetre
 from lib.ui.ecran_saisie import Ui_saisi_fenetre
+from lib.ui.ecran_vol import Ui_vol_fenetre
 
 
 def dmConfirmer(txt):
@@ -119,6 +121,80 @@ class EcranMessage(QDialog):
     def ok(self):
         self.done(1)     
 
+def dmVol(actuelle, maxi = None):
+    fen = EcranVol(actuelle, maxi)
+    fen.show()
+    fen.exec_()
+    return fen.resultat()
+
+class EcranVol(QDialog):
+    """interface de gestion du vol d'un pion
+        renvoie la nouvelle altitude du pion"""
+    def __init__(self, actuelle = 0, maxi = None, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranVol, self).__init__(parent)
+        self._resultat = 0
+        self.createWidgets()
+        self.ouverture(actuelle, maxi)
+          
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_vol_fenetre()
+        self.ui.setupUi(self)                                                          
+        self.connect(self.ui.vol_ok, SIGNAL("clicked()"), self.ok)
+        self.ui.vol_valeur.selectAll()
+        
+    def ouverture(self, actuelle, maxi):
+        """ouverture en mode edition"""
+        if maxi != None:
+            self.ui.vol_valeur.setMaximum(maxi)
+            if actuelle > maxi: actuelle = maxi
+        self.ui.vol_valeur.setValue(actuelle)
+        self._resultat = actuelle
+        
+    def resultat(self):
+        return self._resultat
 
+    def ok(self):
+        """enregistre le terrain cree/edite"""
+        self._resultat = self.ui.vol_valeur.value()
+        self.done(1)
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Return:
+            self.ok()
+
+def dmAltitude(maxi = None):
+    fen = EcranAltitude(maxi)
+    fen.show()
+    fen.exec_()
+    return fen.resultat()
+
+class EcranAltitude(QDialog):
+    """interface de gestion du vol d'un pion
+        renvoie la nouvelle altitude du pion"""
+    def __init__(self, maxi, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranAltitude, self).__init__(parent)
+        self._resultat = 0
+        self._maxi = maxi
+        self.createWidgets()
+          
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_alt_fenetre()
+        self.ui.setupUi(self)              
+        if self._maxi:
+            self.ui.alt_valeur.setMaximum(self._maxi)                                     
+        self.connect(self.ui.alt_ok, SIGNAL("clicked()"), self.ok)
+        self.ui.alt_valeur.selectAll()
 
+    def resultat(self):
+        return self._resultat
 
+    def ok(self):
+        """enregistre le terrain cree/edite"""
+        self._resultat = self.ui.alt_valeur.value()
+        self.done(1)

lib/dmF.py

@@ -14,4 +14,98 @@ def maxi(e1, e2):
         retour = e1
     else:
         retour = e2
-    return retour
+    return retour
+
+def contractTxt(txt, nb = 0):
+    """retourne un texte de longueur limitee, 
+       de la forme 'abcd...xyz'
+       nb doit etre superieur ou egal a 1"""
+    if not nb > 0: return txt
+    if not nb >= 4: return txt[:nb]
+    if not nb >= 10: return "{}...".format(txt[:(nb-3)])
+    if len(txt) <= nb: return txt
+    t1 = txt[:(nb-6)]
+    t2 = txt[-3:]
+    return "{}...{}".format(t1, t2)
+
+def inverser(lst):
+    """retourne la liste inversee"""
+    return list(reversed(lst))
+
+class DmPile(object):
+    """pile d'objets ayant des hauteurs differentes
+       le dernier objet ajoute est dessus (premier)"""
+    def __init__(self):
+        self._pile = []
+
+    def __getitem__(self, zCible):
+        """renvoie l'objet a l'altitude z"""
+        if not zCible >= 0: return None
+        z = 0
+        for cpl in inverser(self._pile):
+            z += cpl[1]
+            if z > zCible: return cpl[0]
+        return None
+    
+    def __repr__(self, *args, **kwargs):
+        return str(self._pile)
+            
+    def pile(self):
+        """retourne la pile d'objets (sans les hauteurs)"""
+        return [cpl[0] for cpl in self._pile]
+
+    def elip(self):
+        """retourne la pile (sans les hauteurs) a l'envers (en partant du dessous)"""
+        return inverser([cpl[0] for cpl in self._pile])
+
+    def __iter__(self):
+        return self.pile().__iter__()
+    
+    def ajouter(self, objet, h = 1):   
+        """ajoute un objet de hauteur h sur la pile""" 
+        self._pile.insert(0, (objet,h))
+
+    def vide(self):
+        return (len(self._pile) == 0)
+
+    def premier(self):
+        if self.vide(): return None
+        return self.pile()[0]
+
+    def retirer(self, objet):
+        """retire l'objet de la pile"""
+        if not objet in self.pile(): 
+            print "Impossible trouver l'objet dans la pile, impossible de l'en retirer"
+            return
+        index = self.pile().index(objet)
+        cpl = self._pile[index]
+        self._pile.remove(cpl)
+        
+    def hauteur(self):
+        """retourne la hauteur totale de la pile"""
+        retour = 0
+        for h in [cpl[1] for cpl in self._pile]:
+            retour += h
+        return retour
+    
+    def hDe(self, obj):
+        """renvoie la hauteur de l'objet demande, None sinon"""
+        d = {obj:h for obj, h in self._pile}
+        if not obj in d: return None
+        return d[obj]
+
+    def zR(self, obj):
+        """renvoie l'altitude relative de l'objet demande, None sinon"""
+        z = 0
+        for o, h in inverser(self._pile):
+            if o == obj: return z
+            z += h
+        return None
+            
+            
+        
+# pile = DmPile()
+# pile.ajouter("a",10)
+# pile.ajouter("b",3)
+# pile.ajouter("c",3)
+# print pile.zR("b")

lib/frameAttaque.py

@@ -4,6 +4,9 @@
 """
 import sys
 
+from PyQt4.QtCore import QString, QSize
+from PyQt4.QtGui import QFrame, QHBoxLayout, QLayout
+
 from Actions import *
 from lib.br import ligne
 from lib.ui.dm import DmLabel, DmLineEdit

lib/rsc.py

@@ -5,7 +5,7 @@ import os
 from shutil import copyfile
 import sys
 
-from PyQt4.QtCore import Qt, SIGNAL, QString
+from PyQt4.QtCore import Qt, SIGNAL, QString, QSize
 from PyQt4.QtGui import QPixmap, QDialog, QFrame, QColor, QPalette, QApplication, \
     QFileDialog
 
@@ -14,6 +14,7 @@ from dialogues import dmConfirmer
 from ui.ecran_editerImage import Ui_edi_fenetre
 from ui.ecran_explorateur import Ui_exr_fenetre
 from ui.panneauImage import Ui_exi_panneau
+from pygame.gfxdraw import pixel
 
 
 def selectionImage():
@@ -113,6 +114,12 @@ class RImage(Ressource):
     def __init__(self):
         super(RImage, self).__init__()
         self._type = "im"
+        self._gommette = None    #les gommettes sont des images crees a partir d'une couleur
+
+    def __setstate__(self, state):
+        """correctif 220915"""
+        self.__dict__ = state
+        if not "_gomette" in self.__dict__: self._gomette = None
 
     def libelleSType(self):
         lstSTypes = ["[Non defini]", "Creature (portrait)", "Creature (pion)", \
@@ -120,7 +127,11 @@ class RImage(Ressource):
         return lstSTypes[self._sType]
 
     def pix(self, l = 0, h = 0):
-        pix = QPixmap(self.fichier())
+        if self._gomette != None:
+            pix = QPixmap(QSize(16, 16))
+            pix.fill(self._gomette)          
+        else:  
+            pix = QPixmap(self.fichier())
         if not pix.isNull():
             if l > 0 and h > 0:
                 pix = pix.scaled(l, h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
@@ -130,6 +141,8 @@ class RImage(Ressource):
                 pix = pix.scaledToHeight(h, Qt.SmoothTransformation)                
         return pix
 
+    def gomette(self, couleur):
+        self._gomette = couleur
 
 class ExplorateurImages(QDialog):
     def __init__(self, parent=None):

lib/test.py

@@ -1,4 +1,3 @@
 
-
-for i in range(0,1):
-    print i
+lst = []
+print range(0,0)

lib/ui/creerPlateau.ui

@@ -7,19 +7,19 @@
     <x>0</x>
     <y>0</y>
     <width>480</width>
-    <height>321</height>
+    <height>311</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>480</width>
-    <height>263</height>
+    <height>311</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>480</width>
-    <height>400</height>
+    <height>311</height>
    </size>
   </property>
   <property name="font">
@@ -33,8 +33,8 @@
   <widget class="QSpinBox" name="crp_hauteur">
    <property name="geometry">
     <rect>
-     <x>410</x>
-     <y>60</y>
+     <x>265</x>
+     <y>78</y>
      <width>51</width>
      <height>31</height>
     </rect>
@@ -101,7 +101,7 @@
    <property name="geometry">
     <rect>
      <x>350</x>
-     <y>280</y>
+     <y>270</y>
      <width>111</width>
      <height>30</height>
     </rect>
@@ -121,10 +121,10 @@
   <widget class="QLabel" name="label_7">
    <property name="geometry">
     <rect>
-     <x>180</x>
-     <y>60</y>
+     <x>30</x>
+     <y>50</y>
      <width>151</width>
-     <height>31</height>
+     <height>21</height>
     </rect>
    </property>
    <property name="font">
@@ -209,8 +209,8 @@
   <widget class="QSpinBox" name="crp_largeur">
    <property name="geometry">
     <rect>
-     <x>320</x>
-     <y>60</y>
+     <x>175</x>
+     <y>78</y>
      <width>51</width>
      <height>31</height>
     </rect>
@@ -328,8 +328,8 @@
   <widget class="QGroupBox" name="crp_formes">
    <property name="geometry">
     <rect>
-     <x>30</x>
-     <y>100</y>
+     <x>150</x>
+     <y>126</y>
      <width>311</width>
      <height>41</height>
     </rect>
@@ -351,7 +351,7 @@
       <x>80</x>
       <y>10</y>
       <width>111</width>
-      <height>20</height>
+      <height>31</height>
      </rect>
     </property>
     <property name="font">
@@ -372,7 +372,7 @@
       <x>220</x>
       <y>10</y>
       <width>81</width>
-      <height>21</height>
+      <height>31</height>
      </rect>
     </property>
     <property name="font">
@@ -390,7 +390,7 @@
       <x>0</x>
       <y>10</y>
       <width>61</width>
-      <height>21</height>
+      <height>31</height>
      </rect>
     </property>
     <property name="text">
@@ -421,8 +421,8 @@
   <widget class="QLabel" name="label">
    <property name="geometry">
     <rect>
-     <x>385</x>
-     <y>62</y>
+     <x>240</x>
+     <y>80</y>
      <width>21</width>
      <height>31</height>
     </rect>
@@ -443,7 +443,7 @@
    <property name="geometry">
     <rect>
      <x>10</x>
-     <y>280</y>
+     <y>270</y>
      <width>141</width>
      <height>30</height>
     </rect>
@@ -463,9 +463,9 @@
   <widget class="QToolButton" name="crp_couleur">
    <property name="geometry">
     <rect>
-     <x>430</x>
-     <y>104</y>
-     <width>31</width>
+     <x>30</x>
+     <y>136</y>
+     <width>51</width>
      <height>31</height>
     </rect>
    </property>
@@ -481,7 +481,7 @@
    <property name="geometry">
     <rect>
      <x>30</x>
-     <y>60</y>
+     <y>78</y>
      <width>131</width>
      <height>31</height>
     </rect>
@@ -546,10 +546,10 @@
   <widget class="Line" name="line">
    <property name="geometry">
     <rect>
-     <x>340</x>
-     <y>100</y>
-     <width>118</width>
-     <height>3</height>
+     <x>30</x>
+     <y>119</y>
+     <width>131</width>
+     <height>16</height>
     </rect>
    </property>
    <property name="orientation">
@@ -559,9 +559,9 @@
   <widget class="DmTextEdit" name="crp_presentation">
    <property name="geometry">
     <rect>
-     <x>30</x>
-     <y>160</y>
-     <width>431</width>
+     <x>28</x>
+     <y>209</y>
+     <width>421</width>
      <height>41</height>
     </rect>
    </property>
@@ -606,8 +606,8 @@
   <widget class="QLabel" name="label_3">
    <property name="geometry">
     <rect>
-     <x>32</x>
-     <y>141</y>
+     <x>30</x>
+     <y>190</y>
      <width>151</width>
      <height>21</height>
     </rect>
@@ -618,15 +618,31 @@
     </font>
    </property>
    <property name="text">
-    <string>Présentation (publique)</string>
+    <string>Texte de présentation : </string>
    </property>
   </widget>
-  <widget class="DmTextEdit" name="crp_description">
+  <widget class="QCheckBox" name="crp_plafond">
    <property name="geometry">
     <rect>
-     <x>30</x>
-     <y>228</y>
-     <width>431</width>
+     <x>340</x>
+     <y>80</y>
+     <width>81</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string> Plafond : </string>
+   </property>
+  </widget>
+  <widget class="QSpinBox" name="crp_zP">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="geometry">
+    <rect>
+     <x>420</x>
+     <y>80</y>
+     <width>41</width>
      <height>31</height>
     </rect>
    </property>
@@ -667,35 +683,33 @@
      </disabled>
     </palette>
    </property>
+   <property name="value">
+    <number>6</number>
+   </property>
   </widget>
-  <widget class="QLabel" name="label_4">
+  <widget class="Line" name="line_2">
    <property name="geometry">
     <rect>
-     <x>32</x>
-     <y>210</y>
-     <width>191</width>
-     <height>20</height>
+     <x>30</x>
+     <y>170</y>
+     <width>431</width>
+     <height>16</height>
     </rect>
    </property>
-   <property name="font">
-    <font>
-     <pointsize>8</pointsize>
-    </font>
-   </property>
-   <property name="text">
-    <string>Description (créateur seulement)</string>
+   <property name="orientation">
+    <enum>Qt::Horizontal</enum>
    </property>
   </widget>
  </widget>
  <customwidgets>
   <customwidget>
-   <class>DmTextEdit</class>
-   <extends>QTextEdit</extends>
+   <class>DmLineEdit</class>
+   <extends>QLineEdit</extends>
    <header location="global">dm.h</header>
   </customwidget>
   <customwidget>
-   <class>DmLineEdit</class>
-   <extends>QLineEdit</extends>
+   <class>DmTextEdit</class>
+   <extends>QTextEdit</extends>
    <header location="global">dm.h</header>
   </customwidget>
  </customwidgets>

lib/ui/dm.py

@@ -292,7 +292,8 @@ class DmTableMat(DmTableWidget):
         for mat in listeMat:
             ligne = self.nouvelleLigneFin()
             self.majTexte(ligne, 0, mat.idM())
-            icon = QIcon() if not mat.icone() else QIcon(mat.icone().fichier())
+            img = mat.icone()
+            icon = QIcon(img.pix()) if img else QIcon() 
             item = QTableWidgetItem(icon, QString.fromUtf8(mat.nom()))
             self.setItem(ligne, 1, item)
           
@@ -480,51 +481,7 @@ class DmTableMenu(QTableWidget):
         if ligne == 0:
             self.setItemSelected(item, True)
 
-class DmFrameInf_Combattant(QGroupBox):
-    """frame d'information (combattant)"""
-    def __init__(self, parent = None):
-        super(DmFrameInf_Combattant, self).__init__(parent)
-
-    def maj(self, combattant):
-        self.setVisible((combattant != None))
-        if combattant:
-            self.findChild(DmLabel, "inf_pionNom").majTexte(combattant.nom())
-            self.findChild(DmLabel, "inf_pionImage").chargerImage(combattant.img.rimage)
-            self.findChild(DmLabel, "inf_pionEffet").setVisible(False)
-            
-
-class DmFrameInf_Decor(QGroupBox):
-    """frame d'information (decor)"""
-    def __init__(self, parent = None):
-        super(DmFrameInf_Decor, self).__init__(parent)
-
-    def maj(self, decor):
-        self.setVisible((decor != None))
-        if decor:
-            self.findChild(DmLabel, "inf_decorNom").majTexte(decor.nom())
-            self.findChild(DmLabel, "inf_decorImage").chargerImage(decor.img.rimage)
-
-class DmFrameInf_Case(QGroupBox):
-    """frame d'information (case)"""
-    def __init__(self, parent = None):
-        super(DmFrameInf_Case, self).__init__(parent)
-
-    def maj(self, case):
-        self.setVisible((case != None))
-        if len(case.terrain.nom()) > 0:
-            self.findChild(DmLabel, "inf_caseTerrain").majTexte(case.terrain.nom())
-        else:
-            self.findChild(DmLabel, "inf_caseTerrain").majTexte("Case")
-            
-        self.findChild(DmLabel, "inf_caseCoord").majTexte("X: {}  Y: {}".format(case.x, case.y))
-        self.findChild(DmLabel, "inf_caseAltitude").majTexte("Altitude: {}".format(case.altitude))
-        
-        if case.effetActif not in ["", "aucun"]:
-            imgEffet = {"brule": "feu_16.png", "eau": "eau_16.png","glace": "glace_16.png","poison": "poison_16.png"}
-            pix = QPixmap(":/interface/16/ressource/{}".format(imgEffet[case.effetActif]))
-            self.findChild(DmLabel, "inf_caseEffet").setPixmap(pix)          
-        else:
-            self.findChild(DmLabel, "inf_caseEffet").clear()      
+    
 
 class DmFrame(QFrame):
     """surcharge de QFrame"""

lib/ui/ecran_creerPlateau.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'creerPlateau.ui'
 #
-# Created: Fri Aug 28 15:57:31 2015
+# Created: Mon Sep 21 17:21:44 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -26,14 +26,14 @@ except AttributeError:
 class Ui_crp_fenetre(object):
     def setupUi(self, crp_fenetre):
         crp_fenetre.setObjectName(_fromUtf8("crp_fenetre"))
-        crp_fenetre.resize(480, 321)
-        crp_fenetre.setMinimumSize(QtCore.QSize(480, 263))
-        crp_fenetre.setMaximumSize(QtCore.QSize(480, 400))
+        crp_fenetre.resize(480, 311)
+        crp_fenetre.setMinimumSize(QtCore.QSize(480, 311))
+        crp_fenetre.setMaximumSize(QtCore.QSize(480, 311))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         crp_fenetre.setFont(font)
         self.crp_hauteur = QtGui.QSpinBox(crp_fenetre)
-        self.crp_hauteur.setGeometry(QtCore.QRect(410, 60, 51, 31))
+        self.crp_hauteur.setGeometry(QtCore.QRect(265, 78, 51, 31))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -55,14 +55,14 @@ class Ui_crp_fenetre(object):
         self.crp_hauteur.setObjectName(_fromUtf8("crp_hauteur"))
         self.crp_ok = QtGui.QPushButton(crp_fenetre)
         self.crp_ok.setEnabled(False)
-        self.crp_ok.setGeometry(QtCore.QRect(350, 280, 111, 30))
+        self.crp_ok.setGeometry(QtCore.QRect(350, 270, 111, 30))
         font = QtGui.QFont()
         font.setPointSize(10)
         self.crp_ok.setFont(font)
         self.crp_ok.setDefault(True)
         self.crp_ok.setObjectName(_fromUtf8("crp_ok"))
         self.label_7 = QtGui.QLabel(crp_fenetre)
-        self.label_7.setGeometry(QtCore.QRect(180, 60, 151, 31))
+        self.label_7.setGeometry(QtCore.QRect(30, 50, 151, 21))
         font = QtGui.QFont()
         font.setPointSize(10)
         self.label_7.setFont(font)
@@ -91,7 +91,7 @@ class Ui_crp_fenetre(object):
         self.label_10.setFont(font)
         self.label_10.setObjectName(_fromUtf8("label_10"))
         self.crp_largeur = QtGui.QSpinBox(crp_fenetre)
-        self.crp_largeur.setGeometry(QtCore.QRect(320, 60, 51, 31))
+        self.crp_largeur.setGeometry(QtCore.QRect(175, 78, 51, 31))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -130,7 +130,7 @@ class Ui_crp_fenetre(object):
         self.crp_chapitre.setMinimum(1)
         self.crp_chapitre.setObjectName(_fromUtf8("crp_chapitre"))
         self.crp_formes = QtGui.QGroupBox(crp_fenetre)
-        self.crp_formes.setGeometry(QtCore.QRect(30, 100, 311, 41))
+        self.crp_formes.setGeometry(QtCore.QRect(150, 126, 311, 41))
         font = QtGui.QFont()
         font.setPointSize(10)
         self.crp_formes.setFont(font)
@@ -138,20 +138,20 @@ class Ui_crp_fenetre(object):
         self.crp_formes.setFlat(True)
         self.crp_formes.setObjectName(_fromUtf8("crp_formes"))
         self.crp_formeHexa = QtGui.QRadioButton(self.crp_formes)
-        self.crp_formeHexa.setGeometry(QtCore.QRect(80, 10, 111, 20))
+        self.crp_formeHexa.setGeometry(QtCore.QRect(80, 10, 111, 31))
         font = QtGui.QFont()
         font.setPointSize(9)
         self.crp_formeHexa.setFont(font)
         self.crp_formeHexa.setChecked(True)
         self.crp_formeHexa.setObjectName(_fromUtf8("crp_formeHexa"))
         self.crp_formeCarree = QtGui.QRadioButton(self.crp_formes)
-        self.crp_formeCarree.setGeometry(QtCore.QRect(220, 10, 81, 21))
+        self.crp_formeCarree.setGeometry(QtCore.QRect(220, 10, 81, 31))
         font = QtGui.QFont()
         font.setPointSize(9)
         self.crp_formeCarree.setFont(font)
         self.crp_formeCarree.setObjectName(_fromUtf8("crp_formeCarree"))
         self.label_2 = QtGui.QLabel(self.crp_formes)
-        self.label_2.setGeometry(QtCore.QRect(0, 10, 61, 21))
+        self.label_2.setGeometry(QtCore.QRect(0, 10, 61, 31))
         self.label_2.setObjectName(_fromUtf8("label_2"))
         self.label_6 = QtGui.QLabel(crp_fenetre)
         self.label_6.setGeometry(QtCore.QRect(360, 10, 51, 31))
@@ -162,27 +162,27 @@ class Ui_crp_fenetre(object):
         self.label_6.setFont(font)
         self.label_6.setObjectName(_fromUtf8("label_6"))
         self.label = QtGui.QLabel(crp_fenetre)
-        self.label.setGeometry(QtCore.QRect(385, 62, 21, 31))
+        self.label.setGeometry(QtCore.QRect(240, 80, 21, 31))
         font = QtGui.QFont()
         font.setPointSize(9)
         self.label.setFont(font)
         self.label.setObjectName(_fromUtf8("label"))
         self.crp_chercherModele = QtGui.QPushButton(crp_fenetre)
         self.crp_chercherModele.setEnabled(False)
-        self.crp_chercherModele.setGeometry(QtCore.QRect(10, 280, 141, 30))
+        self.crp_chercherModele.setGeometry(QtCore.QRect(10, 270, 141, 30))
         font = QtGui.QFont()
         font.setPointSize(10)
         self.crp_chercherModele.setFont(font)
         self.crp_chercherModele.setDefault(True)
         self.crp_chercherModele.setObjectName(_fromUtf8("crp_chercherModele"))
         self.crp_couleur = QtGui.QToolButton(crp_fenetre)
-        self.crp_couleur.setGeometry(QtCore.QRect(430, 104, 31, 31))
+        self.crp_couleur.setGeometry(QtCore.QRect(30, 136, 51, 31))
         icon = QtGui.QIcon()
         icon.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/palette_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.crp_couleur.setIcon(icon)
         self.crp_couleur.setObjectName(_fromUtf8("crp_couleur"))
         self.crp_listeDimensions = QtGui.QComboBox(crp_fenetre)
-        self.crp_listeDimensions.setGeometry(QtCore.QRect(30, 60, 131, 31))
+        self.crp_listeDimensions.setGeometry(QtCore.QRect(30, 78, 131, 31))
         self.crp_listeDimensions.setMaxVisibleItems(9)
         self.crp_listeDimensions.setObjectName(_fromUtf8("crp_listeDimensions"))
         self.crp_listeDimensions.addItem(_fromUtf8(""))
@@ -196,12 +196,12 @@ class Ui_crp_fenetre(object):
         self.crp_listeDimensions.addItem(_fromUtf8(""))
         self.crp_listeDimensions.addItem(_fromUtf8(""))
         self.line = QtGui.QFrame(crp_fenetre)
-        self.line.setGeometry(QtCore.QRect(340, 100, 118, 3))
+        self.line.setGeometry(QtCore.QRect(30, 119, 131, 16))
         self.line.setFrameShape(QtGui.QFrame.HLine)
         self.line.setFrameShadow(QtGui.QFrame.Sunken)
         self.line.setObjectName(_fromUtf8("line"))
         self.crp_presentation = DmTextEdit(crp_fenetre)
-        self.crp_presentation.setGeometry(QtCore.QRect(30, 160, 431, 41))
+        self.crp_presentation.setGeometry(QtCore.QRect(28, 209, 421, 41))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(249, 249, 249))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -215,13 +215,17 @@ class Ui_crp_fenetre(object):
         self.crp_presentation.setPalette(palette)
         self.crp_presentation.setObjectName(_fromUtf8("crp_presentation"))
         self.label_3 = QtGui.QLabel(crp_fenetre)
-        self.label_3.setGeometry(QtCore.QRect(32, 141, 151, 21))
+        self.label_3.setGeometry(QtCore.QRect(30, 190, 151, 21))
         font = QtGui.QFont()
         font.setPointSize(8)
         self.label_3.setFont(font)
         self.label_3.setObjectName(_fromUtf8("label_3"))
-        self.crp_description = DmTextEdit(crp_fenetre)
-        self.crp_description.setGeometry(QtCore.QRect(30, 228, 431, 31))
+        self.crp_plafond = QtGui.QCheckBox(crp_fenetre)
+        self.crp_plafond.setGeometry(QtCore.QRect(340, 80, 81, 31))
+        self.crp_plafond.setObjectName(_fromUtf8("crp_plafond"))
+        self.crp_zP = QtGui.QSpinBox(crp_fenetre)
+        self.crp_zP.setEnabled(False)
+        self.crp_zP.setGeometry(QtCore.QRect(420, 80, 41, 31))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(249, 249, 249))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -232,14 +236,14 @@ class Ui_crp_fenetre(object):
         brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
         brush.setStyle(QtCore.Qt.SolidPattern)
         palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
-        self.crp_description.setPalette(palette)
-        self.crp_description.setObjectName(_fromUtf8("crp_description"))
-        self.label_4 = QtGui.QLabel(crp_fenetre)
-        self.label_4.setGeometry(QtCore.QRect(32, 210, 191, 20))
-        font = QtGui.QFont()
-        font.setPointSize(8)
-        self.label_4.setFont(font)
-        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.crp_zP.setPalette(palette)
+        self.crp_zP.setProperty("value", 6)
+        self.crp_zP.setObjectName(_fromUtf8("crp_zP"))
+        self.line_2 = QtGui.QFrame(crp_fenetre)
+        self.line_2.setGeometry(QtCore.QRect(30, 170, 431, 16))
+        self.line_2.setFrameShape(QtGui.QFrame.HLine)
+        self.line_2.setFrameShadow(QtGui.QFrame.Sunken)
+        self.line_2.setObjectName(_fromUtf8("line_2"))
 
         self.retranslateUi(crp_fenetre)
         self.crp_listeDimensions.setCurrentIndex(1)
@@ -267,8 +271,8 @@ class Ui_crp_fenetre(object):
         self.crp_listeDimensions.setItemText(7, _translate("crp_fenetre", "Carré - Moyen", None))
         self.crp_listeDimensions.setItemText(8, _translate("crp_fenetre", "Carré - Grand", None))
         self.crp_listeDimensions.setItemText(9, _translate("crp_fenetre", "Personnalisé", None))
-        self.label_3.setText(_translate("crp_fenetre", "Présentation (publique)", None))
-        self.label_4.setText(_translate("crp_fenetre", "Description (créateur seulement)", None))
+        self.label_3.setText(_translate("crp_fenetre", "Texte de présentation : ", None))
+        self.crp_plafond.setText(_translate("crp_fenetre", " Plafond : ", None))
 
 from dm import DmTextEdit, DmLineEdit
 import ressource_rc

lib/ui/ecran_editionTerrain.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'editionTerrain.ui'
 #
-# Created: Tue Sep 08 11:44:01 2015
+# Created: Mon Sep 21 17:21:51 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -26,9 +26,9 @@ except AttributeError:
 class Ui_et_fenetre(object):
     def setupUi(self, et_fenetre):
         et_fenetre.setObjectName(_fromUtf8("et_fenetre"))
-        et_fenetre.resize(395, 243)
-        et_fenetre.setMinimumSize(QtCore.QSize(395, 243))
-        et_fenetre.setMaximumSize(QtCore.QSize(395, 243))
+        et_fenetre.resize(395, 225)
+        et_fenetre.setMinimumSize(QtCore.QSize(395, 225))
+        et_fenetre.setMaximumSize(QtCore.QSize(395, 225))
         icon = QtGui.QIcon()
         icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/paysage.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         et_fenetre.setWindowIcon(icon)
@@ -44,7 +44,7 @@ class Ui_et_fenetre(object):
         self.et_apercu.setObjectName(_fromUtf8("et_apercu"))
         self.et_enregistrer = QtGui.QPushButton(et_fenetre)
         self.et_enregistrer.setEnabled(False)
-        self.et_enregistrer.setGeometry(QtCore.QRect(280, 200, 91, 31))
+        self.et_enregistrer.setGeometry(QtCore.QRect(280, 180, 91, 31))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         font.setBold(True)
@@ -54,19 +54,12 @@ class Ui_et_fenetre(object):
         self.et_enregistrer.setDefault(True)
         self.et_enregistrer.setObjectName(_fromUtf8("et_enregistrer"))
         self.et_annuler = QtGui.QPushButton(et_fenetre)
-        self.et_annuler.setGeometry(QtCore.QRect(20, 200, 81, 31))
+        self.et_annuler.setGeometry(QtCore.QRect(20, 180, 81, 31))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         self.et_annuler.setFont(font)
         self.et_annuler.setAutoDefault(False)
         self.et_annuler.setObjectName(_fromUtf8("et_annuler"))
-        self.et_selectionCouleur = QtGui.QPushButton(et_fenetre)
-        self.et_selectionCouleur.setGeometry(QtCore.QRect(20, 80, 31, 31))
-        self.et_selectionCouleur.setText(_fromUtf8(""))
-        icon1 = QtGui.QIcon()
-        icon1.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/palette_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.et_selectionCouleur.setIcon(icon1)
-        self.et_selectionCouleur.setObjectName(_fromUtf8("et_selectionCouleur"))
         self.label_4 = QtGui.QLabel(et_fenetre)
         self.label_4.setGeometry(QtCore.QRect(100, 5, 131, 21))
         font = QtGui.QFont()
@@ -88,34 +81,8 @@ class Ui_et_fenetre(object):
         palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
         self.et_nom.setPalette(palette)
         self.et_nom.setObjectName(_fromUtf8("et_nom"))
-        self.et_selectionFichier = QtGui.QToolButton(et_fenetre)
-        self.et_selectionFichier.setGeometry(QtCore.QRect(60, 80, 31, 31))
-        icon2 = QtGui.QIcon()
-        icon2.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/loupe_32.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.et_selectionFichier.setIcon(icon2)
-        self.et_selectionFichier.setObjectName(_fromUtf8("et_selectionFichier"))
-        self.et_tags = DmLineEdit(et_fenetre)
-        self.et_tags.setGeometry(QtCore.QRect(170, 70, 201, 21))
-        palette = QtGui.QPalette()
-        brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
-        brush.setStyle(QtCore.Qt.SolidPattern)
-        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
-        brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
-        brush.setStyle(QtCore.Qt.SolidPattern)
-        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
-        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
-        brush.setStyle(QtCore.Qt.SolidPattern)
-        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
-        self.et_tags.setPalette(palette)
-        self.et_tags.setObjectName(_fromUtf8("et_tags"))
-        self.label = QtGui.QLabel(et_fenetre)
-        self.label.setGeometry(QtCore.QRect(110, 70, 51, 21))
-        font = QtGui.QFont()
-        font.setFamily(_fromUtf8("Verdana"))
-        self.label.setFont(font)
-        self.label.setObjectName(_fromUtf8("label"))
         self.et_groupeDep = QtGui.QGroupBox(et_fenetre)
-        self.et_groupeDep.setGeometry(QtCore.QRect(20, 120, 351, 61))
+        self.et_groupeDep.setGeometry(QtCore.QRect(20, 100, 351, 61))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         self.et_groupeDep.setFont(font)
@@ -123,45 +90,49 @@ class Ui_et_fenetre(object):
         self.et_depMarche = QtGui.QRadioButton(self.et_groupeDep)
         self.et_depMarche.setGeometry(QtCore.QRect(50, 20, 51, 31))
         self.et_depMarche.setText(_fromUtf8(""))
-        icon3 = QtGui.QIcon()
-        icon3.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/marche_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.et_depMarche.setIcon(icon3)
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/marche_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.et_depMarche.setIcon(icon1)
         self.et_depMarche.setIconSize(QtCore.QSize(19, 19))
         self.et_depMarche.setChecked(True)
         self.et_depMarche.setObjectName(_fromUtf8("et_depMarche"))
         self.et_depNage = QtGui.QRadioButton(self.et_groupeDep)
         self.et_depNage.setGeometry(QtCore.QRect(160, 20, 71, 31))
         self.et_depNage.setText(_fromUtf8(""))
-        icon4 = QtGui.QIcon()
-        icon4.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/24/ressource/nage_24.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.et_depNage.setIcon(icon4)
+        icon2 = QtGui.QIcon()
+        icon2.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/24/ressource/nage_24.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.et_depNage.setIcon(icon2)
         self.et_depNage.setIconSize(QtCore.QSize(19, 19))
         self.et_depNage.setObjectName(_fromUtf8("et_depNage"))
         self.et_depAucun = QtGui.QRadioButton(self.et_groupeDep)
         self.et_depAucun.setGeometry(QtCore.QRect(270, 20, 61, 31))
         self.et_depAucun.setText(_fromUtf8(""))
-        icon5 = QtGui.QIcon()
-        icon5.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/interdit_32.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.et_depAucun.setIcon(icon5)
+        icon3 = QtGui.QIcon()
+        icon3.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/interdit_32.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.et_depAucun.setIcon(icon3)
         self.et_depAucun.setIconSize(QtCore.QSize(19, 19))
         self.et_depAucun.setObjectName(_fromUtf8("et_depAucun"))
+        self.et_paroi = QtGui.QCheckBox(et_fenetre)
+        self.et_paroi.setGeometry(QtCore.QRect(270, 70, 101, 20))
+        self.et_paroi.setObjectName(_fromUtf8("et_paroi"))
 
         self.retranslateUi(et_fenetre)
         QtCore.QMetaObject.connectSlotsByName(et_fenetre)
 
     def retranslateUi(self, et_fenetre):
         et_fenetre.setWindowTitle(_translate("et_fenetre", "Créer / Editer un terrain", None))
-        self.et_apercu.setText(_translate("et_fenetre", "Choisissez \n"
-"une couleur\n"
-"et/ou un \n"
-"fichier\n"
-"texture", None))
+        self.et_apercu.setText(_translate("et_fenetre", "Cliquez ici\n"
+"pour choisir \n"
+"une couleur", None))
         self.et_enregistrer.setText(_translate("et_fenetre", "Enregistrer", None))
         self.et_annuler.setText(_translate("et_fenetre", "Annuler", None))
         self.label_4.setText(_translate("et_fenetre", "Nom du terrain : ", None))
-        self.et_selectionFichier.setText(_translate("et_fenetre", "...", None))
-        self.label.setText(_translate("et_fenetre", "Tags : ", None))
         self.et_groupeDep.setTitle(_translate("et_fenetre", "Déplacement", None))
+        self.et_depMarche.setToolTip(_translate("et_fenetre", "Se franchit à pieds, à cheval, en vélo...", None))
+        self.et_depNage.setToolTip(_translate("et_fenetre", "Se franchit à la nage, en bateau, en surf...", None))
+        self.et_depAucun.setToolTip(_translate("et_fenetre", "Infranchissable, SAUF en volant.", None))
+        self.et_paroi.setToolTip(_translate("et_fenetre", "La case aura l\'altitude du plafond si un plafond est paramétré.", None))
+        self.et_paroi.setText(_translate("et_fenetre", "Paroi, mur, etc... ", None))
 
 from dm import DmLineEdit, DmLabel
 import ressource_rc

lib/ui/ecran_principal.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'principal.ui'
 #
-# Created: Fri Sep 18 17:10:22 2015
+# Created: Wed Sep 23 17:09:45 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -26,7 +26,7 @@ except AttributeError:
 class Ui_principal(object):
     def setupUi(self, principal):
         principal.setObjectName(_fromUtf8("principal"))
-        principal.resize(1153, 691)
+        principal.resize(1153, 687)
         principal.setMinimumSize(QtCore.QSize(882, 623))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("MS Shell Dlg 2"))
@@ -171,7 +171,7 @@ class Ui_principal(object):
         self.panneauInfosPlateau.setMargin(6)
         self.panneauInfosPlateau.setObjectName(_fromUtf8("panneauInfosPlateau"))
         self.inf_listeOrdreJeu = DmTableWidget(self.inf_panneau)
-        self.inf_listeOrdreJeu.setMinimumSize(QtCore.QSize(80, 208))
+        self.inf_listeOrdreJeu.setMinimumSize(QtCore.QSize(80, 274))
         self.inf_listeOrdreJeu.setMaximumSize(QtCore.QSize(110, 16777215))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 120))
@@ -218,135 +218,174 @@ class Ui_principal(object):
         self.cbt_afficherGestion.setObjectName(_fromUtf8("cbt_afficherGestion"))
         self.panneauInfosPlateau.addWidget(self.cbt_afficherGestion)
         self.inf_bas = QtGui.QFrame(self.inf_panneau)
-        self.inf_bas.setMinimumSize(QtCore.QSize(90, 200))
-        self.inf_bas.setMaximumSize(QtCore.QSize(120, 200))
+        self.inf_bas.setMinimumSize(QtCore.QSize(90, 220))
+        self.inf_bas.setMaximumSize(QtCore.QSize(120, 220))
         self.inf_bas.setFrameShape(QtGui.QFrame.StyledPanel)
         self.inf_bas.setFrameShadow(QtGui.QFrame.Raised)
         self.inf_bas.setObjectName(_fromUtf8("inf_bas"))
-        self.inf_boitePion = DmFrameInf_Combattant(self.inf_bas)
-        self.inf_boitePion.setGeometry(QtCore.QRect(0, 0, 110, 65))
-        self.inf_boitePion.setMinimumSize(QtCore.QSize(80, 65))
-        self.inf_boitePion.setMaximumSize(QtCore.QSize(110, 16777215))
-        self.inf_boitePion.setTitle(_fromUtf8(""))
-        self.inf_boitePion.setObjectName(_fromUtf8("inf_boitePion"))
-        self.inf_pionSante = DmLabel(self.inf_boitePion)
-        self.inf_pionSante.setGeometry(QtCore.QRect(50, 20, 51, 21))
-        self.inf_pionSante.setMargin(1)
-        self.inf_pionSante.setIndent(-1)
-        self.inf_pionSante.setObjectName(_fromUtf8("inf_pionSante"))
-        self.inf_pionImage = DmLabel(self.inf_boitePion)
-        self.inf_pionImage.setGeometry(QtCore.QRect(10, 20, 31, 31))
-        self.inf_pionImage.setFrameShape(QtGui.QFrame.StyledPanel)
-        self.inf_pionImage.setText(_fromUtf8(""))
-        self.inf_pionImage.setObjectName(_fromUtf8("inf_pionImage"))
-        self.inf_pionEffet = DmLabel(self.inf_boitePion)
-        self.inf_pionEffet.setGeometry(QtCore.QRect(50, 40, 21, 20))
-        self.inf_pionEffet.setText(_fromUtf8(""))
-        self.inf_pionEffet.setPixmap(QtGui.QPixmap(_fromUtf8("../../../../../Users/olivier.massot/.designer/backup/img/etatEtourdi.png")))
-        self.inf_pionEffet.setScaledContents(False)
-        self.inf_pionEffet.setObjectName(_fromUtf8("inf_pionEffet"))
-        self.inf_pionNom = DmLabel(self.inf_boitePion)
-        self.inf_pionNom.setGeometry(QtCore.QRect(10, 0, 91, 21))
-        self.inf_pionNom.setMargin(1)
-        self.inf_pionNom.setIndent(-1)
-        self.inf_pionNom.setObjectName(_fromUtf8("inf_pionNom"))
-        self.inf_boiteDecor = DmFrameInf_Decor(self.inf_bas)
-        self.inf_boiteDecor.setEnabled(True)
-        self.inf_boiteDecor.setGeometry(QtCore.QRect(0, 70, 110, 61))
-        self.inf_boiteDecor.setMinimumSize(QtCore.QSize(80, 61))
-        self.inf_boiteDecor.setMaximumSize(QtCore.QSize(110, 16777215))
-        self.inf_boiteDecor.setTitle(_fromUtf8(""))
-        self.inf_boiteDecor.setObjectName(_fromUtf8("inf_boiteDecor"))
-        self.inf_decorNom = DmLabel(self.inf_boiteDecor)
-        self.inf_decorNom.setGeometry(QtCore.QRect(10, 0, 91, 21))
-        self.inf_decorNom.setObjectName(_fromUtf8("inf_decorNom"))
-        self.inf_decorImage = DmLabel(self.inf_boiteDecor)
-        self.inf_decorImage.setGeometry(QtCore.QRect(10, 20, 31, 31))
-        self.inf_decorImage.setFrameShape(QtGui.QFrame.StyledPanel)
-        self.inf_decorImage.setText(_fromUtf8(""))
-        self.inf_decorImage.setObjectName(_fromUtf8("inf_decorImage"))
-        self.inf_decorEffet = DmLabel(self.inf_boiteDecor)
-        self.inf_decorEffet.setGeometry(QtCore.QRect(50, 20, 21, 21))
-        self.inf_decorEffet.setText(_fromUtf8(""))
-        self.inf_decorEffet.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/feu_16.png")))
-        self.inf_decorEffet.setObjectName(_fromUtf8("inf_decorEffet"))
-        self.inf_decorDetruit = DmLabel(self.inf_boiteDecor)
-        self.inf_decorDetruit.setGeometry(QtCore.QRect(50, 40, 21, 21))
-        self.inf_decorDetruit.setText(_fromUtf8(""))
-        self.inf_decorDetruit.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/brise_16.png")))
-        self.inf_decorDetruit.setObjectName(_fromUtf8("inf_decorDetruit"))
-        self.inf_decorVerrouille = DmLabel(self.inf_boiteDecor)
-        self.inf_decorVerrouille.setGeometry(QtCore.QRect(70, 20, 21, 21))
-        self.inf_decorVerrouille.setText(_fromUtf8(""))
-        self.inf_decorVerrouille.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/verrou_ferme_16.png")))
-        self.inf_decorVerrouille.setObjectName(_fromUtf8("inf_decorVerrouille"))
-        self.inf_boiteCase = DmFrameInf_Case(self.inf_bas)
-        self.inf_boiteCase.setGeometry(QtCore.QRect(0, 136, 110, 61))
-        self.inf_boiteCase.setMinimumSize(QtCore.QSize(80, 61))
-        self.inf_boiteCase.setMaximumSize(QtCore.QSize(110, 16777215))
-        self.inf_boiteCase.setTitle(_fromUtf8(""))
-        self.inf_boiteCase.setObjectName(_fromUtf8("inf_boiteCase"))
-        self.infoPionEnCours_depRestant_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_depRestant_2.setGeometry(QtCore.QRect(10, 120, 71, 21))
-        self.infoPionEnCours_depRestant_2.setMargin(1)
-        self.infoPionEnCours_depRestant_2.setObjectName(_fromUtf8("infoPionEnCours_depRestant_2"))
-        self.infoPionEnCours_aJoue_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_aJoue_2.setGeometry(QtCore.QRect(10, 140, 61, 21))
-        self.infoPionEnCours_aJoue_2.setMargin(1)
-        self.infoPionEnCours_aJoue_2.setObjectName(_fromUtf8("infoPionEnCours_aJoue_2"))
-        self.infoPionEnCours_endormi_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_endormi_2.setGeometry(QtCore.QRect(0, 180, 21, 21))
-        self.infoPionEnCours_endormi_2.setObjectName(_fromUtf8("infoPionEnCours_endormi_2"))
-        self.infoPionEnCours_paralyse_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_paralyse_2.setGeometry(QtCore.QRect(20, 180, 21, 21))
-        self.infoPionEnCours_paralyse_2.setObjectName(_fromUtf8("infoPionEnCours_paralyse_2"))
-        self.infoPionEnCours_entrave_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_entrave_2.setGeometry(QtCore.QRect(40, 180, 21, 21))
-        self.infoPionEnCours_entrave_2.setObjectName(_fromUtf8("infoPionEnCours_entrave_2"))
-        self.infoPionEnCours_mort_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_mort_2.setGeometry(QtCore.QRect(60, 180, 21, 21))
-        self.infoPionEnCours_mort_2.setObjectName(_fromUtf8("infoPionEnCours_mort_2"))
-        self.infoPionEnCours_evanoui_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_evanoui_2.setGeometry(QtCore.QRect(0, 160, 21, 21))
-        self.infoPionEnCours_evanoui_2.setObjectName(_fromUtf8("infoPionEnCours_evanoui_2"))
-        self.infoPionEnCours_brule_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_brule_2.setGeometry(QtCore.QRect(20, 160, 21, 21))
-        self.infoPionEnCours_brule_2.setObjectName(_fromUtf8("infoPionEnCours_brule_2"))
-        self.infoPionEnCours_mouille_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_mouille_2.setGeometry(QtCore.QRect(40, 160, 21, 21))
-        self.infoPionEnCours_mouille_2.setObjectName(_fromUtf8("infoPionEnCours_mouille_2"))
-        self.infoPionEnCours_vol_2 = QtGui.QLabel(self.inf_boiteCase)
-        self.infoPionEnCours_vol_2.setGeometry(QtCore.QRect(60, 160, 21, 21))
-        self.infoPionEnCours_vol_2.setObjectName(_fromUtf8("infoPionEnCours_vol_2"))
-        self.inf_caseTerrain = DmLabel(self.inf_boiteCase)
-        self.inf_caseTerrain.setGeometry(QtCore.QRect(10, 0, 71, 21))
-        self.inf_caseTerrain.setMargin(1)
-        self.inf_caseTerrain.setIndent(-1)
-        self.inf_caseTerrain.setObjectName(_fromUtf8("inf_caseTerrain"))
-        self.inf_caseCoord = DmLabel(self.inf_boiteCase)
-        self.inf_caseCoord.setGeometry(QtCore.QRect(10, 20, 91, 21))
-        self.inf_caseCoord.setMargin(1)
-        self.inf_caseCoord.setIndent(-1)
-        self.inf_caseCoord.setObjectName(_fromUtf8("inf_caseCoord"))
-        self.inf_caseEffet = DmLabel(self.inf_boiteCase)
-        self.inf_caseEffet.setGeometry(QtCore.QRect(60, 0, 21, 21))
-        self.inf_caseEffet.setText(_fromUtf8(""))
-        self.inf_caseEffet.setPixmap(QtGui.QPixmap(_fromUtf8("../../../../../Users/olivier.massot/.designer/backup/img/etatFeu.png")))
-        self.inf_caseEffet.setScaledContents(True)
-        self.inf_caseEffet.setMargin(1)
-        self.inf_caseEffet.setIndent(-1)
-        self.inf_caseEffet.setObjectName(_fromUtf8("inf_caseEffet"))
-        self.inf_caseAltitude = DmLabel(self.inf_boiteCase)
-        self.inf_caseAltitude.setGeometry(QtCore.QRect(10, 40, 91, 21))
-        self.inf_caseAltitude.setMargin(1)
-        self.inf_caseAltitude.setIndent(-1)
-        self.inf_caseAltitude.setObjectName(_fromUtf8("inf_caseAltitude"))
-        self.inf_caseEffet_2 = DmLabel(self.inf_boiteCase)
-        self.inf_caseEffet_2.setGeometry(QtCore.QRect(90, 0, 21, 21))
-        self.inf_caseEffet_2.setText(_fromUtf8(""))
-        self.inf_caseEffet_2.setMargin(1)
-        self.inf_caseEffet_2.setIndent(-1)
-        self.inf_caseEffet_2.setObjectName(_fromUtf8("inf_caseEffet_2"))
+        self.verticalLayout_5 = QtGui.QVBoxLayout(self.inf_bas)
+        self.verticalLayout_5.setSpacing(0)
+        self.verticalLayout_5.setMargin(0)
+        self.verticalLayout_5.setObjectName(_fromUtf8("verticalLayout_5"))
+        spacerItem2 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
+        self.verticalLayout_5.addItem(spacerItem2)
+        self.icb_panneau = QtGui.QGroupBox(self.inf_bas)
+        self.icb_panneau.setMinimumSize(QtCore.QSize(108, 147))
+        self.icb_panneau.setMaximumSize(QtCore.QSize(108, 147))
+        self.icb_panneau.setTitle(_fromUtf8(""))
+        self.icb_panneau.setObjectName(_fromUtf8("icb_panneau"))
+        self.icb_etat = DmLabel(self.icb_panneau)
+        self.icb_etat.setGeometry(QtCore.QRect(10, 75, 91, 25))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.icb_etat.setFont(font)
+        self.icb_etat.setWordWrap(True)
+        self.icb_etat.setMargin(1)
+        self.icb_etat.setIndent(-1)
+        self.icb_etat.setObjectName(_fromUtf8("icb_etat"))
+        self.icb_image = DmLabel(self.icb_panneau)
+        self.icb_image.setGeometry(QtCore.QRect(10, 10, 31, 31))
+        self.icb_image.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.icb_image.setText(_fromUtf8(""))
+        self.icb_image.setObjectName(_fromUtf8("icb_image"))
+        self.icb_nom = DmLabel(self.icb_panneau)
+        self.icb_nom.setGeometry(QtCore.QRect(10, 45, 91, 26))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.icb_nom.setFont(font)
+        self.icb_nom.setWordWrap(True)
+        self.icb_nom.setMargin(1)
+        self.icb_nom.setIndent(-1)
+        self.icb_nom.setObjectName(_fromUtf8("icb_nom"))
+        self.icb_hauteur = DmLabel(self.icb_panneau)
+        self.icb_hauteur.setGeometry(QtCore.QRect(10, 100, 91, 16))
+        self.icb_hauteur.setMargin(1)
+        self.icb_hauteur.setIndent(-1)
+        self.icb_hauteur.setObjectName(_fromUtf8("icb_hauteur"))
+        self.icb_etourdi = DmLabel(self.icb_panneau)
+        self.icb_etourdi.setGeometry(QtCore.QRect(65, 5, 21, 20))
+        self.icb_etourdi.setText(_fromUtf8(""))
+        self.icb_etourdi.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/etourdi_16.png")))
+        self.icb_etourdi.setScaledContents(False)
+        self.icb_etourdi.setObjectName(_fromUtf8("icb_etourdi"))
+        self.icb_brule = DmLabel(self.icb_panneau)
+        self.icb_brule.setGeometry(QtCore.QRect(86, 5, 21, 20))
+        self.icb_brule.setText(_fromUtf8(""))
+        self.icb_brule.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/feu_16.png")))
+        self.icb_brule.setScaledContents(False)
+        self.icb_brule.setObjectName(_fromUtf8("icb_brule"))
+        self.icb_paralyse = DmLabel(self.icb_panneau)
+        self.icb_paralyse.setGeometry(QtCore.QRect(44, 25, 16, 16))
+        self.icb_paralyse.setText(_fromUtf8(""))
+        self.icb_paralyse.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/eclair_16.png")))
+        self.icb_paralyse.setScaledContents(True)
+        self.icb_paralyse.setObjectName(_fromUtf8("icb_paralyse"))
+        self.icb_empoisonne = DmLabel(self.icb_panneau)
+        self.icb_empoisonne.setGeometry(QtCore.QRect(65, 25, 21, 20))
+        self.icb_empoisonne.setText(_fromUtf8(""))
+        self.icb_empoisonne.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/poison_16.png")))
+        self.icb_empoisonne.setScaledContents(False)
+        self.icb_empoisonne.setObjectName(_fromUtf8("icb_empoisonne"))
+        self.icb_gele = DmLabel(self.icb_panneau)
+        self.icb_gele.setGeometry(QtCore.QRect(86, 25, 21, 20))
+        self.icb_gele.setText(_fromUtf8(""))
+        self.icb_gele.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/glace_16.png")))
+        self.icb_gele.setScaledContents(False)
+        self.icb_gele.setObjectName(_fromUtf8("icb_gele"))
+        self.icb_mort = DmLabel(self.icb_panneau)
+        self.icb_mort.setGeometry(QtCore.QRect(42, 4, 21, 21))
+        self.icb_mort.setText(_fromUtf8(""))
+        self.icb_mort.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/mort_16.png")))
+        self.icb_mort.setScaledContents(False)
+        self.icb_mort.setAlignment(QtCore.Qt.AlignCenter)
+        self.icb_mort.setObjectName(_fromUtf8("icb_mort"))
+        self.icb_vol = DmLabel(self.icb_panneau)
+        self.icb_vol.setGeometry(QtCore.QRect(10, 118, 91, 16))
+        self.icb_vol.setText(_fromUtf8(""))
+        self.icb_vol.setMargin(1)
+        self.icb_vol.setIndent(-1)
+        self.icb_vol.setObjectName(_fromUtf8("icb_vol"))
+        self.verticalLayout_5.addWidget(self.icb_panneau)
+        self.idc_panneau = QtGui.QGroupBox(self.inf_bas)
+        self.idc_panneau.setEnabled(True)
+        self.idc_panneau.setMinimumSize(QtCore.QSize(108, 146))
+        self.idc_panneau.setMaximumSize(QtCore.QSize(108, 146))
+        self.idc_panneau.setTitle(_fromUtf8(""))
+        self.idc_panneau.setObjectName(_fromUtf8("idc_panneau"))
+        self.idc_nom = DmLabel(self.idc_panneau)
+        self.idc_nom.setGeometry(QtCore.QRect(10, 45, 91, 26))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.idc_nom.setFont(font)
+        self.idc_nom.setWordWrap(True)
+        self.idc_nom.setObjectName(_fromUtf8("idc_nom"))
+        self.idc_image = DmLabel(self.idc_panneau)
+        self.idc_image.setGeometry(QtCore.QRect(10, 10, 31, 31))
+        self.idc_image.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.idc_image.setText(_fromUtf8(""))
+        self.idc_image.setObjectName(_fromUtf8("idc_image"))
+        self.idc_brule = DmLabel(self.idc_panneau)
+        self.idc_brule.setGeometry(QtCore.QRect(46, 10, 21, 21))
+        self.idc_brule.setText(_fromUtf8(""))
+        self.idc_brule.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/feu_16.png")))
+        self.idc_brule.setObjectName(_fromUtf8("idc_brule"))
+        self.idc_detruit = DmLabel(self.idc_panneau)
+        self.idc_detruit.setGeometry(QtCore.QRect(86, 10, 21, 21))
+        self.idc_detruit.setText(_fromUtf8(""))
+        self.idc_detruit.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/brise_16.png")))
+        self.idc_detruit.setObjectName(_fromUtf8("idc_detruit"))
+        self.idc_verrouille = DmLabel(self.idc_panneau)
+        self.idc_verrouille.setGeometry(QtCore.QRect(66, 10, 21, 21))
+        self.idc_verrouille.setText(_fromUtf8(""))
+        self.idc_verrouille.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/verrou_ferme_16.png")))
+        self.idc_verrouille.setObjectName(_fromUtf8("idc_verrouille"))
+        self.idc_etat = DmLabel(self.idc_panneau)
+        self.idc_etat.setGeometry(QtCore.QRect(10, 75, 91, 25))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.idc_etat.setFont(font)
+        self.idc_etat.setWordWrap(True)
+        self.idc_etat.setObjectName(_fromUtf8("idc_etat"))
+        self.idc_hauteur = DmLabel(self.idc_panneau)
+        self.idc_hauteur.setGeometry(QtCore.QRect(10, 100, 91, 16))
+        self.idc_hauteur.setObjectName(_fromUtf8("idc_hauteur"))
+        self.verticalLayout_5.addWidget(self.idc_panneau)
+        self.ic_panneau = QtGui.QGroupBox(self.inf_bas)
+        self.ic_panneau.setMinimumSize(QtCore.QSize(110, 65))
+        self.ic_panneau.setMaximumSize(QtCore.QSize(110, 65))
+        self.ic_panneau.setTitle(_fromUtf8(""))
+        self.ic_panneau.setObjectName(_fromUtf8("ic_panneau"))
+        self.ic_terrain = DmLabel(self.ic_panneau)
+        self.ic_terrain.setGeometry(QtCore.QRect(10, 20, 91, 21))
+        self.ic_terrain.setMargin(1)
+        self.ic_terrain.setIndent(-1)
+        self.ic_terrain.setObjectName(_fromUtf8("ic_terrain"))
+        self.ic_coord = DmLabel(self.ic_panneau)
+        self.ic_coord.setGeometry(QtCore.QRect(10, 0, 71, 21))
+        self.ic_coord.setMargin(1)
+        self.ic_coord.setIndent(-1)
+        self.ic_coord.setObjectName(_fromUtf8("ic_coord"))
+        self.ic_altitude = DmLabel(self.ic_panneau)
+        self.ic_altitude.setGeometry(QtCore.QRect(30, 38, 71, 20))
+        self.ic_altitude.setMargin(1)
+        self.ic_altitude.setIndent(-1)
+        self.ic_altitude.setObjectName(_fromUtf8("ic_altitude"))
+        self.ic_effet = DmLabel(self.ic_panneau)
+        self.ic_effet.setGeometry(QtCore.QRect(88, 2, 21, 21))
+        self.ic_effet.setText(_fromUtf8(""))
+        self.ic_effet.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/glace_16.png")))
+        self.ic_effet.setMargin(1)
+        self.ic_effet.setIndent(-1)
+        self.ic_effet.setObjectName(_fromUtf8("ic_effet"))
+        self.ic_logoAlt = QtGui.QLabel(self.ic_panneau)
+        self.ic_logoAlt.setGeometry(QtCore.QRect(5, 39, 21, 20))
+        self.ic_logoAlt.setText(_fromUtf8(""))
+        self.ic_logoAlt.setPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/montagne_32.png")))
+        self.ic_logoAlt.setScaledContents(True)
+        self.ic_logoAlt.setObjectName(_fromUtf8("ic_logoAlt"))
+        self.verticalLayout_5.addWidget(self.ic_panneau)
         self.panneauInfosPlateau.addWidget(self.inf_bas)
         self.horizontalLayout_6.addWidget(self.inf_panneau)
         self.cbt_panneauGauche.addWidget(self.page_5)
@@ -383,6 +422,17 @@ class Ui_principal(object):
         self.cbt_panneauBas = QtGui.QStackedWidget(self.combat)
         self.cbt_panneauBas.setMinimumSize(QtCore.QSize(0, 75))
         self.cbt_panneauBas.setMaximumSize(QtCore.QSize(16777215, 75))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(249, 249, 249))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(249, 249, 249))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        self.cbt_panneauBas.setPalette(palette)
         self.cbt_panneauBas.setFrameShape(QtGui.QFrame.StyledPanel)
         self.cbt_panneauBas.setObjectName(_fromUtf8("cbt_panneauBas"))
         self.page_act = QtGui.QWidget()
@@ -763,8 +813,8 @@ class Ui_principal(object):
         self.cp_importTerrain.setIcon(icon18)
         self.cp_importTerrain.setObjectName(_fromUtf8("cp_importTerrain"))
         self.horizontalLayout_4.addWidget(self.cp_importTerrain)
-        spacerItem2 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
-        self.horizontalLayout_4.addItem(spacerItem2)
+        spacerItem3 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout_4.addItem(spacerItem3)
         self.cp_nouveauTerrain = QtGui.QToolButton(self.cp_afficherTerrains)
         self.cp_nouveauTerrain.setText(_fromUtf8(""))
         icon19 = QtGui.QIcon()
@@ -818,8 +868,8 @@ class Ui_principal(object):
         self.cp_importDecor.setIcon(icon18)
         self.cp_importDecor.setObjectName(_fromUtf8("cp_importDecor"))
         self.horizontalLayout_7.addWidget(self.cp_importDecor)
-        spacerItem3 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
-        self.horizontalLayout_7.addItem(spacerItem3)
+        spacerItem4 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout_7.addItem(spacerItem4)
         self.cp_nouveauDecor = QtGui.QToolButton(self.cp_afficherDecors)
         self.cp_nouveauDecor.setText(_fromUtf8(""))
         self.cp_nouveauDecor.setIcon(icon19)
@@ -870,8 +920,8 @@ class Ui_principal(object):
         self.cp_importCombattant.setIcon(icon18)
         self.cp_importCombattant.setObjectName(_fromUtf8("cp_importCombattant"))
         self.horizontalLayout_8.addWidget(self.cp_importCombattant)
-        spacerItem4 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
-        self.horizontalLayout_8.addItem(spacerItem4)
+        spacerItem5 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout_8.addItem(spacerItem5)
         self.cp_nouveauCombattant = QtGui.QToolButton(self.cp_afficherCreatures)
         self.cp_nouveauCombattant.setText(_fromUtf8(""))
         self.cp_nouveauCombattant.setIcon(icon19)
@@ -1266,7 +1316,7 @@ class Ui_principal(object):
         self.grp_deroulement.setWidgetResizable(True)
         self.grp_deroulement.setObjectName(_fromUtf8("grp_deroulement"))
         self.grp_deroulement_contenu = QtGui.QWidget()
-        self.grp_deroulement_contenu.setGeometry(QtCore.QRect(0, 0, 756, 588))
+        self.grp_deroulement_contenu.setGeometry(QtCore.QRect(0, 0, 756, 584))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -1365,8 +1415,8 @@ class Ui_principal(object):
         self.verticalLayout_12 = QtGui.QVBoxLayout(self.grp_panneauCommande)
         self.verticalLayout_12.setMargin(2)
         self.verticalLayout_12.setObjectName(_fromUtf8("verticalLayout_12"))
-        spacerItem5 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
-        self.verticalLayout_12.addItem(spacerItem5)
+        spacerItem6 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
+        self.verticalLayout_12.addItem(spacerItem6)
         self.grp_nouveauPj = QtGui.QPushButton(self.grp_panneauCommande)
         self.grp_nouveauPj.setMinimumSize(QtCore.QSize(50, 50))
         self.grp_nouveauPj.setMaximumSize(QtCore.QSize(50, 50))
@@ -1618,7 +1668,7 @@ class Ui_principal(object):
         self.cbt_panneauHaut.setCurrentIndex(1)
         self.cbt_panneauGauche.setCurrentIndex(1)
         self.cbt_panneauBas.setCurrentIndex(0)
-        self.cbt_panneauDroite.setCurrentIndex(2)
+        self.cbt_panneauDroite.setCurrentIndex(1)
         self.cp_ongletsListes.setCurrentIndex(1)
         self.pi_ongletsListes.setCurrentIndex(0)
         self.tabStatutAppli.setCurrentIndex(2)
@@ -1645,31 +1695,21 @@ class Ui_principal(object):
         item = self.inf_listeOrdreJeu.horizontalHeaderItem(3)
         item.setText(_translate("principal", "ordre", None))
         self.cbt_afficherGestion.setToolTip(_translate("principal", "Afficher le tableau de gestion du combat (MJ)", None))
-        self.inf_pionSante.setText(_translate("principal", "sante", None))
-        self.inf_pionEffet.setToolTip(_translate("principal", "Evanoui", None))
-        self.inf_pionNom.setText(_translate("principal", "nom", None))
-        self.inf_decorNom.setText(_translate("principal", "nom", None))
-        self.infoPionEnCours_depRestant_2.setText(_translate("principal", "Dep.: 0 ", None))
-        self.infoPionEnCours_aJoue_2.setText(_translate("principal", "A joué: Non", None))
-        self.infoPionEnCours_endormi_2.setToolTip(_translate("principal", "Endormi", None))
-        self.infoPionEnCours_endormi_2.setText(_translate("principal", "end", None))
-        self.infoPionEnCours_paralyse_2.setToolTip(_translate("principal", "Paralysé", None))
-        self.infoPionEnCours_paralyse_2.setText(_translate("principal", "par", None))
-        self.infoPionEnCours_entrave_2.setToolTip(_translate("principal", "Entravé", None))
-        self.infoPionEnCours_entrave_2.setText(_translate("principal", "ent", None))
-        self.infoPionEnCours_mort_2.setToolTip(_translate("principal", "Mort", None))
-        self.infoPionEnCours_mort_2.setText(_translate("principal", "mrt", None))
-        self.infoPionEnCours_evanoui_2.setToolTip(_translate("principal", "Evanoui", None))
-        self.infoPionEnCours_evanoui_2.setText(_translate("principal", "evn", None))
-        self.infoPionEnCours_brule_2.setToolTip(_translate("principal", "Brûle", None))
-        self.infoPionEnCours_brule_2.setText(_translate("principal", "bru", None))
-        self.infoPionEnCours_mouille_2.setToolTip(_translate("principal", "Mouillé", None))
-        self.infoPionEnCours_mouille_2.setText(_translate("principal", "mou", None))
-        self.infoPionEnCours_vol_2.setToolTip(_translate("principal", "En Vol", None))
-        self.infoPionEnCours_vol_2.setText(_translate("principal", "vol", None))
-        self.inf_caseTerrain.setText(_translate("principal", "terrain", None))
-        self.inf_caseCoord.setText(_translate("principal", "coord", None))
-        self.inf_caseAltitude.setText(_translate("principal", "alt", None))
+        self.icb_etat.setText(_translate("principal", "etat", None))
+        self.icb_nom.setText(_translate("principal", "nom", None))
+        self.icb_hauteur.setText(_translate("principal", "hauteur", None))
+        self.icb_etourdi.setToolTip(_translate("principal", "Evanoui", None))
+        self.icb_brule.setToolTip(_translate("principal", "Evanoui", None))
+        self.icb_paralyse.setToolTip(_translate("principal", "Evanoui", None))
+        self.icb_empoisonne.setToolTip(_translate("principal", "Evanoui", None))
+        self.icb_gele.setToolTip(_translate("principal", "Evanoui", None))
+        self.icb_mort.setToolTip(_translate("principal", "Evanoui", None))
+        self.idc_nom.setText(_translate("principal", "nom", None))
+        self.idc_etat.setText(_translate("principal", "etat", None))
+        self.idc_hauteur.setText(_translate("principal", "hauteur", None))
+        self.ic_terrain.setText(_translate("principal", "terrain", None))
+        self.ic_coord.setText(_translate("principal", "coord", None))
+        self.ic_altitude.setText(_translate("principal", "alt", None))
         self.act_img.setToolTip(_translate("principal", "Image du pion sélectionné", None))
         self.act_img.setText(_translate("principal", "logo", None))
         self.act_deplacement.setToolTip(_translate("principal", "Déplacer le pion", None))
@@ -1798,7 +1838,7 @@ class Ui_principal(object):
         self.actionParam_tres.setText(_translate("principal", "Paramètres", None))
         self.actionLexique.setText(_translate("principal", "Lexique", None))
 
-from dm import DmFrameInf_Decor, DmFrameInf_Case, DmLabel, DmGraphicsView, DmFrameInf_Combattant, DmTableWidget, DmTextEdit, DmTableMat
+from dm import DmTableWidget, DmGraphicsView, DmTableMat, DmLabel, DmTextEdit
 import ressource_rc
 
 if __name__ == "__main__":

lib/ui/editionMateriel.ui

@@ -9,7 +9,7 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>700</width>
+    <width>766</width>
     <height>566</height>
    </rect>
   </property>
@@ -708,7 +708,7 @@ image</string>
             </font>
            </property>
            <property name="currentIndex">
-            <number>6</number>
+            <number>3</number>
            </property>
            <widget class="QWidget" name="page_nom">
             <widget class="QFrame" name="frame_2">
@@ -1021,7 +1021,7 @@ image</string>
               <rect>
                <x>10</x>
                <y>70</y>
-               <width>481</width>
+               <width>558</width>
                <height>31</height>
               </rect>
              </property>
@@ -1905,7 +1905,7 @@ image</string>
               <number>0</number>
              </property>
              <property name="maximum">
-              <number>999</number>
+              <number>99</number>
              </property>
             </widget>
            </widget>
@@ -2410,7 +2410,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/etoile_32.png</normaloff>:/interface/32/ressource/etoile_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
              <widget class="QWidget" name="filtre_0">
@@ -2419,7 +2419,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/pieces_32.png</normaloff>:/interface/32/ressource/pieces_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
              <widget class="QWidget" name="filtre_1">
@@ -2428,7 +2428,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/armes_32.png</normaloff>:/interface/32/ressource/armes_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
              <widget class="QWidget" name="filtre_2">
@@ -2437,7 +2437,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/chimie_32.png</normaloff>:/interface/32/ressource/chimie_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
              <widget class="QWidget" name="filtre_3">
@@ -2446,7 +2446,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/diamant_32.png</normaloff>:/interface/32/ressource/diamant_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
              <widget class="QWidget" name="filtre_4">
@@ -2455,7 +2455,7 @@ image</string>
                 <normaloff>:/interface/32/ressource/boiteOutils_32.png</normaloff>:/interface/32/ressource/boiteOutils_32.png</iconset>
               </attribute>
               <attribute name="title">
-               <string>   </string>
+               <string/>
               </attribute>
              </widget>
             </widget>
@@ -3664,6 +3664,16 @@ Croyances :</string>
   </layout>
  </widget>
  <customwidgets>
+  <customwidget>
+   <class>DmLabel</class>
+   <extends>QLabel</extends>
+   <header location="global">dm.h</header>
+  </customwidget>
+  <customwidget>
+   <class>DmTextEdit</class>
+   <extends>QTextEdit</extends>
+   <header location="global">dm.h</header>
+  </customwidget>
   <customwidget>
    <class>DmLineEdit</class>
    <extends>QLineEdit</extends>
@@ -3674,11 +3684,6 @@ Croyances :</string>
    <extends>QTableWidget</extends>
    <header location="global">dm.h</header>
   </customwidget>
-  <customwidget>
-   <class>DmLabel</class>
-   <extends>QLabel</extends>
-   <header location="global">dm.h</header>
-  </customwidget>
   <customwidget>
    <class>DmTableInventaire</class>
    <extends>QTableWidget</extends>
@@ -3690,11 +3695,6 @@ Croyances :</string>
    <header>dm.h</header>
    <container>1</container>
   </customwidget>
-  <customwidget>
-   <class>DmTextEdit</class>
-   <extends>QTextEdit</extends>
-   <header location="global">dm.h</header>
-  </customwidget>
  </customwidgets>
  <resources>
   <include location="ressource.qrc"/>

lib/ui/editionTerrain.ui

@@ -7,19 +7,19 @@
     <x>0</x>
     <y>0</y>
     <width>395</width>
-    <height>243</height>
+    <height>225</height>
    </rect>
   </property>
   <property name="minimumSize">
    <size>
     <width>395</width>
-    <height>243</height>
+    <height>225</height>
    </size>
   </property>
   <property name="maximumSize">
    <size>
     <width>395</width>
-    <height>243</height>
+    <height>225</height>
    </size>
   </property>
   <property name="windowTitle">
@@ -51,11 +51,9 @@
     <enum>QFrame::Sunken</enum>
    </property>
    <property name="text">
-    <string>Choisissez 
-une couleur
-et/ou un 
-fichier
-texture</string>
+    <string>Cliquez ici
+pour choisir 
+une couleur</string>
    </property>
    <property name="alignment">
     <set>Qt::AlignCenter</set>
@@ -68,7 +66,7 @@ texture</string>
    <property name="geometry">
     <rect>
      <x>280</x>
-     <y>200</y>
+     <y>180</y>
      <width>91</width>
      <height>31</height>
     </rect>
@@ -94,7 +92,7 @@ texture</string>
    <property name="geometry">
     <rect>
      <x>20</x>
-     <y>200</y>
+     <y>180</y>
      <width>81</width>
      <height>31</height>
     </rect>
@@ -111,23 +109,6 @@ texture</string>
     <bool>false</bool>
    </property>
   </widget>
-  <widget class="QPushButton" name="et_selectionCouleur">
-   <property name="geometry">
-    <rect>
-     <x>20</x>
-     <y>80</y>
-     <width>31</width>
-     <height>31</height>
-    </rect>
-   </property>
-   <property name="text">
-    <string/>
-   </property>
-   <property name="icon">
-    <iconset resource="ressource.qrc">
-     <normaloff>:/interface/16/ressource/palette_16.png</normaloff>:/interface/16/ressource/palette_16.png</iconset>
-   </property>
-  </widget>
   <widget class="QLabel" name="label_4">
    <property name="geometry">
     <rect>
@@ -194,93 +175,11 @@ texture</string>
     </palette>
    </property>
   </widget>
-  <widget class="QToolButton" name="et_selectionFichier">
-   <property name="geometry">
-    <rect>
-     <x>60</x>
-     <y>80</y>
-     <width>31</width>
-     <height>31</height>
-    </rect>
-   </property>
-   <property name="text">
-    <string>...</string>
-   </property>
-   <property name="icon">
-    <iconset resource="ressource.qrc">
-     <normaloff>:/interface/32/ressource/loupe_32.png</normaloff>:/interface/32/ressource/loupe_32.png</iconset>
-   </property>
-  </widget>
-  <widget class="DmLineEdit" name="et_tags">
-   <property name="geometry">
-    <rect>
-     <x>170</x>
-     <y>70</y>
-     <width>201</width>
-     <height>21</height>
-    </rect>
-   </property>
-   <property name="palette">
-    <palette>
-     <active>
-      <colorrole role="Base">
-       <brush brushstyle="SolidPattern">
-        <color alpha="255">
-         <red>248</red>
-         <green>248</green>
-         <blue>248</blue>
-        </color>
-       </brush>
-      </colorrole>
-     </active>
-     <inactive>
-      <colorrole role="Base">
-       <brush brushstyle="SolidPattern">
-        <color alpha="255">
-         <red>248</red>
-         <green>248</green>
-         <blue>248</blue>
-        </color>
-       </brush>
-      </colorrole>
-     </inactive>
-     <disabled>
-      <colorrole role="Base">
-       <brush brushstyle="SolidPattern">
-        <color alpha="255">
-         <red>240</red>
-         <green>240</green>
-         <blue>240</blue>
-        </color>
-       </brush>
-      </colorrole>
-     </disabled>
-    </palette>
-   </property>
-  </widget>
-  <widget class="QLabel" name="label">
-   <property name="geometry">
-    <rect>
-     <x>110</x>
-     <y>70</y>
-     <width>51</width>
-     <height>21</height>
-    </rect>
-   </property>
-   <property name="font">
-    <font>
-     <family>Verdana</family>
-    </font>
-   </property>
-   <property name="text">
-    <string>Tags : </string>
-   </property>
-  </widget>
   <widget class="QGroupBox" name="et_groupeDep">
    <property name="geometry">
     <rect>
      <x>20</x>
-     <y>120</y>
+     <y>100</y>
      <width>351</width>
      <height>61</height>
     </rect>
@@ -302,6 +201,9 @@ texture</string>
       <height>31</height>
      </rect>
     </property>
+    <property name="toolTip">
+     <string>Se franchit à pieds, à cheval, en vélo...</string>
+    </property>
     <property name="text">
      <string/>
     </property>
@@ -328,6 +230,9 @@ texture</string>
       <height>31</height>
      </rect>
     </property>
+    <property name="toolTip">
+     <string>Se franchit à la nage, en bateau, en surf...</string>
+    </property>
     <property name="text">
      <string/>
     </property>
@@ -351,6 +256,9 @@ texture</string>
       <height>31</height>
      </rect>
     </property>
+    <property name="toolTip">
+     <string>Infranchissable, SAUF en volant.</string>
+    </property>
     <property name="text">
      <string/>
     </property>
@@ -366,6 +274,22 @@ texture</string>
     </property>
    </widget>
   </widget>
+  <widget class="QCheckBox" name="et_paroi">
+   <property name="geometry">
+    <rect>
+     <x>270</x>
+     <y>70</y>
+     <width>101</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="toolTip">
+    <string>La case aura l'altitude du plafond si un plafond est paramétré.</string>
+   </property>
+   <property name="text">
+    <string>Paroi, mur, etc... </string>
+   </property>
+  </widget>
  </widget>
  <customwidgets>
   <customwidget>

parties/defaut/cbt/infos_sauvegarde

@@ -1,4 +1,2 @@
-€}q
(U
-plpjsolkDU}q(UnomqUtestqUdateCreationqGAÕÝ�²UdateSvgqGAÕï°ƒUchapitreqU
1UenCoursq‰Upublicq	‰uU
-plpjloIyzj}q
-(UnomUtestUdateCreationGAÕ|¹›ÒòUdateSvgGAÕ|¹œ9XUchapitreU
1UenCours‰Upublic‰uu.
+€}q
U
+plpjxm4I9S}q(UnomqUtestqUdateCreationqGAÕ€¨AûC–UdateSvgqGAÕ€°µ�UchapitreqU
1UenCoursq‰Upublicq	‰us.

tmp/sepjwj9uy3.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwj9uy3ub.

tmp/sepjwjKfiP.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwjKfiPub.

tmp/sepjwk5WqV.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwk5WqVub.

tmp/sepjwk7y2V.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwk7y2Vub.

tmp/sepjwkJ8JY.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwkJ8JYub.

tmp/sepjwkOPKV.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwkOPKVub.

tmp/sepjwkUvUP.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwkUvUPub.

tmp/sepjwmHNFv.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwmHNFvub.

tmp/sepjwmvYuL.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwmvYuLub.

tmp/sepjwnH7Gy.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwnH7Gyub.

tmp/sepjwnPIDh.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwnPIDhub.

tmp/sepjwoTHYT.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwoTHYTub.

tmp/sepjwotUdu.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjwotUduub.

tmp/sepjxjJzEd.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxjJzEdub.

tmp/sepjxjOIjx.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxjOIjxub.

tmp/sepjxjRGD7.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxjRGD7ub.

tmp/sepjxjiTxv.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxjiTxvub.

tmp/sepjxknHTI.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxknHTIub.

tmp/sepjxnorVK.tmp

@@ -0,0 +1,4 @@
+€clib.commun
+Session
+q
)�q}q(U_idUqUdefautqU_idPqhU_idJqhU_idSqU
+sepjxnorVKub.