Mise en place du suivi versions

DMonde.py

@@ -0,0 +1,288 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+from sys import exit, argv, getsizeof, settrace
+from time import time, sleep, strftime, localtime
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from lib.ui.ecran_principal import Ui_principal
+
+from lib.EcranCreationPlateau import EcranCreationPlateau
+from lib.EcranFondPlateau import EcranFondPlateau
+from lib.Plateau import Plateau
+
+from lib.outilsSvg import *
+
+from lib.Case import Case
+from lib.Pion import Pion
+from lib.PionDecor import PionDecor
+
+from lib.Cache import Cache
+from lib.EntreeSortie import EntreeSortie
+
+
+#fonction ci dessous: deboguage, suit les appels faits aux fonctions
+#settrace(trace_calls)
+def trace_calls(frame, event, arg):
+    if event != 'call':
+        return
+    co = frame.f_code
+    func_name = co.co_name
+    if func_name == 'write':
+        # Ignore write() calls from print statements
+        return
+    func_line_no = frame.f_lineno
+    func_filename = co.co_filename
+    caller = frame.f_back
+    caller_line_no = caller.f_lineno
+    caller_filename = caller.f_code.co_filename
+    #print 'Call to %s on line %s of %s from line %s of %s' % \
+    #    (func_name, func_line_no, func_filename,
+    #     caller_line_no, caller_filename)
+    print("{} ({})".format(func_name, func_filename))
+    return
+
+
+class DMonde(QMainWindow):
+    """interface comprenant: chat ecrit, fenetre d'infos, lancer de des, echange de fichiers, lancement du chat vocal"""
+    def __init__(self, parent=None):
+        """initialisation de la fenetre"""
+        super (DMonde, self).__init__()
+        self.plateau = None
+        self.partie = "partie1"
+        self.idPlateauEnCours = ""
+        self.plateauConnecte = False
+        self.createWidgets()
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        self.ui = Ui_principal()
+        self.ui.setupUi(self)
+        self.majVisibilitePanneauxPlateau("")
+        self.connect(self.ui.sauverPlateau, SIGNAL("clicked()"), self.sauverPlateau)   
+        self.connect(self.ui.fermerPlateau, SIGNAL("clicked()"), self.fermerPlateau)
+        self.ui.vuePlateau.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
+
+        self.majFichierInfosSvg()
+        self.creerEcranFondPlateau()
+        
+    def creerEcranFondPlateau(self):
+        ecranFondPlateau = EcranFondPlateau(self)
+        self.ui.vuePlateau.resetTransform()
+        self.ui.vuePlateau.setScene(ecranFondPlateau)
+        
+    def afficherEcranCreationPlateau(self):
+        """ouvre la fenetre de creation de plateau"""
+        valide = True
+        if self.plateau != None:
+            if self.plateau.estCree() == True:
+                valide = False
+        if valide:
+            self.creationPlateau = EcranCreationPlateau(self)
+            self.creationPlateau.setWindowModality(Qt.ApplicationModal)
+            self.creationPlateau.show()
+            self.creationPlateau.raise_()
+
+    def creerPlateau(self, nom, chapitre, formeCases, largeur, hauteur, couleur):
+        """cree le plateau entre en parametre"""
+        nouvelId = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))
+        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
+        self.plateau = Plateau(self)
+        self.plateau.creer(nouvelId, nom, chapitre, formeCases, largeur, hauteur, couleur)
+        QApplication.restoreOverrideCursor()
+        del self.creationPlateau
+                                   
+    def sauverPlateau(self, plateau):
+        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
+        if self.plateau.id in afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie)):
+           idPlateau = self.plateau.id
+        else:   
+           idPlateau = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))
+
+        enregistrerUnique(self.plateau, "parties\\{}\\svg\\{}.p".format(self.partie, idPlateau))
+        infos = {"nom": self.plateau.nom, "chapitre": self.plateau.chapitre, "dateCreation":self.plateau.dateCreation, "dateSvg":self.plateau.dateSvg, \
+                 "public": self.plateau.public, "enCours": self.plateau.enCours}
+        enregistrer(str(idPlateau), infos, "parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
+        QApplication.restoreOverrideCursor()
+
+    def chargerPlateau(self, nomFichierSvg):
+        if self.plateau != None:
+            if self.plateau.estCree() == True:
+                self.fermerPlateau()
+        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
+        self.plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, nomFichierSvg))
+        if self.plateau:
+            self.plateau.recreer(self)
+        else:
+            self.plateau = Plateau(self)
+        QApplication.restoreOverrideCursor()
+
+        return plateau
+
+    
+    def fermerPlateau(self):
+        self.plateau.fermer()
+        self.plateau = None
+        self.creerEcranFondPlateau()
+##        self.majVisibilitePanneauxPlateau("") 
+
+    def majFichierInfosSvg(self):
+        """construit/maj le fichier contenant la liste des
+           plateaux sauvegardes et leurs informations"""
+        #on parcourt les fichiers de sauvegarde
+        index = 0   
+        f = []
+        lstFichiersSvg = []
+        for (dirpath, dirnames, filenames) in os.walk("parties\\{}\\svg\\".format(self.partie)):
+            f.extend(filenames)
+            break
+        for fichier in f:
+            fileName, fileExtension = os.path.splitext(fichier)
+            if fileExtension == ".p":
+                lstFichiersSvg.append(fileName)
+      
+        #on verifie leur presence dans le fichier 'infos_sauvegarde'
+        infosSvg = afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
+        index = len(infosSvg)
+
+        #on ajoute les sauvegardes manquantes si besoin
+        for fichier in lstFichiersSvg:
+            if not fichier in infosSvg:
+                plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, fichier))
+                enregistrer(fichier, {"nom": plateau.nom, "chapitre": plateau.chapitre, "dateCreation":plateau.dateCreation, "dateSvg":plateau.dateSvg, \
+                                      "public": plateau.public, "enCours": plateau.enCours}, "svg\\infos_sauvegarde")
+                index += 1       
+        #on supprime ceux qui ne sont plus trouves
+        for fichier in infosSvg:
+            if not fichier in lstFichiersSvg:
+                supprSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie), fichier)
+
+    def majVisibilitePanneauxPlateau(self, mode):
+        """affiche ou cache les panneaux d'edition, d'information et de gestion du plateau"""
+        #self.ui.panneauInfosPlateau.setVisible(False)
+        conditionPlateau = (len(mode) > 0)
+        conditionModeCreation = (len(mode) > 0 and mode == "creation")
+        conditionModeCombat = (len(mode) > 0 and mode == "combat")
+
+        #panneaux d'infos
+        self.ui.infoOrdreJeu.setVisible(conditionPlateau)   
+        self.ui.infoPion.setVisible(conditionPlateau)
+        self.ui.infoDecor.setVisible(conditionPlateau)
+        self.ui.infoCase.setVisible(conditionPlateau)
+
+        #autre
+        self.ui.nomPlateau.setVisible(conditionPlateau)
+        self.ui.sauverPlateau.setVisible(conditionPlateau)
+        self.ui.fermerPlateau.setVisible(conditionPlateau)
+        self.ui.etiquetteModeAffichagePlateau.setVisible(conditionPlateau)
+        self.ui.modeAffichagePlateau.setVisible(conditionPlateau)
+        self.ui.combatTour.setVisible(conditionPlateau)
+        
+        #barre de combat:
+        if len(mode) > 0:
+            self.majVisibiliteBarreCombat("menu")
+        else:
+            self.majVisibiliteBarreCombat("aucun")
+        self.ui.combatPasserTour.setVisible(conditionPlateau)
+        self.ui.combatInventaire.setVisible(conditionPlateau)
+
+        #modes creation/combat
+        self.ui.modeCombatPlateau.setVisible(conditionModeCreation)
+        self.ui.outilsEditionPlateau.setVisible(conditionModeCreation)
+        self.ui.outilsCombatPlateau.setVisible(conditionModeCombat)
+        self.ui.modeCreationPlateau.setVisible(conditionModeCombat)
+
+    def reinitialiserPanneauxPlateau(self):
+        """remet a neuf les commandes liees au plateau"""
+        for panneau in [self.ui.panneauInfosPlateau, \
+                         self.ui.outilsEditionPlateau, \
+                         self.ui.outilsCombatPlateau]:
+            #listes
+            for liste in panneau.findChildren(QTableWidget):
+                while liste.rowCount() > 0:
+                    liste.removeRow(0)
+            #textes
+            for texte in panneau.findChildren(QLineEdit):
+                texte.clear()         
+            for texte in panneau.findChildren(QTextEdit):
+                texte.clear()
+            #a cocher
+            for bouton in panneau.findChildren(QToolButton):
+                if bouton.isCheckable():
+                    bouton.setChecked(False)
+            #autre
+            for item in panneau.findChildren(QSlider):
+                item.setValue(1)
+            for item in panneau.findChildren(QDoubleSpinBox):
+                item.setValue(0)                
+
+    def barreCombatMenu(self):
+        self.majVisibiliteBarreCombat("menu")
+
+    def barreCombatVol(self):
+        self.majVisibiliteBarreCombat("vol")
+
+    def barreCombatZone(self):
+        self.majVisibiliteBarreCombat("zone")        
+
+    def majVisibiliteBarreCombat(self, mode = ""):
+        """affiche ou cache les commandes de la barre de combat"""
+        #modes : "aucun", "menu", "vol", "zone"
+        for item in self.ui.barreBasCombat.children():
+            try:
+                item.setVisible(False)
+            except:
+                pass
+            
+        if mode != "aucun":
+            self.ui.combatPionSelectionne.setVisible(True)
+            self.ui.combatPionSelectionne_img.setVisible(True)
+            self.ui.combatPionSelectionne_img.setPixmap(QPixmap())   
+            self.ui.combatPasserTour.setVisible(True)
+            self.ui.combatInventaire.setVisible(True)
+        
+        if mode == "menu" or mode == "":
+            self.ui.combatDeplacement.setVisible(True)
+            self.ui.combatAttaqueCaC.setVisible(True)
+            self.ui.combatAttaqueDist.setVisible(True)
+            self.ui.combatAttaqueZone.setVisible(True)
+            self.ui.combatVol.setVisible(True)
+            
+        elif mode == "vol":
+            self.ui.combatVol.setVisible(True)
+            self.ui.combatVol_altitude.setVisible(True)
+            self.ui.combatRetour.setVisible(True)
+            
+        elif mode == "zone":
+            self.ui.combatZone_ligne.setVisible(True)
+            self.ui.combatZone_disque.setVisible(True)
+            self.ui.combatZone_disqueRayon.setVisible(True)
+            self.ui.combatZone_cone.setVisible(True)
+            self.ui.combatRetour.setVisible(True)
+
+
+
+
+
+
+
+
+        
+if __name__ == "__main__":
+   app = QApplication(argv)
+   #settrace(trace_calls)
+   dm = DMonde()
+   dm.show()
+   r = app.exec_()
+   exit(r)      
+
+
+
+
+
+
+
+

a faire.txt

@@ -0,0 +1,150 @@
+table des attributs: sur clic droit, afficher une inbox qui explique la saisie: =(par def)/+/-- & txt, jet de dés, valeur
+
+verifier fonction d'attaque a dist (au travers de decors)
+
+mettre en place les 'types de terrain' et de decors
+
+décors à forme variables : lignes, disques
+
+effet clic droit sur pion?  -> utiliser l'attaque actuellement selectionnee?
+
+edition de creatures:
+- finir inventaire
+- possibilite de saisir des jets de dés pour les quantités
+
+mettre en place des signaux de maj entre gestioncombat et plateau
+
+[utile?] reprendre la fonction d'occupation des cases pour qu'elle n'utilise plus les objets eux mêmes
+
+bouton de rafraichissement forcé (occupation des cases, affichage des cases, listes de pions et de décors...)
+
+reprendre affichage tactique pour qu'il remplace les terrains par des couleurs et qu'il affiche
+les pions ennemis en rouge, les alliés en bleu, les morts en noirs
+
+altitude des cases : prise en compte dans les deplacement et les champs de vision, hauteur max (plafond?)
+
+faire tableau des carac des décors
+
+créer les codes couleurs de la bordure des pions
+
+idée: mémoriser la position relative des cases de l'attaque zone-disque
+
+-----------------------
+fait 21/07
+- anti aliasing dans qt creator
+- zoom/dezoom
+- affichage distance parcourue
+- ajout de pions (clavier 'p')
+
+fait 22/07:
+- changement couleurs cases et pions
+- ajout textures
+- qgraphicsview dans layout
+
+fait 04/08
+- terrains prédéfinis (glace/forêt/marécage/grotte/desert/...) au pinceau
+- premier nettoyage du code
+- amélioration de la création de pions et de la gestion des modes d'interaction
+
+fait le 05/08:
+- listes de pions enregistrées
+
+fait entre le 06 et le 13/08:
+- formes complexes pour les pions: saisie lors de la creation, 
+                                   enregistrement des formes, 
+                                   possibilités de rotation (60°) et deplacement de ces formes
+                                   gestion des espaces occupés
+                                   .... c'était chaud!!
+- amélioration de la création de pions simples
+- ajout d'une image plus propre pour les pions
+
+fait le 14/08:
+- mouvement restant
+- image dans les infos pions
+- calcul des distances a parcourir prend en compte les pions
+- augmentation de la taille des cases pour des raisons de qualité graphique
+
+fait le 19 et 20/08
+- creation des effets sur les cases (feu, glace...)
+- infos sur la case survolée
+- création des fonctions liées à l'occupation des cases
+- creation de 'couches graphiques' via des polygones superposés
+- creation de la mise a jour des affichages (altitude, tactique, brouillard de guerre)
+- modification des altitudes
+
+fait le 25 et 26/08:
+- algorithme de champ de vision (a revoir: erreurs de superposition des ombres) [abandonné]
+- sauvegarde/chargement de plateau
+
+fait le 27/08
+- optimisation des creations/sauvegardes/chargement de plateau
+- images dans un repertoire séparé
+
+fait le 08/09
+- pions plus classes, avec rotation de l'image, et paramétrages des tailles et positions de l'image et de l'etiquette du pion (créatures seulement)
+
+fait entre le 10 et le 30/09
+- accès rapide aux couleurs customisées
+- formes de dessin (rect, ellipse, ligne, frontiere), 
+- reprise de l'interface 
+- outils de suppression des décors et pions
+
+fait le 07/10/2014
+- correction des pbm liés au format case carrées
+- reprise de la fonction polygonePion qui créé un polygone aggloméré à partir des cases occupées par un pion
+- correction et conversion des fenetres de creation/edition
+- controle de la mise a jour de la forme dans les ecrans d'edition decor/creature
+
+fait courant octobre:
+- caches
+- entrées/sorties
+- zone de placement
+- modes de combat
+- attaques de zone
+- résolution de conflits a la suppr des pions
+- amélioration de la fonction d'agglo de polygone
+
+fait le 28/10
+- module regles
+- Ordre de jeu et passage de tour
+- Ecran de gestion du combat
+- Affichage du pion sélectionné
+
+fait le 07/11
+- liste des attributs dans le panneau de combat
+
+fait le 13/11
+ - historisation des jets de dés dans gestion combat
+
+fait le 14/11
+ - amelioration des fonctions du module 'lancer'
+ - prise de notes pions 
+
+fait le 25/11
+ - stockage du numero du pion selectionne au lieu du pion lui même et creation de la fonction pionSelectionne()
+ - amelioration de la procedure de suppression
+ - liste des attaques et des attributs dans l'édition des créatures
+ - utiliser des attaques prédéfinies
+
+fait le 27/11
+- amelioration de la saisie/ édition des attaques
+- conversion utf8 partout
+- fenetre a part pour l'affichage des notes
+- infos attaque en cours
+- ebauche de reglement du pbm  de visee d'une partie d'un pion (insatisfaisant)
+
+fait le 28/11
+- possibilite de viser une partie dun pion
+- accélération de l'attaque de zone 'disque'
+- attaques de zone touche si une case du pion est touchee
+- charger plateau le plus recent et correction du tri de table par dates
+
+fait le 29/11
+- resolution bug deplacement decors
+- codes des pions decors au dela de 10000
+- possibilite de viser une partie d'un decor
+
+fait le 02/05/2015
+- Debut de reorganisation des librairies
+- Mise en place du versioning Git
+- Methode de synchro via USB

doc/couches.txt

@@ -0,0 +1,26 @@
+superposition des couches:
+
+0- plateau
+
+1- cases
+
+couleur fond
+bordure simple
+bordure champ de deplacement
+bordure bordure projection position
+
+2- decors
+
+
+
+3- effets sur terrain
+
+
+
+4- pions
+
+cases de forme (couleur)
+cercle, couleur, bordure, image
+aspect si selectionne
+aspect si a joué
+

lib/Attaque.py

@@ -0,0 +1,14 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+
+
+class Attaque():
+    """attaque pre-parametree affectee a un pion, un personnage ou une creature"""
+    def __init__(self):
+        self.nom = "Attaque"
+        self.typ = "cac"   #cac, dist, zone
+        self.portee = 1   #portee max en cases
+        self.formeZone = ""   #forme de l'attaque de zone
+        self.rayon = 1    #rayon d'une attaque de zone de type disque
+        self.attributs = regles.listeAttributsAttaques()
+        self.notes = ""

lib/Cache.py

@@ -0,0 +1,62 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class Cache(QGraphicsPolygonItem):
+    """cache place sur le plateau"""
+    def __init__(self, plateau, numCache = 0, parent=None):
+        """initialisation de la fenetre"""
+        super (Cache, self).__init__()
+        self.parent = plateau
+        self.plateau = plateau
+        self.numCache = numCache
+        self.transparence = 130
+        self.setVisible(False)
+        self.plateau.addItem(self)
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.setAcceptHoverEvents(True)
+
+    def afficher(self, actif, listeCases = []):
+        """affiche le cache sur la liste des cases en parametre"""
+        """met a jour l'affichage des cases selon les parametres enregistres pour le cache"""
+        if actif and len(listeCases) > 0:
+            if not self.isVisible():
+                self.setPolygon(self.plateau.polygoneAgglo(listeCases))
+                self.setBrush(QColor(0,0,0,130))
+                pinceau = QPen(QColor("black"))
+                pinceau.setWidth(10)
+                self.setPen(pinceau)
+                text = QGraphicsTextItem(QString.fromUtf8(str(self.numCache)))
+                pos = self.plateau.cases[self.plateau.coordCentreListeCases(listeCases)].centreGraphique
+                text.setPos(self.mapFromScene(pos))
+                police = QFont("Arial",30)
+                police.setBold(True)
+                text.setFont(police)
+                text.setDefaultTextColor(QColor(50,50,50,180))     
+                text.setParentItem(self)
+
+        self.setVisible(actif and len(listeCases) > 0)
+    
+    def mousePressEvent(self, event):
+        event.accept()
+
+    def mouseReleaseEvent(self, event):
+        event.accept()
+
+    def mouseMoveEvent(self, event):
+        event.accept()        
+
+    def mouseDoubleClickEvent(self, event):
+        event.accept()
+
+    def hoverEnterEvent(self, event):
+        event.accept()
+
+    def hoverLeaveEvent(self, event):
+        event.accept()
+
+    def hoverMoveEvent(self, event):
+        event.accept()

lib/Case.py

@@ -0,0 +1,446 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from Terrain import Terrain
+
+class Case(QGraphicsPolygonItem):
+    """objet graphique representant une case du plateau"""
+    def __init__(self, plateau, parent=None):
+        super(Case, self).__init__()
+        #plateau
+        self.plateau = plateau
+        
+        #attributs
+        self.x = 0
+        self.y = 0        
+        self.altitude = 0                   
+        self.terrain = Terrain()                       #terrain par defaut 
+        self.couleur = None                            #couleur du fond par defaut
+        self.bordure = QColor(85, 85, 85, 85)          #couleur de la bordure par defaut
+        self.estDansChampDeplacement = False           #la case est dans le champ de deplacement du pion selectionne
+        self.centreGraphique = None
+        self.formeCases = "H"
+
+        self.occupeePar = {}    #objet: altitudes occupees (sous forme de tuple, ex: (0,1,2) pour une creature occupant les cases d'altitude 0, 1 et 2)
+        self.estCache = False   #est sous un cache place par le MJ (cache le terrain, les decors, les pions aux joueurs...)
+        self.ombre = True       #ombre (cache les pions uniquement)  
+
+        #effet sur la case 
+        self.effetActif = "" 
+
+        #polygones d'affichage
+        self.polygoneEffet = None
+        self.polygoneAffichageSpecial = None
+        self.etiquetteAltitude = None
+
+    def __getstate__(self):
+        """selectionne les attributs qui seront sauvegardes"""
+        self.idTerrain = self.terrain.id
+        state = {key:value for key, value in self.__dict__.items() if key in ["x", "y", "altitude","idTerrain","bordure","couleur", \
+                                                                              "estCache", "ombre", "effetActif"]}
+
+        return (state)
+
+    def __setstate__(self, state):
+        """recupere les attributs sauvegardes"""
+        self.__dict__ = state
+        if self.idTerrain == "00":
+            self.terrain = Terrain()
+        else:
+            self.terrain = charger("librairie\\terrain", self.idTerrain)
+        
+
+    ######## fonctions de base : geometrie, aspect graphique      ######
+    def creer(self, x, y, couleur = QColor(0, 255, 0, 80)):
+        """creation du polygone et enregistrement des donnees geometriques"""
+        self.x = x
+        self.y = y
+        self.couleur = couleur
+        #creation de l'objet graphique sur le plateau
+        self.creerGraphique()
+        
+    def creerGraphique(self):
+        """cree les objets graphiques representant la case"""
+        #reinitialisation des variables 
+        self.couleurEffet = {"brule":QColor("orange"), "glace":QColor("white"), "poison":QColor("green"), "eau":QColor("blue")}
+        self.imgEffet = {"brule":"effFeu.jpg", "glace":"effGlace.jpg", "poison":"effPoison.png", "eau":"effEau.png"}
+
+        #enregistrement des cases voisines: 
+        self.voisins = self.lstVoisins(self.x, self.y)
+        self.occupeePar = {}
+   
+        #enregistrement du centre
+        if self.plateau.formeCases == "H":
+            self.centreGraphique = QPointF(((self.x*0.866)+0.5773)*self.plateau.hCase, (self.y+0.5)*self.plateau.hCase)
+        else:
+            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.plateau.addItem(self)
+        
+        #interactions graphiques:
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.setAcceptHoverEvents(True)
+        self.setAcceptDrops(True)
+        self.setZValue(0)
+        self.setFiltersChildEvents(True)
+
+        #pour afficher les coordonnees des cases:        
+        #text = QGraphicsSimpleTextItem("{}-{}".format(self.x,self.y), parent=self)
+        #if self.plateau.formeCases == "H":
+        #    text.setPos(QPointF(((self.x*0.866)+0.2886)*self.plateau.hCase,  self.y*self.plateau.hCase))
+        #else:
+        #    text.setPos(QPointF(self.x*self.plateau.hCase,  self.y*self.plateau.hCase))
+        
+        #polygone utilise lorsque dans champ de deplacement 
+        self.polygoneChampDep = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
+        self.polygoneChampDep.setVisible(False)
+        self.polygoneChampDep.setAcceptHoverEvents(False)
+        
+        #apparence initiale de la case
+        self.majCouleur(self.couleur)            
+
+        #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)
+
+        #polygone test (pour capter les evts souris par dessus d'autres objets)
+##        self.polygoneTest = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
+##        self.polygoneTest.setVisible(True)
+##        self.polygoneTest.setAcceptHoverEvents(True)
+##        self.polygoneTest.setFlag(QGraphicsItem.ItemIsFocusable)
+##        self.polygoneTest.setBrush(QColor(0,0,0,0))
+##        self.polygoneTest.setPen(QPen(QColor(0,0,0,0)))
+##        self.polygoneTest.setAcceptedMouseButtons(Qt.NoButton)
+##        self.polygoneTest.setZValue(200)
+##        self.polygoneTest.setParentItem(self)
+
+    def majGraphique(self):
+        """met a jour l'aspect graphique de la acse en fonction de son etat"""
+        if self.terrain:
+            if len(self.terrain.nom) > 0 : 
+                self.majTerrain(self.terrain)   
+        self.majAffichageSpecial("")
+        self.majEffet(self.effetActif)
+
+    def recreer(self, plateau):
+        self.plateau = plateau
+        super(Case, self).__init__()
+        #polygones d'affichage
+        self.polygoneEffet = None
+        self.polygoneAffichageSpecial = None
+        self.etiquetteAltitude = None
+        
+        self.creerGraphique()
+        self.majGraphique()
+
+    def polygone(self, x, y):
+        """renvoie l'objet graphique hexagone de la case"""
+        polygone = QPolygonF()
+        if self.plateau.formeCases == "H":
+            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
+           seulement cases existantes sur le plateau / seulement cases adjacentes (cas des cases carrees)"""
+        voisins = []
+        if self.plateau.formeCases == "H":
+            lst = [(x, y-1), (x+1, y-0.5), (x+1, y+0.5), (x,  y+1), (x-1, y+0.5), (x-1, y-0.5)]         
+        else:
+            lst = [(x, y-1), (x+1, y-1), (x+1, y), (x+1, y+1), (x,   y+1), (x-1, y+1), (x-1, y), (x-1, y-1)]
+                  
+        for coord in lst: 
+            if self.plateau.coordonneesValides(coord): voisins.append(coord)
+        return voisins                      
+
+     
+    ########################
+
+    ########## fonctions liees a l'etat de la case ###########
+    def majCouleur(self, couleur):
+        self.couleur = couleur
+        self.setBrush(couleur)
+        self.polygoneChampDep.setBrush(self.couleurDep())
+        pinceau = QPen()
+        pinceau.setColor(self.couleurBordure())
+        pinceau.setWidth(1)
+        self.setPen(pinceau)
+        
+    def majTerrain(self, terrain):
+        if terrain != None: 
+            self.terrain = terrain
+            if len(self.terrain.imgTexture) > 0:
+                self.setBrush(QBrush(QImage("img\\"+self.terrain.imgTexture)))
+            else:
+                if self.terrain.couleur.isValid():
+                     self.setBrush(QBrush(self.terrain.couleur))
+                     self.couleur = self.terrain.couleur
+                     self.polygoneChampDep.setBrush(self.couleurDep())
+        else:
+            self.terrain = Terrain()
+
+    def majOccupation(self, objet, nouveauZ = None):
+        """met a jour l'occupation de la case par les pions, decors..."""
+        if objet != None:
+            if not objet in self.occupeePar and nouveauZ != None:
+                #on ajoute l'objet a la liste des objets occupant la case ou on met a jour son altitude
+                casesOccupees = []
+                for i in range(0, objet.hauteur):
+                    casesOccupees.append(self.altitude + nouveauZ + i)
+                self.occupeePar[objet] = casesOccupees
+                
+            elif objet in self.occupeePar and nouveauZ == None:
+                #on supprime l'objet de la liste des objets occupant la case
+                del self.occupeePar[objet]
+            else:
+                pass
+            
+    def estOccupee(self, z=0):
+        """renvoie vrai si la case correspondant a la hauteur z est occupee"""
+        retour = False
+        for objet in self.occupeePar:
+            if objet.hauteur > 0 and z in self.occupeePar[objet]:
+                retour = True
+        return retour        
+
+    def estOccupeePar(self, z=0):
+        """si la case correspondant a la hauteur z est occupee, renvoie l'objet en question
+           sinon renvoie None"""
+        retour = None
+        for objet in self.occupeePar:
+            if objet.hauteur > 0 and z in self.occupeePar[objet]:
+                retour = objet
+        return retour  
+
+    def pionOccupant(self):
+        """si un pion occupe cette case, le renvoie"""
+        retour = None
+        for objet in self.occupeePar:
+            if objet.__class__.__name__ == "Pion":
+                retour = objet
+        return retour          
+
+    def estFranchissable(self, z=0):
+        """la case est-elle franchissable?"""
+        retour = True
+        if self.terrain.franchissable == False:
+            retour = False
+        else:
+            if self.estOccupee(z) == True:
+                retour = False
+        return retour
+
+    def estObstacleVision(self, hauteurObs):
+        """renvoie vrai si la case et l'eventuel decor qui l'occupe bloquent le champ de
+           vision d'un observateur situe a la hauteur precisee"""
+        retour = False
+        if self.altitude > hauteurObs:
+            retour = True
+        else:
+            hauteurObstacle = 0
+            for objet in self.occupeePar:
+                if objet.hauteur > hauteurObstacle:
+                    hauteurObstacle = objet.hauteur
+            if (self.altitude + hauteurObstacle) > hauteurObs:
+                retour = True
+        return retour                
+
+    def majEstDansChampDeplacement(self, actif):
+        """la case apparait ou pas comme etant dans le champ de deplacement d'un pion"""
+        self.polygoneChampDep.setVisible(actif)
+
+    def majEstCibleAttaque(self, actif):
+        """la case apparait ou pas comme etant dans le champ de deplacement d'un pion"""
+        self.polygoneChampDep.setVisible(actif)
+
+    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)    
+            
+    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)
+            pinceau = QPen()
+            pinceau.setColor(self.bordure)
+            pinceau.setWidth(1)
+            self.polygoneEffet.setPen(pinceau)
+            self.polygoneEffet.setVisible(False)
+
+        if len(effet) > 0 and effet != "aucun":
+            #gradient de couleur
+            gradient = QRadialGradient(self.centreGraphique, 0.5*self.plateau.hCase)
+            couleur0 = QColor(0,0,0,0)
+            couleur20 = self.couleurEffet[effet]
+            couleur20.setAlpha(70)
+            couleur10 = self.couleurEffet[effet]
+            couleur10.setAlpha(255)
+
+            gradient.setColorAt(0, couleur0)
+            gradient.setColorAt(0.8, couleur0)
+            gradient.setColorAt(0.95, couleur10)
+            gradient.setColorAt(0.98, couleur20)
+            gradient.setColorAt(1, couleur10)
+            self.polygoneEffet.setBrush(gradient)
+   
+            self.polygoneEffet.setVisible(True)
+
+            self.effetActif = effet
+        else:
+            self.polygoneEffet.setVisible(False)              
+
+    def majAltitude(self, altitude):
+        """met a jour l'altitude de la case"""
+        self.altitude = altitude
+
+    def majAffichageSpecial(self, affichage=""):
+        """donne a la case l'aspect demande en rendant visible/invisible le polygone d'affichage special"""
+        #polygone d'affichage special (altitude, tactique...)
+        if self.polygoneAffichageSpecial == None:
+            self.polygoneAffichageSpecial = QGraphicsPolygonItem(self.polygone(self.x, self.y), parent=self)
+            pinceau = QPen()
+            pinceau.setColor(self.bordure)
+            pinceau.setWidth(1)
+            self.polygoneAffichageSpecial.setPen(pinceau)
+
+        if affichage != "altitude" and self.etiquetteAltitude:
+            self.etiquetteAltitude.setVisible(False)
+            
+        if affichage == "tactique":
+            if self.terrain.franchissable:
+                self.polygoneAffichageSpecial.setBrush(QColor(255,255,255))
+            else:
+                self.polygoneAffichageSpecial.setBrush(QColor(50,50,50))
+            self.polygoneAffichageSpecial.setVisible(True)
+            
+        elif affichage == "altitude":
+            if self.etiquetteAltitude == None:
+                self.etiquetteAltitude = QGraphicsSimpleTextItem("{}".format(self.altitude), parent=self)
+                police = QFont("Georgia", 18)
+                police.setItalic(True)
+                self.etiquetteAltitude.setFont(police)
+                self.etiquetteAltitude.setPos(QPointF(((self.x*0.866)+0.65)*self.plateau.hCase,  (self.y+0.7)*self.plateau.hCase))
+            if self.altitude >= 0:
+                couleur = QColor("red").lighter(200-(5*self.altitude))
+            else:
+                couleur = QColor("purple").lighter(200+(5*self.altitude))
+            self.polygoneAffichageSpecial.setBrush(couleur)
+            self.polygoneAffichageSpecial.setZValue(5)
+            self.polygoneAffichageSpecial.setVisible(True)
+            self.etiquetteAltitude.setText(QString.fromUtf8("{}".format(self.altitude)))
+            self.etiquetteAltitude.setVisible(True)
+            self.etiquetteAltitude.setZValue(6)
+        else:
+            self.polygoneAffichageSpecial.setVisible(False)
+        
+    def couleurDep(self):
+        """renvoie une couleur secondaire utilisee pour les champs de deplacements"""
+        luminositeActuelle = self.couleurEffective().lightness()
+        if luminositeActuelle < 150:
+            retour = QColor(210,255,255,100)
+        else:
+            retour = QColor(210,255,255,100)
+        return retour
+
+    def couleurProj(self, valide):
+        """renvoie une couleur secondaire utilisee pour les projections de deplacement"""
+        luminositeActuelle = self.couleurEffective().lightness()
+        if valide:
+            retour = QColor("white")
+        else:
+            retour = QColor("red")
+        if luminositeActuelle > 220:
+            retour = retour.darker(120)
+            
+        return retour
+
+    def couleurBordure(self):
+        """renvoie la couleur utilisee pour les bordures de la case"""
+        luminositeActuelle = self.couleurEffective().lightness()
+        if luminositeActuelle > 150:
+            retour = QColor(85, 85, 85, 130)
+        elif luminositeActuelle > 100 and luminositeActuelle <= 150:
+            retour = QColor(10, 10, 10, 130)
+        else:
+            retour = QColor(255, 255, 255, 180)
+        return retour        
+
+    def couleurEffective(self):
+        """renvoie la couleur effective de la case (utile quand la texture est une image)"""
+        texture = self.brush()
+        if texture.textureImage().isNull():
+            couleurFond = texture.color()
+        else:
+            couleurFond = self.couleurDominante(texture.textureImage())
+        return couleurFond
+
+    def couleurDominante(self, img):
+        """retourne la couleur dominante d'une QImage"""
+        r = 0
+        v = 0
+        b = 0
+        for i in range(0, img.width()):
+            for j in range(0, img.height()):
+                pixel = img.pixel(i,j)
+                r += qRed(pixel)
+                v += qGreen(pixel)
+                b += qBlue(pixel)
+        nb_pix = img.width() * img.height()   
+        r_moy = int(r / nb_pix)
+        v_moy = int(v / nb_pix)
+        b_moy = int(b / nb_pix)
+        return QColor(r_moy, v_moy, b_moy)
+
+    ######### evebements souris et clavier    #################
+    #*EC
+    def mousePressEvent(self, event):
+        """evenement lors du clic souris"""
+        super(Case, self).mousePressEvent(event)
+        if event.button() == 1: #sur clic gauche
+            accepte = self.plateau.caseCliquee((self.x, self.y))
+            if accepte: event.accept()
+        else:
+            event.ignore()
+
+    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)
+        self.plateau.caseSurvol(self)
+
+    def hoverLeaveEvent(self, event):
+        """met a jour l'affichage de la case au survol de la souris, si un pion est selectionne"""
+        super(Case, self).hoverLeaveEvent(event)
+        #self.plateau.caseSurvol()
+    
+    ########################

lib/Creature.py

@@ -0,0 +1,27 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+class Creature():
+    """creature a affecter a un pion"""
+    def __init__(self, parent=None):
+        self.id = "00"
+        self.nom = ""                #libelle a afficher dans la liste 
+        self.couleur = QColor("grey")    #couleur si pas de texture
+        self.logo = ""                #image source du logo
+        self.img = {"nom": "", "kx": 1, "ky": 1, "dx": 0, "dy": 0, "rotation": 0, "pivote": False, "masqueAuto": False}
+        self.txt = {"taille_police": 20, "gras": False, "dx": 0, "dy": 0, "rotation": 0}
+        self.deplacement = 9         #capacite de deplacement (par tour)
+        self.vol = False             #peut voler
+        self.formeDef = {"H":[], "C":[]} #definition de la forme du decor sur cases hexagonales (cf. classe Forme("H")) et sur cases carrees (cf. classe Forme("C"))        
+        self.hauteur = 1             #nombre de cases occupees verticalement par la creature
+        self.lstCaracCreature = regles.listeAttributs()    #attributs complementaires lies aux regles utilisees
+        self.attaques = []
+        self.inventaire = {}          #inventaire {objet: nombre}
+        self.notes = ""
+
+    def listeCarac(self):
+        return self.lstCaracCreature
+
+    def listeAttaques(self):
+        return self.attaques

lib/Decor.py

@@ -0,0 +1,21 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class Decor():
+    """decor a placer sur le plateau"""
+    def __init__(self, parent=None):
+        self.id = "00"
+        self.nom = ""                   #libelle a afficher dans la liste 
+        self.couleur = QColor("grey")       #couleur si pas de texture
+        #self.img = ""                   #image source a afficher
+        self.logo = ""                #image source du logo
+        self.img = {"nom": "", "kx": 1, "ky": 1, "dx": 0, "dy": 0, "rotation": 0, "pivote": False, "masqueAuto": False}
+        self.escalade = False           #peut etre escalade
+        self.franchissablePied = False  #peut etre franchi a pied
+        self.franchissableVol = False   #peut etre franchi en volant
+        self.brule = False              #peut prendre feu
+        self.hauteur = 0                #hauteur (en cases)
+        self.formeDef = {"H":[], "C":[]} #definition de la forme du decor sur cases hexagonales (cf. classe Forme("H")) et sur cases carrees (cf. classe Forme("C"))        

lib/EcranAffichageTexte.py

@@ -0,0 +1,28 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from ui.ecran_affichageTexte import Ui_affichageTexte
+
+class EcranAffichageTexte(QDialog):
+    """boite de dialogue d'affichage de texte longs"""
+    def __init__(self, texte="", parent=None):
+        """initialisation de la fenetre - le controle source est le widget a remettre a jour avec le texte a la fermeture"""
+        super (EcranAffichageTexte, self).__init__()
+        self.createWidgets()
+        self.ui.texte.setText(QString.fromUtf8(texte))
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        self.ui = Ui_affichageTexte()
+        self.ui.setupUi(self)
+
+    def recupererTexte(self):
+        return self.texte
+
+    def done(self, result=1):
+        self.texte = str(self.ui.texte.toPlainText().toUtf8())
+        super (EcranAffichageTexte, self).done(result)

lib/EcranCreationPlateau.py

@@ -0,0 +1,155 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+from time import time, sleep, strftime, localtime
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from ui.ecran_creationPlateau import Ui_creationPlateau
+
+from outilsSvg import *
+
+class EcranCreationPlateau(QDialog):
+    """interface de creation/chargement de plateau"""
+    def __init__(self, fenetrePrincipale, terrain=None, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranCreationPlateau, self).__init__()
+        self.fenetre = fenetrePrincipale
+        self.couleur = QColor(0, 255, 0, 80)
+        self.idSvgPlusRecent = None     #id de la sauvegarde du plateau le plus recent
+        
+        self.createWidgets()
+        self.majAffichage()
+        self.focusBoutonChargerEC()
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_creationPlateau()
+        self.ui.setupUi(self)
+        
+        self.ui.couleurCasesPlateau.setStyleSheet("QLabel {backGround:%s}" %(self.couleur))
+        self.majListeChargement()
+        self.connect(self.ui.creerPlateau, SIGNAL("clicked()"), self.creerPlateau)
+        self.connect(self.ui.nomPlateau, SIGNAL("textEdited(QString)"), self.focusBoutonCreer)
+        self.connect(self.ui.nomPlateau, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.listPlateau, SIGNAL("cellPressed(int, int)"), self.majAffichage) 
+        self.connect(self.ui.listPlateau, SIGNAL("cellPressed(int, int)"), self.focusBoutonCharger) 
+        self.connect(self.ui.selectionCouleur, SIGNAL("clicked()"), self.selectionCouleur)
+        self.connect(self.ui.supprimerPlateau, SIGNAL("clicked()"), self.supprimerPlateau)
+        self.connect(self.ui.chargerPlateau, SIGNAL("clicked()"), self.chargerPlateau)
+        self.connect(self.ui.chargerPlateauEC, SIGNAL("clicked()"), self.chargerPlateauEC)
+        self.connect(self.ui.chapitreChargementPlateau, SIGNAL("valueChanged(int)"), self.majListeChargement)
+        self.connect(self.ui.toutAfficherPlateau, SIGNAL("stateChanged(int)"), self.majListeChargement)
+
+    def creerPlateau(self):
+        nom = self.ui.nomPlateau.text().toUtf8()
+        largeur = self.ui.largeurPlateau.value()
+        hauteur = self.ui.hauteurPlateau.value()
+        chapitre = str(self.ui.chapitrePlateau.value())
+        if self.ui.formeCase_hexagone.isChecked():
+            formeCases = "H"
+        else:
+            formeCases = "C"
+        ok = True
+        if (largeur * hauteur) > 10000:
+            reponse = QMessageBox.question(self, 'Message',
+                                           "Attention ! \nLe nombre élevé de cases peut entrainer des ralentissements " \
+                                           "importants...\nVoulez vous continuer?", QMessageBox.Yes | 
+                                           QMessageBox.No, QMessageBox.No)
+            if reponse == QMessageBox.No:
+                ok = False
+        if ok == True:
+            self.fenetre.creerPlateau(nom, chapitre, formeCases, largeur, hauteur, self.couleur)
+            self.close()
+
+    def chargerPlateau(self):
+        """charge le plateau selectionne"""
+        index = str(self.ui.listPlateau.item(self.ui.listPlateau.currentRow(), 0).text().toUtf8())
+        self.fenetre.chargerPlateau(index)
+        self.close()
+
+    def chargerPlateauEC(self):
+        """charge le plateau le pus recent"""
+        if self.idSvgPlusRecent != None:
+            self.fenetre.chargerPlateau(self.idSvgPlusRecent)
+            self.close()
+            
+    def supprimerPlateau(self):
+        """supprime le plateau selectionne"""
+        reponse = QMessageBox.question(self, 'Message',
+                                           "Etes vous sûr de vouloir supprimer ce plateau?", QMessageBox.Yes | 
+                                           QMessageBox.No, QMessageBox.No)
+        if reponse == QMessageBox.Yes:       
+            index = str(self.ui.listPlateau.item(self.ui.listPlateau.currentRow(), 0).text().toUtf8())
+            os.remove("parties\\{}\\svg\\{}.p".format(self.fenetre.partie, index))
+            supprSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.fenetre.partie), index)
+            self.majListeChargement()
+        
+
+    def majListeChargement(self):
+        """remplit ou maj la liste des plateaux sauvegardes"""
+        #on met a jour la largeur des colonnes
+        self.ui.listPlateau.setColumnWidth(0, 0)  #colonne de l'index (invisible)
+        self.ui.listPlateau.setColumnWidth(1, 55)
+        self.ui.listPlateau.setColumnWidth(2, 110)
+        self.ui.listPlateau.setColumnWidth(3, 60)
+        self.ui.listPlateau.setColumnWidth(4, 80)
+        self.ui.listPlateau.setColumnWidth(5, 50)
+        self.ui.listPlateau.setColumnWidth(6, 50)
+##        self.ui.listPlateau.setColumnHidden(6, True)
+
+        #on vide la liste   si necessaire
+        while self.ui.listPlateau.rowCount() > 0:
+            self.ui.listPlateau.removeRow(0)
+        
+        infosSvg = afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.fenetre.partie))
+        ligne  = 0
+        for id_svg in infosSvg:
+            if self.idSvgPlusRecent == None or infosSvg[id_svg]["dateSvg"] > infosSvg[self.idSvgPlusRecent]["dateSvg"]: self.idSvgPlusRecent = id_svg
+            
+            if infosSvg[id_svg]["chapitre"] == str(self.ui.chapitreChargementPlateau.value()) or bool(self.ui.toutAfficherPlateau.checkState()) == True:
+                self.ui.listPlateau.insertRow(ligne)
+                self.ui.listPlateau.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(str(id_svg))))
+                self.ui.listPlateau.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(" "+infosSvg[id_svg]["chapitre"])))
+                self.ui.listPlateau.setItem(ligne, 2, QTableWidgetItem(QString.fromUtf8(infosSvg[id_svg]["nom"])))
+                self.ui.listPlateau.setItem(ligne, 3, QTableWidgetItem(QString.fromUtf8(strftime('%d/%m/%y %H:%M',localtime(infosSvg[id_svg]["dateCreation"])))))
+                self.ui.listPlateau.setItem(ligne, 4, QTableWidgetItem(QString.fromUtf8(strftime('%d/%m/%y %H:%M',localtime(infosSvg[id_svg]["dateSvg"])))))
+                if infosSvg[id_svg]["public"] == True:
+                    txt = "Oui"
+                else:
+                    txt = "Non"
+                self.ui.listPlateau.setItem(ligne, 5, QTableWidgetItem(QString.fromUtf8(txt)))
+
+                self.ui.listPlateau.setItem(ligne, 6, QTableWidgetItem(QString.fromUtf8(str(infosSvg[id_svg]["dateSvg"]))))
+                
+                ligne += 1
+        for i in range(1,5):
+            self.ui.listPlateau.sizeHintForColumn(i)
+            
+        #on trie par date    
+##        trierTable(self.ui.listPlateau, 6, 1)          
+
+    def majAffichage(self):
+        self.ui.creerPlateau.setEnabled(len(self.ui.nomPlateau.text().toUtf8()) > 0)
+        self.ui.chargerPlateau.setEnabled(self.ui.listPlateau.currentRow()>=0)
+        self.ui.supprimerPlateau.setEnabled(self.ui.listPlateau.currentRow()>=0)
+        self.ui.chargerPlateauEC.setEnabled(self.ui.listPlateau.rowCount() > 0)
+        
+    def selectionCouleur(self):
+        """selectionne la couleur dans la boite de dialogue dediee"""
+        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        if couleur.isValid():
+            nomCouleur = couleur.name()
+            self.ui.couleurCasesPlateau.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
+            self.couleur = couleur    
+
+    def focusBoutonChargerEC(self):
+        self.ui.chargerPlateauEC.setFocus()
+
+    def focusBoutonCharger(self):
+        self.ui.chargerPlateau.setFocus()
+
+    def focusBoutonCreer(self):
+        self.ui.creerPlateau.setFocus()

lib/EcranEditionAttaques.py

@@ -0,0 +1,256 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from ui.ecran_editionAttaques import Ui_editionAttaques
+        
+class EcranEditionAttaques(QFrame):
+    #*EEA
+    """interface d'edition des attaques du pion"""
+    def __init__(self, pion, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranEditionAttaques, self).__init__()
+        self.pion = pion
+        self.colonnesBase = {}
+        self.createWidgets()
+        self.majEnCours = False
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_editionAttaques()
+        self.ui.setupUi(self)
+        self.connect(self.ui.nouvelleAttaque, SIGNAL("clicked()"), self.nouvelleAttaque)
+        self.connect(self.ui.supprimerAttaque, SIGNAL("clicked()"), self.supprimerAttaque)
+##        self.connect(SIGNAL("majTypeAttaque()"), self.majTypeAttaque)
+        self.initListe()
+        self.majListe()
+        self.connect(self.ui.editionListeAttaques, SIGNAL("cellChanged(int, int)"), self.celluleModifiee)
+
+    def initListe(self):
+        """formate la table des donnees"""
+        #mise en forme des colonnes
+        #colonnes de base: celles qui ne dependent pas des regles utilisees
+        self.colonnesBase = ["numAttaque","Type","Nom","Portee","Forme","Rayon"]
+        largeurColonnesBase = {"numAttaque": 0, "Type": 70, "Nom": 100, "Portee": 60, "Forme": 80,"Rayon": 60}
+
+        for i in range(0, 10):
+            self.ui.editionListeAttaques.insertColumn(i)
+            self.ui.editionListeAttaques.setColumnHidden(i, (i >= len(self.colonnesBase)))
+            if i < len(self.colonnesBase):
+                self.ui.editionListeAttaques.setHorizontalHeaderItem(i, QTableWidgetItem(self.colonnesBase[i]))
+                if self.colonnesBase[i] in largeurColonnesBase:
+                    largeur = largeurColonnesBase[self.colonnesBase[i]]
+                else:
+                    largeur = 60
+                if largeur > 0:    
+                    self.ui.editionListeAttaques.setColumnWidth(i, largeur)
+                else:    
+                    self.ui.editionListeAttaques.setColumnHidden(i, True)
+                    
+        ordre = regles.ordreAttributsAttaques()
+        for elt in ordre:
+            numCol = 10 + ordre.index(elt)
+            self.ui.editionListeAttaques.insertColumn(numCol)
+            self.ui.editionListeAttaques.setHorizontalHeaderItem(numCol, QTableWidgetItem(QString.fromUtf8(elt)))
+            self.ui.editionListeAttaques.setColumnWidth(numCol, 45)
+            self.ui.editionListeAttaques.setColumnHidden(numCol, False)
+            
+    def majListe(self):
+        """met a jour le contenu de la table des donnees"""
+        self.majEnCours = True
+        while self.ui.editionListeAttaques.rowCount() > 0:
+            self.ui.editionListeAttaques.removeRow(0)
+        index = 0
+
+        for numAttaque in range(0, len(self.pion.attaques)):
+            self.ui.editionListeAttaques.insertRow(int(index))
+            #liste deroulante des types d'attaque
+            self.ui.editionListeAttaques.setCellWidget(int(index), self.colonnesBase.index("Type"), self.listeTypesAttaques())
+            
+            #num du pion (0):   
+            self.ui.editionListeAttaques.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(str(numAttaque))))
+            self.majDonneesAttaque(numAttaque)
+            index += 1
+
+        self.majEnCours = False
+
+    def majDonneesAttaque(self, numAttaque):
+        """met a jour les donnees de l'attaque"""
+        index = None
+        for i in range(0, self.ui.editionListeAttaques.rowCount()):
+            if int(self.ui.editionListeAttaques.item(i, 0).text().toUtf8()) == numAttaque:
+                index = i
+                break
+
+        if index != None:
+            ### parametres de base
+            #Type d'attaque
+            item = QTableWidgetItem()
+            item.setFlags(Qt.NoItemFlags)
+            item.setFlags(Qt.ItemIsSelectable)
+
+            if self.pion.attaques[numAttaque].typ in ["cac", "dist", "zone"]:
+                self.ui.editionListeAttaques.cellWidget(index, self.colonnesBase.index("Type")).setCurrentIndex(\
+                    self.ui.editionListeAttaques.cellWidget(index, self.colonnesBase.index("Type")).findData(QVariant(self.pion.attaques[numAttaque].typ)))
+                self.afficherDonneesAttaqueZone(index, (self.pion.attaques[numAttaque].typ == "zone"))
+            #Nom de l'attaque
+            self.ui.editionListeAttaques.setItem(index, self.colonnesBase.index("Nom"), QTableWidgetItem(QString.fromUtf8(self.pion.attaques[numAttaque].nom)))
+                                    
+            #Portee
+            self.ui.editionListeAttaques.setItem(index, self.colonnesBase.index("Portee"), QTableWidgetItem(QString.fromUtf8(str(self.pion.attaques[numAttaque].portee))))
+                        
+            ### parametres supplementaires (issus des regles)
+            for elt in self.pion.attaques[numAttaque].attributs:
+                col = 10 + regles.ordreAttributsAttaques().index(elt)
+                self.ui.editionListeAttaques.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.pion.attaques[numAttaque].attributs[elt]))))
+        else:
+            print ("Attaque {} introuvable, impossible de maj".format(numPion))
+ 
+        
+    def celluleModifiee(self, ligne, colonne):
+        """une cellule de la table a ete modifiee"""
+        if not self.majEnCours:
+            numAttaque = int(self.ui.editionListeAttaques.item(ligne, 0).text().toUtf8())
+            if colonne < len(self.colonnesBase):
+                if colonne == self.colonnesBase.index("Nom"):
+                    nom = str(self.ui.editionListeAttaques.item(ligne, colonne).text().toUtf8())
+                    if not len(nom) > 0:
+                        nom = "Att. {}".format(numAttaque)
+                    self.pion.attaques[numAttaque].nom = nom
+                
+                elif colonne == self.colonnesBase.index("Type"):
+                    typ = str(self.ui.editionListeAttaques.cellWidget(ligne, colonne).itemData(\
+                              self.ui.editionListeAttaques.cellWidget(ligne, colonne).currentIndex()).toString())
+                    self.pion.attaques[numAttaque].typ = typ
+                    self.afficherDonneesAttaqueZone(ligne, (typ == "zone"))
+                    
+                elif colonne == self.colonnesBase.index("Forme"):
+                    forme = str(self.ui.editionListeAttaques.cellWidget(ligne, colonne).itemData(\
+                              self.ui.editionListeAttaques.cellWidget(ligne, colonne).currentIndex()).toString())
+                    self.pion.attaques[numAttaque].formeZone = forme
+                    
+                elif colonne == self.colonnesBase.index("Portee"):
+                    #doit etre de type numerique
+                    try:
+                        portee = int(str(self.ui.editionListeAttaques.item(ligne, colonne).text().toUtf8()))
+                        valide = True
+                    except:
+                        valide = False
+                    if valide:
+                        self.pion.attaques[numAttaque].portee = portee
+                    else:    
+                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(self.pion.attaques[numAttaque].portee))
+
+                elif colonne == self.colonnesBase.index("Rayon"):
+                    #doit etre de type numerique
+                    try:
+                        rayon = int(str(self.ui.editionListeAttaques.item(ligne, colonne).text().toUtf8()))
+                        valide = True
+                    except:
+                        valide = False
+                    if valide:
+                        self.pion.attaques[numAttaque].rayon = rayon
+                    else:    
+                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.pion.attaques[numAttaque].rayon)))
+                        
+            elif colonne >= 10:
+                self.majEnCours = True
+                index = colonne - 10
+                attribut = regles.ordreAttributsAttaques()[index]
+                valeurAttribut = regles.listeControleAttaques()[attribut].controler(str(self.ui.editionListeAttaques.item(ligne, colonne).text().toUtf8()))
+                if valeurAttribut != None:
+                    self.pion.attaques[numAttaque].attributs[attribut] = valeurAttribut
+                else:
+                    self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.pion.attaques[numAttaque].attributs[attribut])))
+                self.majEnCours = False
+
+    def majTypeAttaque(self):
+        """une des liste de type a ete modifiee, on met a jour toute la colonne (en attendant mieux :( )"""
+        colonne = self.colonnesBase.index("Type")
+        for i in range(0, self.ui.editionListeAttaques.rowCount()):
+            if str(self.ui.editionListeAttaques.cellWidget(i, colonne).itemData(\
+                   self.ui.editionListeAttaques.cellWidget(i, colonne).currentIndex())) != \
+                   self.pion.attaques[int(self.ui.editionListeAttaques.item(i, 0).text().toUtf8())].typ:
+                self.celluleModifiee(i, colonne)
+
+    def majFormeZone(self):
+        """une des liste de type a ete modifiee, on met a jour toute la colonne (en attendant mieux :( )"""
+        colonne = self.colonnesBase.index("Forme")
+        for i in range(0, self.ui.editionListeAttaques.rowCount()):
+            if self.ui.editionListeAttaques.cellWidget(i, colonne).__class__.__name__ == "QComboBox":
+                if str(self.ui.editionListeAttaques.cellWidget(i, colonne).itemData(\
+                       self.ui.editionListeAttaques.cellWidget(i, colonne).currentIndex())) != \
+                       self.pion.attaques[int(self.ui.editionListeAttaques.item(i, 0).text().toUtf8())].formeZone:
+                    self.celluleModifiee(i, colonne)
+                
+    def nouvelleAttaque(self):
+        """ajoute une ligne a la table et une attaque au pion"""
+        self.pion.attaques.append(Attaque())
+        self.majListe()
+
+    def supprimerAttaque(self):
+        """supprime l'attaque selectionnee de la liste des attaques du pion"""
+        numAttaque = None
+
+        for i in range(0, self.ui.editionListeAttaques.rowCount()):
+            if self.ui.editionListeAttaques.item(i,0).isSelected():
+                numAttaque = int(self.ui.editionListeAttaques.item(i,0).text().toUtf8())
+        if numAttaque != None:
+            reponse = QMessageBox.question(self, 'Message',
+                           "Etes vous sûr de vouloir supprimer cette attaque?", QMessageBox.Yes | 
+                           QMessageBox.No, QMessageBox.No)
+            if reponse == QMessageBox.Yes:   
+                del self.pion.attaques[numAttaque]
+                self.majListe()
+        else:
+            print "pas d'attaque selectionnee"
+
+    def listeTypesAttaques(self):
+        """retourne la QComboBox qui apparait dans la colonne Type d'attaque"""
+        liste = QComboBox()
+        liste.addItem(QIcon("img\\curseurEpee.png"), QString.fromUtf8("C.à.C"), "cac")
+        liste.addItem(QIcon("img\\arc.png"), QString.fromUtf8("Dist."), "dist")
+        liste.addItem(QIcon("img\\baguette.png"), QString.fromUtf8("Zone"), "zone")
+        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.majTypeAttaque)
+        return liste
+    
+    def listeFormesZone(self):
+        """retourne la QComboBox qui apparait dans la colonne forme de zone"""
+        liste = QComboBox()
+        liste.addItem(QIcon("img\\formeLigne.png"), QString.fromUtf8("Ligne"), "ligne")
+        liste.addItem(QIcon("img\\formeEllipsePlein.png"), QString.fromUtf8("Disque"), "disque")
+        liste.addItem(QIcon("img\\cone.png"), QString.fromUtf8("Cone"), "cone")
+        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.majFormeZone)
+        return liste
+
+    def afficherDonneesAttaqueZone(self, ligne, afficher):
+        """rend modifiables ou non les donnees de base liees aux attaques de zone et modifie l'affichage en consequence"""
+        self.majEnCours = True
+        if afficher == True:
+            numAttaque = int(self.ui.editionListeAttaques.item(ligne, 0).text().toUtf8())
+            if self.ui.editionListeAttaques.cellWidget(ligne, self.colonnesBase.index("Forme")) == None:
+                self.ui.editionListeAttaques.setCellWidget(ligne, self.colonnesBase.index("Forme"), self.listeFormesZone())
+            if self.pion.attaques[numAttaque].formeZone in ["ligne", "disque", "cone"]:
+                self.ui.editionListeAttaques.cellWidget(ligne, self.colonnesBase.index("Forme")).setCurrentIndex(\
+                    self.ui.editionListeAttaques.cellWidget(ligne, self.colonnesBase.index("Forme")).findData(QVariant(self.pion.attaques[numAttaque].formeZone)))
+            item = QTableWidgetItem(QString.fromUtf8(str(self.pion.attaques[numAttaque].rayon)))
+            item.setBackgroundColor(QColor("white"))
+            self.ui.editionListeAttaques.setItem(ligne, self.colonnesBase.index("Rayon"), item)
+        else:
+            if self.ui.editionListeAttaques.cellWidget(ligne, self.colonnesBase.index("Forme")) != None:
+                self.ui.editionListeAttaques.removeCellWidget(ligne, self.colonnesBase.index("Forme"))
+            item = QTableWidgetItem(QString.fromUtf8(""))
+            item.setFlags(Qt.NoItemFlags)
+            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            item.setBackgroundColor(QColor(200,200,200))
+            self.ui.editionListeAttaques.setItem(ligne, self.colonnesBase.index("Forme"), item)    
+            item = QTableWidgetItem(QString.fromUtf8(""))
+            item.setFlags(Qt.NoItemFlags)
+            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
+            item.setBackgroundColor(QColor(200,200,200))
+            self.ui.editionListeAttaques.setItem(ligne, self.colonnesBase.index("Rayon"), item)
+
+        self.majEnCours = False

lib/EcranEditionCreature.py

@@ -0,0 +1,353 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class EcranEditionCreature(QDialog):
+    """interface de creation/edition de terrains"""
+    def __init__(self, creature=None, formeCases = "H", parent=None):
+        """initialisation de la fenetre"""
+        super (EcranEditionCreature, self).__init__()
+        self.creature = creature
+        self.pixGraphique = None
+        self.formeCases = formeCases
+        self.createWidgets()
+        
+        if creature == None:
+            self.accesCreation()
+        else:
+            self.accesEdition()
+        self.majAffichage("")
+        self.afficheListeAttaques()
+        self.majListeAttributs()
+##        self.majListeInventaire()
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_editionCreature()
+        self.ui.setupUi(self)
+        self.connect(self.ui.enregistrerCreature, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.annulerCreature, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.supprimerCreature, SIGNAL("clicked()"), self.supprimer)
+        self.connect(self.ui.idCreature, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.nomCreature, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.couleurCreature, SIGNAL("clicked()"), self.selectionCouleur)
+
+        self.connect(self.ui.imgTextureCreature, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgLogoCreature, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgAfficherCreature, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPivoteCreature, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgMasqueCreature, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleXCreature, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleYCreature, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosXCreature, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosYCreature, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgRotationCreature, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgReinitCreature, SIGNAL("clicked()"), self.reinitImage)
+
+        self.connect(self.ui.nomCreature, SIGNAL("textEdited(QString)"), self.majApercuTexte)
+        self.connect(self.ui.txtAfficherCreature, SIGNAL("stateChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtTaillePoliceCreature, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtGrasCreature, SIGNAL("stateChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtPosXCreature, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtPosYCreature, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtRotationCreature, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtReinitCreature, SIGNAL("clicked()"), self.reinitTexte)
+
+        self.vueForme = VueEditionForme(self, self.formeCases)
+        self.vueForme.creer()
+
+        self.ui.listeAttributs.setColumnWidth(0, (0.4*self.ui.listeAttributs.width())) 
+        self.ui.listeAttributs.setColumnWidth(1, (0.4*self.ui.listeAttributs.width()))
+        self.connect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection)
+
+##        self.ui.listeInventaireCreature.setColumnWidth(0, (0.2*self.ui.listeInventaireCreature.width()))
+##        self.ui.listeInventaireCreature.setColumnWidth(1, (0.8*self.ui.listeInventaireCreature.width()))
+##        self.connect(self.ui.listeInventaireCreature, SIGNAL("clicked()"), self.listeInventaireCelluleModifiee)
+##        self.connect(self.ui.supprimerInventaireCreature, SIGNAL("clicked()"), self.supprimerLigneListeInventaire)
+##        self.connect(self.ui.ajouterInventaireCreature, SIGNAL("clicked()"), self.ajouterLigneListeInventaire)
+   
+        
+    def accesEdition(self):
+        """ouverture en mode edition"""
+        self.ui.idCreature.setEnabled(True)
+       
+        self.ui.idCreature.setText(QString.fromUtf8(str(self.creature.id)))
+        self.ui.nomCreature.setText(QString.fromUtf8(str(self.creature.nom)))
+        self.ui.notesCreature.setText(QString.fromUtf8(str(self.creature.notes)))
+        
+        if self.creature.couleur.isValid():
+            self.ui.affichageCouleurCreature.setStyleSheet("QLabel {backGround:%s}" %(self.creature.couleur.name()))
+        self.ui.imgLogoCreature.setText(QString.fromUtf8(str(self.creature.logo)))
+        self.ui.imgTextureCreature.setText(QString.fromUtf8(str(self.creature.img["nom"])))
+        self.ui.imgTailleXCreature.setValue(self.creature.img["kx"])
+        self.ui.imgTailleYCreature.setValue(self.creature.img["ky"])
+        self.ui.imgPosXCreature.setValue(self.creature.img["dx"])
+        self.ui.imgPosYCreature.setValue(self.creature.img["dy"])
+        self.ui.imgRotationCreature.setValue(self.creature.img["rotation"])
+        self.ui.imgPivoteCreature.setChecked(self.creature.img["pivote"])
+        self.ui.imgMasqueCreature.setChecked(self.creature.img["masqueAuto"])
+
+        self.ui.txtTaillePoliceCreature.setValue(self.creature.txt["taille_police"])
+        self.ui.txtGrasCreature.setChecked(self.creature.txt["gras"])
+
+        self.ui.txtPosXCreature.setValue(self.creature.txt["dx"])
+        self.ui.txtPosYCreature.setValue(self.creature.txt["dy"])
+        self.ui.txtRotationCreature.setValue(self.creature.txt["rotation"])
+        
+        self.ui.deplacementCreature.setValue(self.creature.deplacement)
+        self.ui.hauteurCreature.setValue(self.creature.hauteur)
+        self.ui.volCreature.setChecked(self.creature.vol)
+   
+        self.vueForme.majForme(self.creature.formeDef[self.formeCases])
+        self.ui.supprimerCreature.setEnabled(True)
+        self.ui.idCreature.setEnabled(False)
+        self.majApercuImage()
+        self.majApercuTexte()
+
+    def accesCreation(self):
+        """ouverture en mode creation"""
+        self.creature = Creature()
+        self.ui.idCreature.setEnabled(True)
+        self.ui.idCreature.setText(QString.fromUtf8(str(self.nouvelIdCreature())))
+        self.ui.idCreature.setEnabled(False)
+        self.majApercuImage()
+        self.majApercuTexte()
+
+    def majAffichage(self, txt):
+        """verifie la validite des saisies"""
+        self.ui.enregistrerCreature.setEnabled(len(self.ui.idCreature.text().toUtf8()) > 0 and len(self.ui.nomCreature.text().toUtf8()) > 0)
+
+    def afficheListeAttaques(self):
+        """insere la frame d'edition des attaques"""
+        tabAttaques = self.ui.ongletsCreation.widget(1)
+        editionAttaques = EcranEditionAttaques(self.creature)
+        editionAttaques.setParent(tabAttaques)
+
+    def majListeAttributs(self):
+        """met a jour la liste des attributs de la creature"""
+        """met a jour la liste des attributs dans le panneau de combat"""
+        self.disconnect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+        
+        #on vide la liste
+        while self.ui.listeAttributs.rowCount() > 0:
+            self.ui.listeAttributs.removeRow(0)
+        
+        #attributs issus des regles utilisees    
+        ordre = regles.ordreAttributs()
+        for elt in ordre:
+            ligne = ordre.index(elt)
+            self.ui.listeAttributs.insertRow(ligne)
+            if regles.attribut(elt).combatSeulement == True: self.ui.listeAttributs.setRowHidden(ligne, True)
+            item = QTableWidgetItem(QString.fromUtf8(elt))
+            item.setFlags(Qt.NoItemFlags)
+            self.ui.listeAttributs.setItem(ligne, 0, item)
+            self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.creature.lstCaracCreature[elt]))))
+            
+        self.connect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+
+    def listeAttributCelluleModifiee(self, ligne, colonne):
+        """une cellule de la liste des attributs a ete modifiee"""
+        if colonne != 1:
+            pass
+        else:
+            attribut = regles.ordreAttributs()[(ligne)]
+            nouvelleVal = str(self.ui.listeAttributs.item(ligne, 1).text().toUtf8())
+            valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal)
+            if valVerifiee != None:
+                self.creature.lstCaracCreature[attribut] = valVerifiee
+            else:    
+                self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.creature.lstCaracCreature[attribut]))))
+
+##    def majListeInventaire(self):
+##        """met a jour la liste de l'inventaire de la creature"""
+##        self.disconnect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##        
+##        #on vide la liste
+##        while self.ui.listeInventaireCreature.rowCount() > 0:
+##            self.ui.listeInventaireCreature.removeRow(0)
+##        ligne = 0
+##        #attributs issus des regles utilisees
+##        for objet in self.creature.inventaire:
+##            self.ui.listeInventaireCreature.insertRow(ligne)
+##            self.ui.listeInventaireCreature.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(self.creature.inventaire[objet])))
+##            self.ui.listeInventaireCreature.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
+##            ligne += 1
+##        self.connect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##
+##    def listeInventaireCelluleModifiee(self, ligne, colonne):
+##        """une cellule de la liste des attributs a ete modifiee"""
+##        nouvelleVal = str(self.ui.listeInventaireCreature.item(ligne, colonne).text().toUtf8())
+##        val = None
+##        if colonne == 0:
+##            try:
+##                nbre = int(nouvelleVal)
+##            except:
+##                nbre = -1
+##            if nbre >= 0: val = str(nbre)
+##        else:
+##            val = str(nouvelleVal)
+##            if val in self.creature.inventaire or len(val) == 0:
+##                print("cet objet existe deja ou a un nom invalide")
+##                val = None
+##
+##        if colonne == 0:    
+##            if val != None:
+##                self.creature.inventaire[str(self.ui.listeInventaireCreature.item(ligne, 1).text().toUtf8())] = val
+##            else:
+##                self.ui.listeInventaireCreature.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(\
+##                                                        str(self.creature.inventaire[str(self.ui.listeInventaireCreature.item(ligne, 1).text().toUtf8())]))))
+##        else:
+##            txt = str(self.ui.listeInventaireCreature.item(ligne, 1).text().toUtf8())
+##            if txt in self.creature.inventaire:
+##                del self.creature.inventaire[txt]
+##            if val != None:
+##                self.creature.inventaire[val] = txt
+##            else:    
+##                self.ui.listeInventaireCreature.removeRow(ligne)
+##
+##    def ajouterLigneListeInventaire(self, objet=""):
+##        num = -1
+##        for i in range(0, self.ui.listeInventaireCreature.rowCount()):   #si un objet de la liste a deja un nom vide, on ne cree pas de nouvelle ligne
+##            if len(str(self.ui.listeInventaireCreature.item(i, 0).text().toUtf8())) == 0:
+##                num = i
+##                break 
+##        if num < 0:           
+##            self.disconnect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##            ligne = self.ui.listeInventaireCreature.rowCount()
+##            self.ui.listeInventaireCreature.insertRow(ligne)
+##            self.ui.listeInventaireCreature.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8("0")))
+##            self.ui.listeInventaireCreature.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
+##            self.connect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##        else:
+##            self.ui.listeInventaireCreature.setCurrentRow(num)
+##            
+##    def supprimerLigneListeInventaire(self):
+##        self.disconnect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##        ligne = self.ui.listeInventaireCreature.currentRow()
+##        del self.creature.inventaire[str(self.ui.listeInventaireCreature.item(ligne, 1).text().toUtf8())]
+##        self.ui.listeInventaireCreature.removeRow(ligne)
+##        self.connect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)        
+
+    def majApercuImage(self):
+        """met a jour l'image sur l'apercu du pion"""
+        if self.ui.imgAfficherCreature.isChecked():
+            if len(str(self.ui.imgTextureCreature.text().toUtf8())) > 0:
+                img = str(self.ui.imgTextureCreature.text().toUtf8())
+                self.vueForme.majImage(img, self.ui.imgTailleXCreature.value() \
+                                          , self.ui.imgTailleYCreature.value() \
+                                          , self.ui.imgPosXCreature.value() \
+                                          , self.ui.imgPosYCreature.value() \
+                                          , self.ui.imgRotationCreature.value() \
+                                          , self.ui.imgPivoteCreature.isChecked() \
+                                          , self.ui.imgMasqueCreature.isChecked() )
+            else:
+                img = str(self.ui.imgLogoCreature.text().toUtf8())
+                self.vueForme.majImage(img)
+        else:
+            img = ""
+            self.vueForme.majImage(img)
+
+    def majApercuTexte(self):
+        """met a jour l'etiquette sur l'apercu du pion"""
+        if self.ui.txtAfficherCreature.isChecked():
+            txt = str(self.ui.nomCreature.text().toUtf8())
+        else:
+            txt = "Pion"   
+        self.vueForme.majTexte(txt, self.ui.txtTaillePoliceCreature.value() \
+                                  , self.ui.txtGrasCreature.isChecked() \
+                                  , self.ui.txtPosXCreature.value() \
+                                  , self.ui.txtPosYCreature.value() \
+                                  , self.ui.txtRotationCreature.value())
+
+    def reinitImage(self):
+        self.ui.imgTailleXCreature.setValue(10)
+        self.ui.imgTailleYCreature.setValue(10)
+        self.ui.imgPosXCreature.setValue(0)
+        self.ui.imgPosYCreature.setValue(0)
+        self.ui.imgRotationCreature.setValue(0)
+        self.ui.imgPivoteCreature.setChecked(False)
+        self.ui.imgMasqueCreature.setChecked(False)
+        self.majApercuImage()
+
+    def reinitTexte(self):
+        self.ui.txtTaillePoliceCreature.setValue(21)
+        self.ui.txtGrasCreature.setCheckState(0)
+        self.ui.txtPosXCreature.setValue(0)
+        self.ui.txtPosYCreature.setValue(0)
+        self.ui.txtRotationCreature.setValue(0)
+        self.majApercuTexte()        
+
+    def nouvelIdCreature(self):
+        """renvoie un identifiant pour un nouveau terrain"""
+        dicoSvg = afficheSvg("librairie\\creature")
+        nouvelId = 1
+        while str(nouvelId) in dicoSvg.keys():
+            nouvelId += 1
+        return str(nouvelId)
+
+    def selectionCouleur(self):
+        """selectionne la couleur dans la boite de dialogue dediee"""
+        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        if couleur.isValid():
+            nomCouleur = couleur.name()
+            self.ui.affichageCouleurCreature.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
+            self.creature.couleur = couleur    
+            
+    def enregistrer(self):
+        """enregistre le terrain cree/edite"""
+        self.creature.id = str(self.ui.idCreature.text().toUtf8())
+        self.creature.nom = str(self.ui.nomCreature.text().toUtf8())
+        self.creature.logo = str(self.ui.imgLogoCreature.text().toUtf8())
+        if len(str(self.ui.imgTextureCreature.text().toUtf8())) > 0:
+            self.creature.img["nom"] = str(self.ui.imgTextureCreature.text().toUtf8())
+            self.creature.img["kx"] = self.ui.imgTailleXCreature.value()
+            self.creature.img["ky"] = self.ui.imgTailleYCreature.value()
+            self.creature.img["dx"] = self.ui.imgPosXCreature.value()
+            self.creature.img["dy"] = self.ui.imgPosYCreature.value()
+            self.creature.img["rotation"] = self.ui.imgRotationCreature.value()
+            self.creature.img["pivote"] = self.ui.imgPivoteCreature.isChecked()
+            self.creature.img["masqueAuto"] = self.ui.imgMasqueCreature.isChecked()
+        else:
+            self.creature.img["nom"] = str(self.ui.imgLogoCreature.text().toUtf8())
+            self.creature.img["kx"] = 10
+            self.creature.img["ky"] = 10
+            self.creature.img["dx"] = 0
+            self.creature.img["dy"] = 0
+            self.creature.img["rotation"] = 0
+            self.creature.img["pivote"] = False
+            self.creature.img["masqueAuto"] = False
+
+        self.creature.txt["taille_police"] = self.ui.txtTaillePoliceCreature.value()
+        self.creature.txt["gras"] = bool(self.ui.txtGrasCreature.checkState())
+        self.creature.txt["dx"] = self.ui.txtPosXCreature.value()
+        self.creature.txt["dy"] = self.ui.txtPosYCreature.value()
+        self.creature.txt["rotation"] = self.ui.txtRotationCreature.value()
+
+        self.creature.deplacement = int(self.ui.deplacementCreature.value())
+        self.creature.hauteur = int(self.ui.hauteurCreature.value())
+        self.creature.vol = self.ui.volCreature.isChecked()
+
+        self.creature.formeDef[self.formeCases] = self.vueForme.formeDef()
+
+        self.creature.notes = str(self.ui.notesCreature.toPlainText())
+        #attributs, attaques et inventaire enregistres lors de la modif des listes
+        
+        enregistrer(self.creature.id, self.creature, "librairie\\creature")
+        self.creature = None
+        self.emit(SIGNAL("majListCreatures()"))
+        self.close()
+
+    def supprimer(self):
+        """supprimer l'enregistrement de ce terrain"""
+        supprSvg("librairie\\creature", self.creature.id)
+        self.emit(SIGNAL("majListCreatures()"))
+        self.close()
+
+    def annuler(self):
+        """annule la creation/edition"""
+        self.creature = None
+        self.close()

lib/EcranEditionDecors.py

@@ -0,0 +1,191 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from ui.ecran_editionDecor import Ui_editionDecor
+
+class EcranEditionDecors(QDialog):
+    """interface de creation/edition de decors"""
+    def __init__(self, decor=None, formeCases = "H", parent=None):
+        """initialisation de la fenetre"""
+        super (EcranEditionDecors, self).__init__()
+        self.decor = decor
+        self.pixGraphique = None
+        self.formeCases = formeCases
+        self.createWidgets()
+        
+        if decor == None:
+            self.accesCreation()
+        else:
+            self.accesEdition()
+        self.majAffichage("")    
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_editionDecor()
+        self.ui.setupUi(self)
+        self.connect(self.ui.enregistrerDecor, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.annulerDecor, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.supprimerDecor, SIGNAL("clicked()"), self.supprimer)
+        self.connect(self.ui.idDecor, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.nomDecor, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.couleurDecor, SIGNAL("clicked()"), self.selectionCouleur)
+
+        self.connect(self.ui.imgDecor, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgLogoDecor, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgAfficherDecor, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPivoteDecor, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgMasqueDecor, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleXDecor, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleYDecor, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosXDecor, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosYDecor, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgRotationDecor, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgReinitDecor, SIGNAL("clicked()"), self.reinitImage)
+
+        self.vueForme = VueEditionForme(self, self.formeCases)
+        self.vueForme.creer()
+        
+    def accesEdition(self):
+        """ouverture en mode edition"""
+        self.ui.idDecor.setEnabled(True)
+       
+        self.ui.idDecor.setText(QString.fromUtf8(str(self.decor.id)))
+        self.ui.nomDecor.setText(QString.fromUtf8(str(self.decor.nom)))        
+        if self.decor.couleur.isValid():
+            self.ui.affichageCouleurDecor.setStyleSheet("QLabel {backGround:%s}" %(self.decor.couleur.name()))
+
+        self.ui.imgLogoDecor.setText(QString.fromUtf8(str(self.decor.logo)))
+        if self.decor.img["nom"] != self.decor.logo: 
+            self.ui.imgDecor.setText(QString.fromUtf8(str(self.decor.img["nom"])))
+        self.ui.imgTailleXDecor.setValue(self.decor.img["kx"])
+        self.ui.imgTailleYDecor.setValue(self.decor.img["ky"])
+        self.ui.imgPosXDecor.setValue(self.decor.img["dx"])
+        self.ui.imgPosYDecor.setValue(self.decor.img["dy"])
+        self.ui.imgRotationDecor.setValue(self.decor.img["rotation"])
+        self.ui.imgPivoteDecor.setChecked(self.decor.img["pivote"])
+        self.ui.imgMasqueDecor.setChecked(self.decor.img["masqueAuto"])
+          
+        self.ui.hauteurDecor.setValue(self.decor.hauteur)    
+        self.ui.couvertDecor.setChecked(self.decor.couvert)
+        self.ui.escaladeDecor.setChecked(self.decor.escalade)
+        self.ui.franchissablePiedDecor.setChecked(self.decor.franchissablePied)
+        self.ui.franchissableVolDecor.setChecked(self.decor.franchissableVol)
+        self.ui.bruleDecor.setChecked(self.decor.brule)
+              
+        self.vueForme.majForme(self.decor.formeDef[self.formeCases])    
+        self.ui.supprimerDecor.setEnabled(True)
+        self.ui.idDecor.setEnabled(False)
+        self.majApercuImage()
+
+    def accesCreation(self):
+        """ouverture en mode creation"""
+        self.decor = Decor()
+        self.ui.idDecor.setEnabled(True)
+        self.ui.idDecor.setText(QString.fromUtf8(str(self.nouvelIdCreature())))
+        self.ui.idDecor.setEnabled(False)
+        self.majApercuImage()
+
+    def majAffichage(self, txt):
+        """verifie la validite des saisies"""
+        self.ui.enregistrerDecor.setEnabled(len(self.ui.idDecor.text().toUtf8()) > 0 and len(self.ui.nomDecor.text().toUtf8()) > 0)
+
+    def nouvelIdCreature(self):
+        """renvoie un identifiant pour un nouveau decor"""
+        dicoSvg = afficheSvg("librairie\\decor")
+        nouvelId = 1
+        while str(nouvelId) in dicoSvg.keys():
+            nouvelId += 1
+        return str(nouvelId)
+
+    def selectionCouleur(self):
+        """selectionne la couleur dans la boite de dialogue dediee"""
+        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        if couleur.isValid():
+            nomCouleur = couleur.name()
+            self.ui.affichageCouleurDecor.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
+            self.decor.couleur = couleur    
+
+    def majApercuImage(self):
+        """met a jour l'image sur l'apercu du pion"""
+        if self.ui.imgAfficherDecor.isChecked():
+            if len(str(self.ui.imgDecor.text().toUtf8())) > 0:
+                img = str(self.ui.imgDecor.text().toUtf8())
+                self.vueForme.majImage(img, self.ui.imgTailleXDecor.value() \
+                                  , self.ui.imgTailleYDecor.value() \
+                                  , self.ui.imgPosXDecor.value() \
+                                  , self.ui.imgPosYDecor.value() \
+                                  , self.ui.imgRotationDecor.value() \
+                                  , self.ui.imgPivoteDecor.isChecked() \
+                                  , self.ui.imgMasqueDecor.isChecked())
+            else:
+                img = str(self.ui.imgLogoDecor.text().toUtf8())
+                self.vueForme.majImage(img)
+        else:
+            img = ""
+            self.vueForme.majImage(img)
+
+
+    def reinitImage(self):
+        self.ui.imgTailleXDecor.setValue(10)
+        self.ui.imgTailleYDecor.setValue(10)
+        self.ui.imgPosXDecor.setValue(0)
+        self.ui.imgPosYDecor.setValue(0)
+        self.ui.imgRotationDecor.setValue(0)
+        self.ui.imgPivoteDecor.setChecked(False)
+        self.ui.imgMasqueDecor.setChecked(False)
+        self.majApercuImage()
+            
+    def enregistrer(self):
+        """enregistre le terrain cree/edite"""
+        self.decor.id = str(self.ui.idDecor.text().toUtf8())
+        self.decor.nom = str(self.ui.nomDecor.text().toUtf8())
+
+        self.decor.logo = str(self.ui.imgLogoDecor.text().toUtf8())
+        if len(str(self.ui.imgDecor.text().toUtf8())) > 0:       
+            self.decor.img["nom"] = str(self.ui.imgDecor.text().toUtf8())
+            self.decor.img["kx"] = self.ui.imgTailleXDecor.value()
+            self.decor.img["ky"] = self.ui.imgTailleYDecor.value()
+            self.decor.img["dx"] = self.ui.imgPosXDecor.value()
+            self.decor.img["dy"] = self.ui.imgPosYDecor.value()
+            self.decor.img["rotation"] = self.ui.imgRotationDecor.value()
+            self.decor.img["pivote"] = self.ui.imgPivoteDecor.isChecked()
+            self.decor.img["masqueAuto"] = self.ui.imgMasqueDecor.isChecked()
+        else:
+            self.decor.img["nom"] = str(self.ui.imgLogoDecor.text().toUtf8())
+            self.decor.img["kx"] = 10
+            self.decor.img["ky"] = 10
+            self.decor.img["dx"] = 0
+            self.decor.img["dy"] = 0
+            self.decor.img["rotation"] = 0
+            self.decor.img["pivote"] = False
+            self.decor.img["masqueAuto"] = self.ui.imgMasqueDecor.isChecked()
+            
+        self.decor.hauteur = int(self.ui.hauteurDecor.value())        
+        self.decor.couvert = self.ui.couvertDecor.isChecked()
+        self.decor.brule = self.ui.bruleDecor.isChecked()
+        self.decor.franchissablePied = self.ui.franchissablePiedDecor.isChecked()
+        self.decor.franchissableVol = self.ui.franchissableVolDecor.isChecked()
+        self.decor.escalade = self.ui.escaladeDecor.isChecked()
+        
+        self.decor.formeDef[self.formeCases] = self.vueForme.formeDef()
+        
+        enregistrer(self.decor.id, self.decor, "librairie\\decor")
+        self.decor = None
+        self.emit(SIGNAL("majListDecors()"))
+        self.close()
+
+    def supprimer(self):
+        """supprimer l'enregistrement de ce terrain"""
+        supprSvg("librairie\\decor", self.decor.id)
+        self.emit(SIGNAL("majListDecors()"))
+        self.close()
+
+    def annuler(self):
+        """annule la creation/edition"""
+        self.decor = None
+        self.close()

lib/EcranEditionTerrain.py

@@ -0,0 +1,103 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class EcranEditionTerrain(QDialog):
+    """interface de creation/edition de terrains"""
+    def __init__(self, terrain=None, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranEditionTerrain, self).__init__()
+        self.createWidgets()
+        self.terrain = terrain
+        if terrain == None:
+            self.accesCreation()
+        else:
+            self.accesEdition()
+        self.majAffichage("")    
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_editionTerrain()
+        self.ui.setupUi(self)
+        self.connect(self.ui.enregistrerTerrain, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.annulerTerrain, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.supprimerTerrain, SIGNAL("clicked()"), self.supprimer)
+        self.connect(self.ui.idTerrain, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.nomTerrain, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.couleurTerrain, SIGNAL("clicked()"), self.selectionCouleur)
+        
+    def accesEdition(self):
+        """ouverture en mode edition"""
+        self.ui.idTerrain.setEnabled(True)
+       
+        self.ui.idTerrain.setText(QString.fromUtf8(str(self.terrain.id)))
+        self.ui.nomTerrain.setText(QString.fromUtf8(str(self.terrain.nom)))        
+        if self.terrain.couleur.isValid():
+            self.ui.affichageCouleurTerrain.setStyleSheet("QLabel {backGround:%s}" %(self.terrain.couleur.name()))
+        self.ui.imgTextureTerrain.setText(QString.fromUtf8(str(self.terrain.imgTexture)))      
+        self.ui.modDeplacementTerrain.setValue(self.terrain.modDeplacement)
+        if self.terrain.visibilite:
+            self.ui.visibiliteTerrain.setCheckState(2)
+        else:
+            self.ui.visibiliteTerrain.setCheckState(0)
+        if self.terrain.franchissable:    
+            self.ui.franchissableTerrain.setCheckState(2)
+        else:
+            self.ui.franchissableTerrain.setCheckState(0)
+        self.ui.supprimerTerrain.setEnabled(True)
+        self.ui.idTerrain.setEnabled(False)
+
+    def accesCreation(self):
+        """ouverture en mode creation"""
+        self.terrain = Terrain()
+        self.ui.idTerrain.setEnabled(True)
+        self.ui.idTerrain.setText(QString.fromUtf8(str(self.nouvelIdTerrain())))
+        self.ui.idTerrain.setEnabled(False)
+
+    def majAffichage(self, txt):
+        """verifie la validite des saisies"""
+        self.ui.enregistrerTerrain.setEnabled(len(self.ui.idTerrain.text().toUtf8()) > 0 and len(self.ui.nomTerrain.text().toUtf8()) > 0)
+
+    def nouvelIdTerrain(self):
+        """renvoie un identifiant pour un nouveau terrain"""
+        dicoSvg = afficheSvg("librairie\\terrain")
+        nouvelId = 1
+        while str(nouvelId) in dicoSvg.keys():
+            nouvelId += 1
+        return str(nouvelId)
+
+    def selectionCouleur(self):
+        """selectionne la couleur dans la boite de dialogue dediee"""
+        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        if couleur.isValid():
+            nomCouleur = couleur.name()
+            self.ui.affichageCouleurTerrain.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
+            self.terrain.couleur = couleur    
+            
+    def enregistrer(self):
+        """enregistre le terrain cree/edite"""
+        self.terrain.id = str(self.ui.idTerrain.text().toUtf8())
+        self.terrain.nom = str(self.ui.nomTerrain.text().toUtf8())
+        self.terrain.imgTexture = str(self.ui.imgTextureTerrain.text().toUtf8())
+        self.terrain.modDeplacement = float(self.ui.modDeplacementTerrain.value())
+        self.terrain.visibilite = bool(self.ui.visibiliteTerrain.checkState())
+        self.terrain.franchissable = bool(self.ui.franchissableTerrain.checkState())
+        enregistrer(self.terrain.id, self.terrain, "librairie\\terrain")
+        self.terrain = None
+        self.close()
+        self.emit(SIGNAL("majListTerrains()"))
+
+    def supprimer(self):
+        """supprimer l'enregistrement de ce terrain"""
+        supprSvg("terrain", self.terrain.id)
+        self.close()
+        self.emit(SIGNAL("majListTerrains()"))
+
+    def annuler(self):
+        """annule la creation/edition"""
+        self.terrain = None
+        self.close()

lib/EcranFondPlateau.py

@@ -0,0 +1,20 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class EcranFondPlateau(QGraphicsScene):
+    """ecran de fond lorsqu'aucun plateau n'est cree"""
+    def __init__(self, fenetre, parent=None):
+        super(EcranFondPlateau, self).__init__()
+        self.fenetre = fenetre
+        self.setBackgroundBrush(QBrush(QPixmap("img\\parchemin.jpg")))
+        police = QFont("GothicI", 16)
+        self.addText(QString.fromUtf8("Cliquer pour créer\nou ouvrir un plateau"),police)
+        #self.ecranFondPlateau.addText(QString("Charger un plateau"),police)
+
+    def mousePressEvent(self, event):
+        """cree un plateau sur clic gauche"""
+        if event.button() == 1:
+            self.fenetre.afficherEcranCreationPlateau()

lib/EcranGestionCombat.py

@@ -0,0 +1,337 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+                
+class EcranGestionCombat(QFrame):
+    #*EGC
+    """interface de gestion du combat (MJ)"""
+    def __init__(self, plateau, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranGestionCombat, self).__init__()
+        self.plateau = plateau
+        self.colonnesBase = {}
+        self.createWidgets()
+        self.positionDansHistoJets = 0
+        self.histoJets = [QString.fromUtf8("")]
+        self.majEnCours = False
+        
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_gestionCombat()
+        self.ui.setupUi(self)
+
+        self.majListesDeroulantes()
+        self.ui.jetDes.installEventFilter(self)
+        #selection
+        self.connect(self.ui.selectionPionEnCours, SIGNAL("clicked()"), self.selection)
+        self.connect(self.ui.selectionAttaquant, SIGNAL("clicked()"), self.selection)
+        self.connect(self.ui.selectionDefenseur, SIGNAL("clicked()"), self.selection)
+        #jet de des
+        self.connect(self.ui.jetDes, SIGNAL("returnPressed()"), self.jetDes)
+##        self.connect(self.ui.jetDes, SIGNAL("keyPressEvent()"), self.jetDesToucheEnfoncee)
+        self.connect(self.ui.validerJetDes, SIGNAL("clicked()"), self.jetDes)
+        self.connect(self.ui.majChamp, SIGNAL("clicked()"), self.majChamp)
+        self.connect(self.ui.afficherDetailDes, SIGNAL("stateChanged(int)"), self.majAffichageDetailDes)
+        
+        #autre
+        self.connect(self.ui.listePions.horizontalHeader(), SIGNAL("sectionClicked(int)"), self.enTeteCliquee)
+        self.connect(self.ui.gestionCombatAide, SIGNAL("clicked()"), self.afficherAide)
+        self.connect(self.ui.masquerHorsCombat, SIGNAL("stateChanged(int)"), self.majFiltreHorsCombat)
+        
+        self.initListe()
+        self.majListe()
+        
+        self.connect(self.ui.listePions, SIGNAL("cellChanged(int, int)"), self.celluleModifiee)
+
+    def majListesDeroulantes(self):
+        """remplit les listes deroulantes des champs a mettre a jour"""
+        self.ui.nomChampMaj.addItem(QString.fromUtf8("Jet(s) de des"), "D")
+        self.ui.nomChampSourceMaj.addItem(QString.fromUtf8("Jet(s) de des"), "D")
+        for elt in regles.ordreAttributs():
+            if regles.listeControle()[elt].typ == "entier":
+                self.ui.nomChampMaj.addItem(QString.fromUtf8(regles.listeControle()[elt].nom), regles.ordreAttributs().index(elt))
+                self.ui.nomChampSourceMaj.addItem(QString.fromUtf8(regles.listeControle()[elt].nom), regles.ordreAttributs().index(elt))
+        self.ui.nomChampMaj.setCurrentIndex(1)
+
+    def enTeteCliquee(self, colonne):
+        """clic sur l'en-tete de la colonne"""
+        if colonne >= 20:    #ne s'applique pas aux colonnes de base (a part Des)
+            attribut = regles.ordreAttributs()[(colonne-20)]
+            index = self.ui.nomChampMaj.findData((colonne-20))
+            if index >= 0:
+                self.ui.nomChampMaj.setCurrentIndex(index)
+        elif colonne == self.colonnesBase.index("Des"):
+            self.ui.nomChampMaj.setCurrentIndex(0)      
+
+    def initListe(self):
+        """formate la table des donnees"""
+        #mise en forme des colonnes
+        #le dico des colonnes de base (celles qui ne dependent pas des regles utilisees) contient:
+        #nom, largeur, (est modifiable?)
+        self.ui.listePions.setEditTriggers(QAbstractItemView.DoubleClicked)
+        self.ui.listePions.setIconSize(QSize(20,20))
+        self.colonnesBase = ["num","I","Des","DetailDes","Pion","Ordre","Etat","Alt.","Notes"]
+        largeurColonnesBase = {"num": 0, "I": 20, "Des": 40, "DetailDes": 60, "Pion": 80,"Ordre": 40, "Etat": 60,"Alt.": 30,"Notes": 80}
+
+        for i in range(0, 20):
+            self.ui.listePions.insertColumn(i)
+            self.ui.listePions.setColumnHidden(i, (i >= len(self.colonnesBase)))
+            if i < len(self.colonnesBase):
+                self.ui.listePions.setHorizontalHeaderItem(i, QTableWidgetItem(self.colonnesBase[i]))
+                if self.colonnesBase[i] in largeurColonnesBase:
+                    largeur = largeurColonnesBase[self.colonnesBase[i]]
+                else:
+                    largeur = 60
+                if largeur > 0:    
+                    self.ui.listePions.setColumnWidth(i, largeur)
+                else:    
+                    self.ui.listePions.setColumnHidden(i, True)
+        self.majAffichageDetailDes()            
+
+        ordre = regles.ordreAttributs()
+        for elt in ordre:
+            numCol = 20 + ordre.index(elt)
+            self.ui.listePions.insertColumn(numCol)
+            self.ui.listePions.setHorizontalHeaderItem(numCol, QTableWidgetItem(QString.fromUtf8(elt)))
+            self.ui.listePions.setColumnWidth(numCol, 45)
+            self.ui.listePions.setColumnHidden(numCol, False)
+            if elt == regles.attributOrdreJeu():
+                self.ui.listePions.setColumnHidden(self.colonnesBase.index("Ordre"), True)   #si un attribut sert a definir l'ordre, on cache la colonne ordre de jeu
+
+            
+    def majListe(self):
+        """met a jour le contenu de la table des donnees"""
+        self.majEnCours = True
+        while self.ui.listePions.rowCount() > 0:
+            self.ui.listePions.removeRow(0)
+        index = 0
+
+        for num in self.plateau.pions:
+            self.ui.listePions.insertRow(int(index))
+            #num du pion (0):
+            self.ui.listePions.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(str(num))))
+            self.majDonneesPion(num)
+            index += 1
+
+        for elt in regles.ordreAttributs():    
+            if elt == regles.attributOrdreJeu():
+                self.plateau.majOrdreJeu()
+                self.majTri()
+                     
+        self.majEnCours = False
+
+    def majDonneesPion(self, numPion):
+        """met a jour les donnees du pion"""
+        index = None
+        for i in range(0, self.ui.listePions.rowCount()):
+            if int(self.ui.listePions.item(i, 0).text().toUtf8()) == numPion:
+                index = i
+                break
+            
+        if index != None:
+            ### parametres de base
+            #I - Indication sur le pion (attaquant, defenseur, selectionne sur la plateau...etc)
+            item = QTableWidgetItem()
+            item.setFlags(Qt.NoItemFlags)
+            item.setFlags(Qt.ItemIsSelectable)
+            if numPion == self.plateau.numPionEnCours:
+                item.setIcon(QIcon("img\\flecheDroite2.png"))
+            if item != None:
+                self.ui.listePions.setItem(index, self.colonnesBase.index("I"), item)
+            
+            #Des et DetailDes - jets de des, on laisse tel quel
+            self.ui.listePions.setItem(index, self.colonnesBase.index("Des"), QTableWidgetItem(QString.fromUtf8("")))
+            self.ui.listePions.setItem(index, self.colonnesBase.index("DetailDes"), QTableWidgetItem(QString.fromUtf8("")))
+                                    
+            #Icone et nom
+            item = QTableWidgetItem(QIcon("img\\"+self.plateau.pions[numPion].creature.logo), \
+                                    QString.fromUtf8(self.plateau.pions[numPion].txtId()))
+            self.ui.listePions.setItem(index, self.colonnesBase.index("Pion"), item)
+            
+            #Ordre
+            self.ui.listePions.setItem(index, self.colonnesBase.index("Ordre"), QTableWidgetItem(QString.fromUtf8(str(self.plateau.ordreJeu[numPion]))))
+
+            #Etat
+            #...
+
+            #altitude
+            self.ui.listePions.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.pions[numPion].z))))
+
+            ### parametres supplementaires (issus des regles)
+            for elt in self.plateau.pions[numPion].lstCarac:
+                col = 20 + regles.ordreAttributs().index(elt)
+                self.ui.listePions.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.plateau.pions[numPion].lstCarac[elt]))))
+        else:
+            print ("Pion {} introuvable, impossible de maj".format(numPion))
+ 
+        
+    def celluleModifiee(self, ligne, colonne):
+        """une cellule de la table a ete modifiee"""
+        if not self.majEnCours:
+            numPion = int(self.ui.listePions.item(ligne, 0).text().toUtf8())
+            
+            if colonne < len(self.colonnesBase):
+                if colonne == self.colonnesBase.index("Ordre"):
+                    #ordre de jeu
+                    nouvellePosition = int(self.ui.listePions.item(ligne, colonne).text().toUtf8())
+                    if nouvellePosition < 1: nouvellePosition = 1
+                    self.plateau.pionDeplacerDansOrdreJeu(numPion, nouvellePosition)
+                    self.majListe()
+                    
+                elif colonne == self.colonnesBase.index("Des"):
+                    #jet de de
+                    self.majEnCours = True
+                    if len(str(self.ui.listePions.item(ligne, colonne).text().toUtf8())) > 0:
+                        resultat = jet(str(self.ui.listePions.item(ligne, colonne).text().toUtf8()))[0]
+                        self.ui.listePions.item(ligne, colonne).setText(QString.fromUtf8(str(resultat)))
+                    else:
+                        self.ui.listePions.item(ligne, colonne).setText(QString.fromUtf8(""))   
+                    self.majEnCours = False
+
+            elif colonne >= 20:
+                self.majEnCours = True
+                index = colonne - 20
+                attribut = regles.ordreAttributs()[index]
+                valeurAttribut = regles.listeControle()[attribut].controler(str(self.ui.listePions.item(ligne, colonne).text().toUtf8()))
+                if valeurAttribut != None:
+                    self.plateau.pions[numPion].lstCarac[attribut] = valeurAttribut
+                    if attribut == regles.attributOrdreJeu():
+                        self.plateau.majOrdreJeu()
+                        self.majTri()
+                else:
+                    self.ui.listePions.item(ligne, colonne).setText(QString.fromUtf8(str(self.plateau.pions[numPion].lstCarac[attribut])))
+                self.majEnCours = False
+                
+            self.emit(SIGNAL("majListesPions"), numPion)                        
+
+    def majTri(self):
+        """met a jour le tri en fonction de la colonne ordreJeu """
+        for i in range(0,self.ui.listePions.rowCount()):
+            self.ui.listePions.setItem(i, self.colonnesBase.index("Ordre"), \
+                                       QTableWidgetItem(str(self.plateau.ordreJeu[int(str(self.ui.listePions.item(i,0).text().toUtf8()))])))
+        trierTable(self.ui.listePions, self.colonnesBase.index("Ordre"))
+
+    def jetDes(self):
+        """jette les des en fonction de ce qui est tape dans jetDes, et affecte les resultats a la colonne D des lignes selectionnees"""
+        jetCommun = None
+        
+        for i in range(0, self.ui.listePions.rowCount()):
+            self.ui.listePions.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(""))
+        if estJetValide(str(self.ui.jetDes.text().toUtf8())):    
+            if not self.ui.jetDesIndependants.isChecked() and len(str(self.ui.jetDes.text().toUtf8())) > 0:
+                jetCommun = jet(str(self.ui.jetDes.text().toUtf8()))
+                
+            for i in range(0, self.ui.listePions.rowCount()):
+                self.ui.listePions.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(""))
+                if len(str(self.ui.jetDes.text().toUtf8())) > 0:
+                    if self.ui.listePions.isItemSelected(self.ui.listePions.item(i, 0)):
+                        if not jetCommun == None:
+                            resultat = jetCommun
+                        else:    
+                            resultat = jet(str(self.ui.jetDes.text().toUtf8()))
+                        if resultat[0] != None:    
+                            self.ui.listePions.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(str(resultat[0])))
+                            self.ui.listePions.item(i, self.colonnesBase.index("DetailDes")).setText(QString.fromUtf8(str(resultat[1])))
+            self.histoJets.insert(1, self.ui.jetDes.text().toUtf8())
+        else:
+            print "Jet de des invalide"
+        self.positionDansHistoJets = 0    
+        self.ui.jetDes.setText(QString.fromUtf8(""))
+
+    def afficherJetHisto(self):
+        """affiche le jet depuis l'historique dans la qlineedit dediee"""
+        if len(self.histoJets) > 0:
+            if self.positionDansHistoJets < 0:
+                self.positionDansHistoJets = 0
+            elif self.positionDansHistoJets >= len(self.histoJets):
+                self.positionDansHistoJets = len(self.histoJets) - 1 
+            self.ui.jetDes.setText(QString.fromUtf8(self.histoJets[self.positionDansHistoJets]))
+            
+    def selection(self):
+        """selectionne les lignes demandees"""
+        origine = str(self.sender().objectName())
+        for i in range(0, self.ui.listePions.rowCount()):
+            if origine == "selectionPionEnCours":
+                self.ui.listePions.item(i, 0).setSelected((int(self.ui.listePions.item(i, 0).text().toUtf8()) == self.plateau.numPionEnCours))
+            elif origine == "selectionAttaquant":
+                pass
+            elif origine == "selectionDefenseur":
+                pass
+            if self.ui.listePions.item(i, 0).isSelected():
+                self.ui.listePions.setCurrentCell(i, 0)
+                
+    def majChamp(self):
+        """met a jour le champ demande avec les resultats de des ou avec les valeurs du champ specifie"""
+        self.majEnCours = True
+        aMaj = []   #liste des numPions a mettre a jour
+        cible = str(self.ui.nomChampMaj.itemData(self.ui.nomChampMaj.currentIndex()).toString())
+        
+        if cible == "D":
+            colonne = self.colonnesBase.index("Des")
+        else:
+            colonne = 20 + int(cible)
+
+        source = str(self.ui.nomChampSourceMaj.itemData(self.ui.nomChampSourceMaj.currentIndex()).toString())
+        if source != "D" and not len(self.ui.listePions.selectedItems()) > 0:
+            msgBox = QMessageBox()
+            msgBox.setWindowTitle(QString.fromUtf8("Avertissement"))
+            msgBox.setText(QString.fromUtf8("Aucune ligne n'est sélectionnée"))
+            msgBox.exec_()
+        else:
+            for i in range(0, self.ui.listePions.rowCount()):
+                if len(str(self.ui.listePions.item(i, self.colonnesBase.index("Des")).text().toUtf8())) > 0:
+                    valeur = int(self.ui.listePions.item(i, colonne).text().toUtf8())
+                    jet = None
+                    try:
+                        if source == "D" and cible != "D":
+                            jet = int(str(self.ui.listePions.item(i, self.colonnesBase.index("Des")).text().toUtf8()))
+                        elif source != cible:
+                            if self.ui.listePions.item(i, 0).isSelected():
+                                jet = int(str(self.ui.listePions.item(i, (20 + int(source))).text().toUtf8()))
+                    except:
+                        print("jet invalide")
+                        
+                    if jet != None:    
+                        if self.ui.majValeurAjouter.isChecked():
+                            valeur += jet
+                        elif self.ui.majValeurRetirer.isChecked():
+                            valeur -= jet      
+                        elif self.ui.majValeurRemplacer.isChecked():
+                            valeur = jet
+                        aMaj.append(i)
+                        self.ui.listePions.item(i, colonne).setText(QString.fromUtf8(str(valeur)))    
+            self.majEnCours = False
+            
+            for ligne in aMaj:
+                self.celluleModifiee(ligne, colonne)
+            self.ui.nomChampSourceMaj.setCurrentIndex(0)
+        
+    def afficherAide(self):
+        pass
+
+    def majFiltreHorsCombat(self):
+        pass
+
+    def majAffichageDetailDes(self):
+        """affiche ou cache la colonne de detail des jets de des en fonction de l'etat de la case correspondante"""
+        self.ui.listePions.setColumnHidden(self.colonnesBase.index("DetailDes"), (not self.ui.afficherDetailDes.isChecked()))
+
+    def eventFilter(self, item, event):
+        """filtre les evenements sur les widgets"""
+        retour = False
+        if item == self.ui.jetDes:
+            if event.type() == QEvent.KeyPress:
+                if event.key() == Qt.Key_Up:
+                    self.positionDansHistoJets += 1
+                    self.afficherJetHisto()
+                    retour = True
+                elif event.key() == Qt.Key_Down:
+                    self.positionDansHistoJets -= 1
+                    self.afficherJetHisto()
+                    retour = True
+        return retour

lib/EditionForme.py

@@ -0,0 +1,198 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+class VueEditionForme(QGraphicsScene):
+    """vue graphique permettant d'afficher et de modifier la forme des creatures/decors"""
+    def __init__(self, fenetre, formeCases="H", parent=None):   
+        super(VueEditionForme, self).__init__()
+        self.fenetre = fenetre
+        self.pixGraphique = None
+        self.text = None
+        self.largeurOriginale = 0
+        self.hauteurOriginale = 0
+        self.rotation = 0
+        self.cases = {}
+        self.formeCases = formeCases
+
+    def creer(self):
+        #cree les cases hexagonales
+        for x in range(-5,6):
+            for y in range(-5,6):
+                if self.formeCases == "H":
+                     if 1 == (x % 2):
+                          y += 0.5
+                c = CaseEditionForme(self)
+                c.creer(x, y, self.formeCases)
+                self.cases[(x,y)] = c
+                
+        self.fenetre.ui.vueForme.setScene(self)    
+        self.fenetre.ui.vueForme.centerOn(self.fenetre.ui.vueForme.mapFromScene(QPointF(60,60)))   #centre la vue sur la case 0,0
+        self.fenetre.ui.vueForme.scale(0.25, 0.25)
+        
+
+    def formeDef(self):
+        """liste definissant la forme"""
+        retour = []
+        for coord in self.cases:
+            if self.cases[coord].estSelectionnee and coord != (0,0):
+                retour.append(coord)      
+        return retour        
+
+    def majForme(self, formeDef):
+        """met a jour la forme sur le graphique"""
+        if formeDef:
+            for coord in formeDef:
+                if coord in self.cases:
+                    self.cases[coord].estSelectionnee = True
+                    self.cases[coord].setBrush(QColor("red"))
+
+    def majTexte(self, txt, taillePolice = 20, gras = False, dx = 0, dy = 0, rotation = 0):
+        if len(txt) > 0:
+            if not self.text:
+                self.text = QGraphicsSimpleTextItem()
+                self.addItem(self.text)
+            self.text.setText(QString.fromUtf8("1."+txt))
+            self.text.setPos(QPointF(dx-0.112*120, dy-0.275*120))
+            police = QFont("Georgia", taillePolice)
+            police.setBold(gras)
+            self.text.setFont(police)
+            self.text.setRotation(rotation)
+        else:
+            if self.text:
+                self.removeItem(self.text)
+
+    def majImage(self, img, kx = 10, ky = 10, dx = 0, dy = 0, rotation = 0, imgPivote = False, masqueAuto = False):
+        if len(img) > 0:
+            pix = QPixmap(QString.fromUtf8("img\\"+img))
+            if not pix.isNull():
+                if masqueAuto == True:
+                    pix.setMask(pix.createHeuristicMask())
+                if not self.pixGraphique:
+                    self.pixGraphique = QGraphicsPixmapItem()
+                    self.addItem(self.pixGraphique)
+                    self.pixGraphique.setZValue(10)
+                    if pix.height() >= pix.width():
+                        pix = pix.scaledToHeight(120*0.9, Qt.SmoothTransformation)
+                    else:
+                        pix = pix.scaledToWidth(120*0.9, Qt.SmoothTransformation)
+                    self.largeurOriginale = pix.width()
+                    self.hauteurOriginale = pix.height()    
+
+                pix = pix.scaled((kx/10)*self.largeurOriginale, (ky/10)*self.hauteurOriginale, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+                deltaX = dx + 0.5*(120*1.1544 - self.largeurOriginale)
+                deltaY = dy + 0.5*(120 - self.hauteurOriginale)
+      
+                self.pixGraphique.setPixmap(pix)    
+                self.pixGraphique.setPos(QPointF(deltaX, deltaY))
+                self.pixGraphique.setRotation(rotation)
+        else:
+            if self.pixGraphique:
+                self.removeItem(self.pixGraphique)
+
+    def majSelection(self, coord):
+         """met a jour l'affichage des cases selectionnees pour l'affichage de la forme"""
+         if self.cases[coord].estSelectionnee == True:
+             self.cases[coord].estSelectionnee = False
+             valide = True
+             for coordVerif in self.cases:
+                 #on parcourt les autres cases selectionnees
+                 if coordVerif != (0,0) and coordVerif != coord and self.cases[coordVerif].estSelectionnee == True:
+                     #on liste les cases connectees a cette case, de proche en proche
+                     connectees = [coordVerif]
+                     for coordVerif2 in connectees:
+                         for coordVoisin in self.cases[coordVerif2].voisins:
+                             if coordVoisin in self.cases and not coordVoisin in connectees:
+                                 if self.cases[coordVoisin].estSelectionnee:
+                                     connectees.append(coordVoisin)
+                     if not (0,0) in connectees:
+                         valide = False
+                         break
+             if valide == True:        
+                 self.cases[coord].setBrush(QColor("white"))
+             else:
+                 self.cases[coord].estSelectionnee = True
+         else:
+             #on s'assure que la case est bien adjacente a une case selectionnee
+             valide = False
+             for coordVerif in self.cases[coord].voisins:
+                if coordVerif in self.cases:
+                    if self.cases[coordVerif].estSelectionnee == True:
+                        valide = True
+                        break
+             if valide:
+                 self.cases[coord].estSelectionnee = True
+                 self.cases[coord].setBrush(QColor("red"))
+
+class CaseEditionForme(QGraphicsPolygonItem):
+    """case utilisee dans une VueEditionForme()"""
+    def __init__(self, vueForme, parent=None):
+        super(CaseEditionForme, self).__init__()
+        self.vue = vueForme
+        self.position = (0,0)
+        self.estSelectionnee = False
+        self.voisins = []
+        
+        #interactions graphiques
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.setAcceptHoverEvents(True)
+        #self.setAcceptDrops(True)
+
+    def creer(self, x, y, formeCases="H"):
+        """creation du polygone et enregistrement des donnees geometriques"""
+        self.position = (x, y)
+        polygone = QPolygonF()
+        if self.vue.formeCases == "H":
+            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)          
+        self.setPolygon(polygone)
+
+        #enregistrement des cases voisines:       
+        if self.vue.formeCases == "H":
+            self.voisins.append((x, y+1))
+            self.voisins.append((x, y-1))
+            self.voisins.append((x-1, y+0.5))
+            self.voisins.append((x-1, y-0.5))
+            self.voisins.append((x+1, y+0.5))
+            self.voisins.append((x+1, y-0.5))
+        else:
+            self.voisins.append((x,   y-1))
+            self.voisins.append((x,   y+1))
+            self.voisins.append((x-1, y))
+            self.voisins.append((x+1, y))
+
+        #pour afficher les coordonnees des cases:        
+        #text = QGraphicsSimpleTextItem("{}-{}".format(x,y), parent=self)
+        #police = QFont()
+        #police.setPointSize(20)
+        #text.setFont(police)
+        #text.setPos(QPointF(((x*0.866)+0.2886)*120,  y*120))
+
+        #couleur de fond par defaut
+        if self.position == (0, 0):
+            self.setBrush(QColor("purple"))
+            self.estSelectionnee = True
+        else:    
+            self.setBrush(QColor("white"))
+        #creation de l'objet graphique sur le plateau
+        self.vue.addItem(self)
+
+    def mousePressEvent(self, event):
+        """evenement lors du clic souris"""
+        super(CaseEditionForme, self).mousePressEvent(event)
+        if event.button() == 1: #sur clic gauche
+            if self.position != (0, 0):
+                self.vue.majSelection(self.position)             

lib/EntreeSortie.py

@@ -0,0 +1,78 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+
+
+class EntreeSortie(QGraphicsPolygonItem):
+    """marqueur d'entree sortie du plateau"""
+    def __init__(self, plateau, entreeSortie = "", parent=None):
+        """initialisation de la fenetre"""
+        super (EntreeSortie, self).__init__()
+        self.plateau = plateau
+        self.entreeSortie = entreeSortie
+        self.position = QPointF(0,0)
+        self.nbRotations = 0
+        self.prepareGeometryChange()
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        
+
+    def __getstate__(self):
+        state = {key:value for key, value in self.__dict__.items() if key in ["entreeSortie", "position", "nbRotations"]}
+        return (state)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+    
+    def creerForme(self):
+        """cree le polygone graphique"""
+        polygone = QPolygonF()
+        polygone << QPointF(60,0) \
+                 << QPointF(-60,60) \
+                 << QPointF(-60,-60)
+        if self.entreeSortie == "E":
+            couleur = QColor("green")
+            self.txtEtiquette = "Entree"
+        elif self.entreeSortie == "S":
+            couleur = QColor("red")
+            self.txtEtiquette = "Sortie"
+        if couleur.isValid():
+            self.setBrush(couleur)
+            self.setPen(QPen(couleur))
+        self.setPolygon(polygone)
+        self.setOpacity(0.5)
+        self.setTransformOriginPoint(0,0)
+        self.plateau.fenetre.ui.vuePlateau.fitInView(self.plateau.sceneRect(), Qt.KeepAspectRatio)
+        self.plateau.addItem(self)
+        
+    def majProjection(self, position = None):
+        """met a jour la projection de la position de l'objet"""
+        if position != None:
+            self.setPos(position)
+            self.position = position
+        self.setRotation(90*self.nbRotations)
+
+    def positionner(self):
+        """la projection est validee, le marqueur est laisse a cette position"""
+        self.setOpacity(1)
+
+    def recreer(self, plateau):
+        """recreation et repositionnement dans le cadre d'un chargement du plateau"""
+        self.plateau = plateau
+        super(EntreeSortie, self).__init__()
+        self.creerForme()
+        self.setPos(self.position)
+        self.setRotation(self.nbRotations*90)
+        self.setOpacity(1)
+    
+    def mousePressEvent(self, event):
+        event.ignore()
+        if event.button() == 1:
+            if self.plateau.modeActif != "placementEntreeSortie":
+                self.setOpacity(0.5)
+                self.plateau.modeParam["entreeSortie"] = self
+                self.plateau.majMode("placementEntreeSortie")
+                event.accept()

lib/Forme.py

@@ -0,0 +1,137 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+class Forme():
+    """forme a affecter a une creature, decor ou autre..."""
+    def __init__(self, formeCases = "H", parent=None):
+        
+        self.formeDef = []           #coord relatives par rapport a la case (0,0) definissant la forme (vide si forme 1*1)
+        
+        #les anneaux sont utilises pour les rotations (coordonnees relatives a la case centrale)
+        #attention: il est important que les cases soient enregistrees dans le sens de la rotation (sens des aiguilles d'une montre)
+        self.formeCases = formeCases   # "C" ou "H" pour carre ou hexagone        
+
+    def anneau(self, distance=0):
+        """renvoie la liste des cases situees a [distance] cases du centre, dans l'ordre des aiguilles d'une montre"""
+        anneau = {}
+        if self.formeCases == "H":
+             anneau[1] = [(0,-1),(1,-0.5),(1,0.5), \
+                          (0,1),(-1,0.5),(-1,-0.5)]
+             anneau[2] = [(0,-2),(1,-1.5),(2,-1),(2,0),(2,1),(1,1.5), \
+                          (0,2),(-1,1.5),(-2,1),(-2,0),(-2,-1),(-1,-1.5)]
+             anneau[3] = [(0,-3),(1,-2.5),(2,-2),(3,-1.5),(3,-0.5),(3,0.5),(3,1.5),(2,2),(1,2.5), \
+                          (0,3),(-1,2.5),(-2,2),(-3,1.5),(-3,0.5),(-3,-0.5),(-3,-1.5),(-2,-2),(-1,-2.5)]
+             anneau[4] = [(0,-4),(1,-3.5),(2,-3),(3,-2.5),(4,-2),(4,-1),(4,0),(4,1),(4,2),(3,2.5),(2,3),(1,3.5), \
+                          (0,4),(-1,3.5),(-2,3),(-3,2.5),(-4,2),(-4,1),(-4,0),(-4,-1),(-4,-2),(-3,-2.5),(-2,-3),(-1,-3.5)]
+             anneau[5] = [(0,-5),(1,-4.5),(2,-4),(3,-3.5),(4,-3),(5,-2.5),(5,-1.5),(5,-0.5),(5,0.5),(5,1.5),(5,2.5),(4,3),(3,3.5),(2,4),(1,4.5), \
+                          (0,5),(-1,4.5),(-2,4),(-3,3.5),(-4,3),(-5,2.5),(-5,1.5),(-5,0.5),(-5,-0.5),(-5,-1.5),(-5,-2.5),(-4,-3),(-3,-3.5),(-2,-4),(-1,-4.5)]
+             
+        elif self.formeCases == "C":
+             anneau[1] = [(0,-1),(1,-1),(1,0),(1,1),\
+                          (0,1),(-1,1),(-1,0),(-1,-1)]
+             anneau[2] = [(0,-2),(1,-2),(2,-2),(2,-1),(2,0),(2,1),(2,2),(1,2),\
+                          (0,2),(-1,2),(-2,2),(-2,1),(-2,0),(-2,-1),(-2,-2),(-1,-2)]
+             anneau[3] = [(0,-3),(1,-3),(2,-3),(3,-3),(3,-2),(3,-1),(3,0),(3,1),(3,2),(3,3),(2,3),(1,3),\
+                          (0,3),(-1,3),(-2,3),(-3,3),(-3,2),(-3,1),(-3,0),(-3,-1),(-3,-2),(-3,-3),(-2,-3),(-1,-3)]
+             anneau[4] = [(0,-4),(1,-4),(2,-4),(3,-4),(4,-4),(4,-3),(4,-2),(4,-1),(4,0),(4,1),(4,2),(4,3),(4,4),(3,4),(2,4),(1,4),\
+                          (0,4),(-1,4),(-2,4),(-3,4),(-4,4),(-4,3),(-4,2),(-4,1),(-4,0),(-4,-1),(-4,-2),(-4,-3),(-4,-4),(-3,-4),(-2,-4),(-1,-4)]
+             anneau[5] = [(0,-5),(1,-5),(2,-5),(3,-5),(4,-5),(5,-5),(5,-4),(5,-3),(5,-2),(5,-1),(5,0),(5,1),(5,2),(5,3),(5,4),(5,5),(4,5),(3,5),(2,5),(1,5),\
+                          (0,5),(-1,5),(-2,5),(-3,5),(-4,5),(-5,5),(-5,4),(-5,3),(-5,2),(-5,1),(-5,0),(-5,-1),(-5,-2),(-5,-3),(-5,-4),(-5,-5),(-4,-5),(-3,-5),(-2,-5),(-1,-5)]
+             
+        if distance > 0:
+             retour = anneau[distance]
+        elif distance == 0:
+             retour = anneau
+             
+        return retour
+        
+             
+    def __repr__(self):
+        """renvoie la liste des cases occupees par la forme"""
+        retour = str(self.listeCases((0,0)))
+        return retour
+    
+    def ajouterCase(self, coordRelatives):
+        """ajoute une case a la liste des cases occupees de la forme"""
+        ajoutee = False
+        if not coordRelatives in self.formeDef:
+            for distance in self.anneau(0):
+                if coordRelatives in self.anneau(distance):
+                     self.formeDef.append(coordRelatives)
+                     ajoutee = True
+        if not ajoutee:
+            print("case non prise en charge (trop eloignee du centre)")
+    
+    def definirForme(self, formeDef):
+        """utilise une forme pre-definie"""
+        self.formeDef = []
+        if formeDef:
+            if len(formeDef)>0:
+                for coordRelatives in formeDef:
+                    self.ajouterCase(coordRelatives)
+        
+    def retirerCase(self, coordRelatives):
+        """retire une case a la liste des cases occupees de la forme"""
+        if coordRelatives in self.formeDef:
+            self.formeDef.remove(coordRelatives)    
+
+    def pivoter(self, nbRotations = 1):
+        """pivote si possible la forme dans le sens '+' ou '-' et renvoie la liste des cases qui seront occupees"""
+        sens = 1
+        if nbRotations < 0: sens = -1
+        formeDefPivote = []
+        tmp = self.formeDef
+
+        if self.formeCases == "H":
+            k = 1
+        else:
+            k = 2  #on avance de deux cases sur l'anneau dans le cas de cases carrees
+        
+        if len(self.formeDef) > 0:
+            for i in range(0,abs(nbRotations)):
+                for coord in tmp:
+                    #on trouve dans quel anneau se situe cette case
+                    distance = 0
+                    i = 0
+                    while distance == 0 and i <= len(self.anneau(0)):
+                        i += 1
+                        if coord in self.anneau(i):
+                            distance = i
+                    #si on a trouve la case, on la deplace selon les conditions de la rotation        
+                    if distance > 0:
+                        #position actuelle dans la liste des cases de l'anneau
+                        position = self.anneau(distance).index(coord) 
+
+                        #le pivot entraine un deplacement dans la liste des cases de l'anneau egal a sa distance au centre
+                        nouvellePosition = position + k*sens*distance    
+    
+                        #retour au debut/a la fin de l'anneau si on atteint la fin/ le debut
+                        if nouvellePosition >= len(self.anneau(distance)):   
+                            nouvellePosition -= len(self.anneau(distance))
+                        elif nouvellePosition < 0:
+                            nouvellePosition += len(self.anneau(distance))
+                        
+                        #on retrouve les nouvelles coordonnees relatives a partir de la position dans l'anneau  
+                        nouvellesCoord = self.anneau(distance)[nouvellePosition]
+                        #on ajoute cette position a la nouvelle definition de forme
+                        formeDefPivote.append((nouvellesCoord[0], nouvellesCoord[1]))
+                    else:
+                        print("{} non trouvee dans les anneaux".format(coord))
+                tmp = formeDefPivote
+                formeDefPivote = []
+                
+            formeDefPivote = tmp    
+            return formeDefPivote                     
+
+    def listeCases(self, coordCibles, nbRotations = 0):
+        """renvoie la liste des cases occupees par la forme en cours"""
+        retour = [coordCibles]
+        if nbRotations != 0:
+            formeEnCours = self.pivoter(nbRotations)
+        else:
+            formeEnCours = self.formeDef
+        if len(formeEnCours) > 0:
+            for coordRelatives in formeEnCours:
+                retour.append((coordCibles[0]+coordRelatives[0], coordCibles[1]+coordRelatives[1]))       
+        return retour

lib/Inventaire.py

@@ -0,0 +1,7 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+
+class Inventaire():
+    """inventaire des objets portes par une creature ou un joueur"""
+    def __init__(self):
+        self.liste = {}  #objet: nombre

lib/Objet.py

@@ -0,0 +1,10 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+
+class Objet():
+    """objets tels qu'ils apparaissent dans l'inventaire"""
+    def __init__(self):
+        self.id = ""
+        self.nom = ""
+        self.valeur = 0
+        self.poids = 0

lib/Pion.py

@@ -0,0 +1,363 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from Creature import Creature
+from Forme import Forme
+
+class Pion(QGraphicsItem):
+    """pion du plateau de combat"""
+    def __init__(self, plateau, numero, parent=None):
+        super(Pion, self).__init__()
+        #plateau
+        self.plateau = plateau
+
+        #attributs
+        self.numero = numero
+        self.creature = Creature()
+        self.nom = "pion"
+        self.numTxt = ""
+        self.lstCarac = self.creature.listeCarac()   #caracteristiques par defaut issues des regles utilisees
+        self.position = (-1, -1)
+        self.forme = Forme(self.plateau.formeCases)
+        self.champDeplacement = {}   #dictionnaire des cases jusqu'auquelles le pion peut se deplacer (coordonnees : distance)
+        self.deplacementRestant = 0
+        self.z = 0         #hauteur z par rapport a l'altitude de la case occupee
+        self.hauteur = 1   #nombre de cases occupees en hauteur
+        self.pixGraphique = None
+        self.largeurOriginale = 0
+        self.hauteurOriginale = 0
+        self.polygoneGraphique = None
+        self.nbRotations = 0
+        self.etat = ""
+        self.attaques = []   #liste des attaques pre-parametrees du pion
+        self.notes = ""
+
+
+    def __getstate__(self):
+        self.idCreature = self.creature.id
+        state = {key:value for key, value in self.__dict__.items() if not key in ["plateau", "brillance", "shadow", "creature", \
+                                                                                  "polygonesForme", "pixGraphique"]}
+        return (state)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+        self.creature = charger("librairie\\creature", self.idCreature)
+##        if self.creature == None:   ##############
+            
+    def creer(self, posX, posY, nom, numTxt = "", creature = None, couleur = None, nbRotations = 0):
+        """place le pion sur le plateau"""        
+        #definition de la forme  
+        if creature != None:
+            self.creature = creature  
+            if len(self.creature.formeDef[self.plateau.formeCases]) > 0:
+                self.forme.definirForme(self.creature.formeDef[self.plateau.formeCases])
+            self.attaques = creature.listeAttaques()
+            self.lstCarac = self.creature.listeCarac()
+        else:
+            if couleur != None:
+                if couleur.isValid():
+                    self.creature.couleur = couleur
+                    
+        self.creerPolygone()
+        self.deplacementRestant = self.creature.deplacement
+        
+        self.nom = nom
+        self.numTxt = numTxt
+        
+        #aspect graphique
+        self.majAspectGraphique()
+
+        #ajout de l'objet graphique
+        self.plateau.addItem(self)
+
+        #enregistrement et maj de la position
+        self.majPosition((posX, posY), nbRotations)
+
+    def recreer(self, plateau):
+        """recree le pion (apres un chargement du plateau par ex)"""
+        self.plateau = plateau  
+        super(Pion, self).__init__()
+        self.pixGraphique = None
+        self.polygoneGraphique = None
+        self.creerPolygone()
+        self.majAspectGraphique()
+        self.plateau.addItem(self)
+        self.majPosition(self.position, self.nbRotations)
+
+    def creerPolygone(self):
+        """cree le polygone representant le pion (doit etre cree avant toute rotation)"""
+        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))
+
+    def majAspectGraphique(self):
+        """met a jour l'aspect graphique du pion
+          (seulement les parametres independants de la position et de la forme de l'objet)"""
+        self.setZValue(10)
+           
+        #interactions graphiques
+##        self.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
+        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
+##        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
+        self.setHandlesChildEvents(True)
+
+        #classes graphiques
+        self.brillance = QGraphicsColorizeEffect()
+        self.shadow = QGraphicsDropShadowEffect()
+         
+        #etiquette         
+        self.text = QGraphicsSimpleTextItem("{}. {}".format(self.numero, self.txtId()))
+        self.text.setPos(QPointF(self.creature.txt["dx"]-0.112*self.plateau.hCase, self.creature.txt["dy"]-0.275*self.plateau.hCase))
+        police = QFont("Georgia", self.creature.txt["taille_police"])
+        police.setBold(self.creature.txt["gras"])
+        self.text.setFont(police)
+        self.text.setRotation(self.creature.txt["rotation"])
+        self.text.setParentItem(self)
+
+        #bordure
+        pinceau = QPen()
+        pinceau.setColor(self.creature.couleur.darker(130))
+        pinceau.setWidth(10)
+        self.polygoneGraphique.setPen(pinceau)
+            
+        #couleur de fond 
+        if self.creature.couleur.isValid():
+             self.polygoneGraphique.setBrush(self.creature.couleur)
+        else:
+             self.polygoneGraphique.setBrush(QColor(255, 0, 0, 150))
+        
+        #ombre
+        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)
+
+        #brillance (invisible par defaut, est un polygone semi transparent superpose au pion)
+        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)
+
+    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"""
+        valide = True  
+        if nouvellePosition in self.champDeplacement and self.plateau.modePrincipal == "combat":
+            distanceParcourue = self.champDeplacement[nouvellePosition]
+            if distanceParcourue <= self.deplacementRestant:
+                self.deplacementRestant -= distanceParcourue
+            else:
+                print ("pas assez de points de deplacement")
+                valide = False
+
+        if valide:
+            #on met a jour l'occupation des cases
+            if self.position != (-1,-1):
+                for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
+                    self.plateau.cases[coord].majOccupation(self)
+
+            #on met a jour la position du pion        
+            self.position = nouvellePosition
+            self.majNbRotation(nbRotations)
+
+            #on replace
+            if self.plateau.formeCases == "H":
+                angleRotation = 60
+                positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.position[1] * self.plateau.hCase)
+            else:
+                angleRotation = 90
+                positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
+            self.prepareGeometryChange()
+            self.setPos(positionGraphique)
+            self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)
+            
+            #maj de l'image
+            self.majImage()
+            
+            #on met a jour l'occupation des cases
+            for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
+                 self.plateau.cases[coord].majOccupation(self, self.z)
+   
+    def majImage(self):
+        """met a jour la taille, la position et l'orientation de l'image"""
+        if len(self.creature.img["nom"]) > 0:
+            pix = QPixmap(QString.fromUtf8("img\\"+self.creature.img["nom"]))
+            if self.creature.img["masqueAuto"]:
+                pix.setMask(pix.createHeuristicMask())
+            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.largeurOriginale = pix.width()
+                    self.hauteurOriginale = pix.height()
+                    pix = pix.scaled((self.creature.img["kx"]/10)*pix.width(), \
+                                     (self.creature.img["ky"]/10)*pix.height(), \
+                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+                    self.pixGraphique.setPixmap(pix)
+
+                deltaX = self.creature.img["dx"] + 0.5*(self.plateau.hCase*1.1544 - self.largeurOriginale)
+                deltaY = self.creature.img["dy"] + 0.5*(self.plateau.hCase - self.hauteurOriginale)
+                if self.creature.img["nom"] != self.creature.logo and self.creature.img["pivote"] == True:
+                    self.pixGraphique.setParentItem(self.polygoneGraphique)
+                else:
+                    self.pixGraphique.setParentItem(self)
+                self.pixGraphique.setRotation(self.creature.img["rotation"])
+                self.pixGraphique.setPos(QPointF(deltaX, deltaY))
+
+    def majNbRotation(self, nbRotations):
+        self.nbRotations = nbRotations
+        if self.plateau.formeCases == "H":
+            rotationsTour = 6
+        else:
+            rotationsTour = 4
+            
+        if self.nbRotations >= 0:
+            self.nbRotations = self.nbRotations % rotationsTour
+        else:
+            self.nbRotations = self.nbRotations % (-rotationsTour)
+
+    def afficheOmbreSelection(self, actif = False):
+        if actif:
+            self.shadow.setXOffset(3) 
+            self.shadow.setYOffset(3)
+        else:
+            self.shadow.setXOffset(1) 
+            self.shadow.setYOffset(2)            
+        
+    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) 
+
+    def estCibleAttaque(self, estCible, possible = True):
+        """le pion s'affiche comme etant cible d'une attaque"""
+        if not possible:
+            couleur = "red"
+        else:
+            couleur = "white"
+        self.surbrillance(estCible, 0.8, couleur)
+        
+    def majZ(self, valeur):
+        """met a jour l'altitude Z du pion"""
+        if valeur != self.z:
+            self.z = valeur            
+
+    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:
+            retour = retour.darker(140)
+        elif self.polygoneGraphique.brush().color().lightness() < 80:
+            retour = retour.lighter(140)
+        return retour
+
+    def supprimer(self):
+        """'deconnecte' les items enfants avant de supprimer du pion"""
+        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.text.prepareGeometryChange()
+        self.text.setParentItem(None)
+        self.plateau.removeItem(self)
+        self.plateau = None
+    def boundingRect(self):
+        return QRectF()
+    
+    def hoverEnterEvent(self, event):
+        """evenement lors du survol de la souris (en entree)"""
+        #super(Pion, self).hoverEnterEvent(event)
+        if (self.plateau.pionSelectionne() == None and self.plateau.modeActif == "standard") or self.plateau.modeActif == "pionSupprimer":
+            self.surbrillance(True, 0.4)    
+        self.plateau.pionSurvol(self.numero)
+        event.ignore()
+
+    def hoverLeaveEvent(self, event):
+        """evenement lors du survol de la souris (en entree)"""
+        #super(Pion, self).hoverLeaveEvent(event)
+        self.surbrillance(False)
+        self.plateau.pionSurvol(None)
+
+    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)
+           if accepte: event.accept()
+        else:
+           event.ignore()
+
+    def mouseDoubleClickEvent(self, event):
+        """evenement lors du clic souris"""
+        super(Pion, self).mouseDoubleClickEvent(event)
+        if event.button() == 1: #sur clic gauche
+           accepte = self.plateau.pionDoubleClic(self.numero)
+           if accepte: event.accept()
+        else:
+           event.ignore() 
+    ##################
+
+    ###############   evenements clavier et souris    ##############
+    #*EP
+    def boundingRect(self):
+        return QRectF()
+    
+    def hoverEnterEvent(self, event):
+        """evenement lors du survol de la souris (en entree)"""
+        #super(Pion, self).hoverEnterEvent(event)
+        if (self.plateau.pionSelectionne() == None and self.plateau.modeActif == "standard") or self.plateau.modeActif == "pionSupprimer":
+            self.surbrillance(True, 0.4)    
+        self.plateau.pionSurvol(self.numero)
+        event.ignore()
+
+    def hoverLeaveEvent(self, event):
+        """evenement lors du survol de la souris (en entree)"""
+        #super(Pion, self).hoverLeaveEvent(event)
+        self.surbrillance(False)
+        self.plateau.pionSurvol(None)
+
+    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)
+           if accepte: event.accept()
+        else:
+           event.ignore()
+
+    def mouseDoubleClickEvent(self, event):
+        """evenement lors du clic souris"""
+        super(Pion, self).mouseDoubleClickEvent(event)
+        if event.button() == 1: #sur clic gauche
+           accepte = self.plateau.pionDoubleClic(self.numero)
+           if accepte: event.accept()
+        else:
+           event.ignore()

lib/PionDecor.py

@@ -0,0 +1,241 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from Decor import Decor
+from Forme import Forme
+
+
+
+class PionDecor(QGraphicsItem):
+    """pion du plateau de combat representant un decor"""
+    def __init__(self, plateau, numero, parent=None):
+        super(PionDecor, self).__init__(parent)
+        #plateau
+        self.plateau = plateau    
+
+        #attributs
+        self.nom = "decor"
+        self.numero = numero
+        self.decor = Decor()
+        self.position = (-1, -1)
+        self.forme = Forme(self.plateau.formeCases)
+        self.z = 0
+        self.hauteur = 1   #hauteur de l'objet en cases
+        self.pixGraphique = None
+        self.largeurOriginale = 0
+        self.hauteurOriginale = 0
+        self.polygoneGraphique = None
+        self.nbRotations = 0
+
+    def __getstate__(self):
+        state = {key:value for key, value in self.__dict__.items() if not key in ["plateau", "forme", "polygoneGraphique", "pixGraphique", "shadow"]}
+        return (state)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def paint(self, painter, option, widget = None):
+        """reimplemente de QGraphicsItem"""
+        pass
+
+    def surbrillance(self, active):
+        """active/desactive la surbrillance"""
+        pass
+
+    def txtId(self):
+        return self.nom
+
+    ########### fonctions graphiques et geometriques   ##############
+    def creer(self, posX, posY, decor, nbRotations):
+        """place le pion decor sur le plateau"""        
+        self.decor = decor
+        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
+        self.setHandlesChildEvents(True)
+        
+        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
+            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])
+        self.hauteur = self.decor.hauteur
+        
+        self.position = (posX, posY)
+        self.majNbRotations(nbRotations)
+
+        #aspect graphique
+        self.majAspectGraphique()
+
+        #ajout de l'objet graphique et placement
+        self.plateau.addItem(self)
+
+    def recreer(self, plateau):
+        """recree l'objet graphique apres un chargement"""
+        self.plateau = plateau
+        super(PionDecor, self).__init__()
+        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
+        self.setHandlesChildEvents(True)
+        self.polygoneGraphique = None
+        self.pixGraphique = None
+        self.forme = Forme(self.plateau.formeCases)
+        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
+            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])        
+        #aspect graphique
+        self.majAspectGraphique()
+        #ajout de l'objet graphique et placement
+        self.plateau.addItem(self)
+             
+    def majAspectGraphique(self):
+        """met a jour l'aspect graphique du pion"""
+        #creation de la forme
+        if not self.polygoneGraphique:
+            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))
+                
+        if self.plateau.formeCases == "H":
+            angleRotation = 60
+            positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.position[1] * self.plateau.hCase)
+        else:
+            angleRotation = 90
+            positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
+            
+        self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)    
+        self.setPos(positionGraphique)
+        self.setZValue(10)    #place au dessus des cases
+        
+        #interactions
+        self.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
+
+        #bordure
+        pinceau = QPen()
+        #pinceau.setColor(self.decor.couleur.darker(130))
+        pinceau.setColor(self.decor.couleur)
+        pinceau.setWidth(10)
+        self.polygoneGraphique.setPen(pinceau)
+
+        #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.polygoneGraphique.setGraphicsEffect(self.shadow)
+
+        #maj de l'image
+        self.majImage()
+
+        #fond 
+        if self.decor.couleur.isValid():
+            self.polygoneGraphique.setBrush(self.decor.couleur)
+        else:
+            self.polygoneGraphique.setBrush(QColor(255, 0, 0, 100))
+
+        #on met a jour l'occupation des cases
+        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
+            self.plateau.cases[coord].majOccupation(self, self.z)
+
+    def majImage(self):
+        """met a jour la taille, la position et l'orientation de l'image"""
+        if len(self.decor.img["nom"]) > 0:
+            pix = QPixmap(QString.fromUtf8("img\\"+self.decor.img["nom"]))
+            if self.decor.img["masqueAuto"]:
+                pix.setMask(pix.createHeuristicMask())
+            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.largeurOriginale = pix.width()
+                    self.hauteurOriginale = pix.height()
+                    pix = pix.scaled((self.decor.img["kx"]/10)*pix.width(), \
+                                     (self.decor.img["ky"]/10)*pix.height(), \
+                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+                    self.pixGraphique.setPixmap(pix)
+
+                deltaX = self.decor.img["dx"] + 0.5*(self.plateau.hCase*1.1544 - self.largeurOriginale)
+                deltaY = self.decor.img["dy"] + 0.5*(self.plateau.hCase - self.hauteurOriginale)
+                if self.decor.img["nom"] != self.decor.logo and self.decor.img["pivote"] == True:
+                    self.pixGraphique.setParentItem(self.polygoneGraphique)
+                else:
+                    self.pixGraphique.setParentItem(self)
+                self.pixGraphique.setRotation(self.decor.img["rotation"])
+                self.pixGraphique.setPos(QPointF(deltaX, deltaY))            
+
+    def majNbRotations(self, nbRotations):
+        self.nbRotations = nbRotations
+        if self.plateau.formeCases == "H":
+            rotationsTour = 6
+        else:
+            rotationsTour = 4
+            
+        if self.nbRotations >= 0:
+            self.nbRotations = self.nbRotations % rotationsTour
+        else:
+            self.nbRotations = self.nbRotations % (-rotationsTour)
+
+    def majPosition(self, position, nbRotations = 0):
+        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
+            self.plateau.cases[coord].majOccupation(self)
+        self.position = position
+        self.majNbRotations(nbRotations)
+        self.majAspectGraphique()
+        
+    def afficheOmbreSelection(self, actif = False):
+        if actif:
+            self.shadow.setXOffset(3) 
+            self.shadow.setYOffset(3)
+        else:
+            self.shadow.setXOffset(1) 
+            self.shadow.setYOffset(2)  
+
+    def supprimer(self):
+        """'deconnecte' les items enfants avant de supprimer du pion"""
+        if self.pixGraphique != None:
+            self.pixGraphique.prepareGeometryChange()
+            self.pixGraphique.setParentItem(None)
+        self.polygoneGraphique.prepareGeometryChange()
+        self.polygoneGraphique.setParentItem(None)
+        self.plateau.removeItem(self)
+        self.plateau = None
+
+    ##################
+
+    ###############   evenements clavier et souris    ##############         
+    def boundingRect(self):
+        return QRectF()
+
+    def hoverEnterEvent(self, event):
+        """evenement lors du survol de la souris (en entree)""" 
+        self.plateau.caseSurvol(self.plateau.cases[self.position])
+        self.plateau.pionDecorSurvol(self.numero)
+
+    def hoverLeaveEvent(self, event):
+        """evenement lors du survol de la souris (en sortie)"""
+        self.plateau.pionDecorSurvol(None)
+
+    def mousePressEvent(self, event):
+        """evenement lors du clic souris"""
+        if event.button() == 1: #sur clic gauche  
+            #en mode creation, on peut selectionner le decor pour le deplacer ou le supprimer
+            if self.plateau.modePrincipal == "creation":
+                 self.plateau.pionDecorSaisir(self.numero)
+                 event.accept()
+        else:
+            event.ignore()            
+            
+    
+    #######################

lib/Plateau.py

@@ -0,0 +1,2451 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+from sys import exit, argv, getsizeof, settrace
+from time import time, sleep, strftime, localtime
+from threading import Thread
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from PyQt4 import QtOpenGL
+
+from ui.ecran_editionTerrain import Ui_editionTerrain
+from ui.ecran_editionCreature import Ui_editionCreature
+from ui.ecran_editionDecor import Ui_editionDecor
+
+from ui.ecran_gestionCombat import Ui_gestionCombat
+from ui.ecran_editionAttaques import Ui_editionAttaques
+from ui.ecran_affichageTexte import Ui_affichageTexte
+
+from Case import Case
+from Pion import Pion
+from PionDecor import PionDecor
+
+from Cache import Cache
+from EntreeSortie import EntreeSortie
+
+
+import regles as regles
+from outilsSvg import *
+from lancer import jet, estJetValide
+
+from operator import itemgetter, attrgetter
+from math import *
+
+
+        
+class Plateau(QGraphicsScene):
+    """plateau de jeu contenant les cases, decors et pions"""
+    def __init__(self, fenetre, parent=None):
+        super(Plateau, self).__init__()
+        #parametres et variables
+        self.id = ""
+        self.nom = ""
+        self.chapitre = 0
+        self.fenetre = fenetre
+        self.nbCasesX = 0
+        self.nbCasesY = 0
+        self.hCase = 0
+        self.cases = {}   #dict des cases du plateau   (coordonnées: case)
+        self.pions = {}   #liste de pions positionnes sur le plateau
+        self.decors = {}  #liste des decors places sur le plateau
+        self.ordreJeu = {}  #numero du pion: ordre de jeu
+        self.numPionEnCours = 0
+        self.tour = 1
+        self.cacheEnCours = 1
+        self.caches = {}
+        self.polygonesCaches = {}
+        for i in range(1,5):
+            self.caches[i] = {"actif":False,"listeCases":[]}
+            self.polygonesCaches[i] = None
+            
+        self.listeCasesZonePlacement = []
+        self.polygoneZonePlacement = None
+        self.entreesSorties = []
+        self.modePrincipal = "creation"
+        self.modeActif = ""
+        self.modeCombat = ""
+        self.nbZoomActuel = 0
+        self.epaisseurpinceau = 0
+        self.enCours = False
+        self.public = False
+        self.dateCreation = ""
+        self.dateSvg = ""
+        self.notes = ""
+        
+        #note: la hauteur Z (qui gere l'empilement des objets graphiques est distribuee de cette maniere:
+        #cases : 0 a 9
+        #pions : 10 et +
+        
+    def __getstate__(self):
+        self.dateSvg = time()
+        state = {key:value for key, value in self.__dict__.items() if not key in ["fenetre", "modeActif", "listMode", "cacheEnCours", \
+                                                                                  "modeParam", "nbZoomActuel", "epaisseurPinceau", \
+                                                                                  "editionTerrain", "editionCreature", "editionDecor", \
+                                                                                  "polygoneZonePlacement", "gestionCombat", "polygonesCaches", \
+                                                                                  "editionAttaques"]}
+        return (state)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def creer(self, idPlateau, nom, chapitre, formeCases, nbCasesX, nbCasesY, couleur = QColor(0, 255, 0, 80)):
+        """cree le plateau"""
+        self.id = idPlateau
+        self.nom = nom
+        self.chapitre = chapitre
+        self.dateCreation = time()
+        self.hCase = 120  #hauteur d'une case
+        self.nbCasesX = nbCasesX   #nb cases en x
+        self.nbCasesY = nbCasesY   #nb cases en y
+        self.formeCases = formeCases
+        self.gestionCombat = None
+        self.initialisationGraphique()
+        self.connexions()
+        
+        #cree les cases hexagonales
+        for x in range(nbCasesX):
+            for y in range(nbCasesY):
+                if formeCases == "H":
+                     if 1 == (x % 2):
+                          y += 0.5
+                c = Case(self)
+                c.creer(x, y, couleur)
+                self.cases[(x,y)] = c
+                
+
+    def recreer(self, fenetre):
+        self.fenetre = fenetre
+        self.gestionCombat = None
+        super(Plateau, self).__init__()
+        self.connexions()
+
+        self.initialisationGraphique() 
+
+        #recreation des cases 
+        for coord in self.cases:
+            self.cases[coord].recreer(self)
+
+        #recreation des pions
+        for numPion in self.pions:
+            self.pions[numPion].recreer(self)
+        self.majOrdreJeu()    
+
+        #recreation des decors
+        for num in self.decors:
+            self.decors[num].recreer(self)
+
+        #recreation des marqueurs entree/sortie
+        for entreeSortie in self.entreesSorties:
+            entreeSortie.recreer(self)
+
+        #recreation de la zone de placement: 
+        if len(self.listeCasesZonePlacement) > 0:
+            self.polygoneZonePlacement = None
+            self.majZonePlacement(self.listeCasesZonePlacement)    
+
+        #recreation des caches
+        self.polygonesCaches = {}
+        for i in range(1,5):
+            self.polygonesCaches[i] = None
+
+    def fermer(self):
+        """ferme le plateau 'proprement'"""
+        for item in self.items():
+            item.prepareGeometryChange()
+            self.removeItem(item)
+        if self.gestionCombat != None:    
+            del self.gestionCombat           
+        self.fenetre.reinitialiserPanneauxPlateau()
+
+    def connexions(self):
+        """connecte le plateau aux differents widgets de la fenetre principale"""
+        self.fenetre.connect(self.fenetre.ui.modeCreationPlateau, SIGNAL("clicked()"), self.plateauModeCreation, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.modeCombatPlateau, SIGNAL("clicked()"), self.plateauModeCombat, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.afficherGestionCombat, SIGNAL("clicked()"), self.afficheEcranGestionCombat, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.terrainCouleur, SIGNAL("clicked()"), self.modePeintureCase, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.terrainCopie, SIGNAL("clicked()"), self.modeCopieTerrain, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.pionCouleur, SIGNAL("clicked()"), self.majCouleurPion, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.terrainEdit, SIGNAL("clicked()"), self.terrainEdit, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.terrainNouveau, SIGNAL("clicked()"), self.terrainNouveau, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.creatureEdit, SIGNAL("clicked()"), self.creatureEdit, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.creatureNouveau, SIGNAL("clicked()"), self.creatureNouveau, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.pionSimpleCreer, SIGNAL("clicked()"), self.modeCreationPion, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.pionSupprimer, SIGNAL("clicked()"), self.majModePionSupprimer, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.decorEdit, SIGNAL("clicked()"), self.decorEdit, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.decorNouveau, SIGNAL("clicked()"), self.decorNouveau, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.decorSupprimer, SIGNAL("clicked()"), self.majModePionSupprimer, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.definirEntree, SIGNAL("clicked()"), self.majModeDefinirEntree, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.definirSortie, SIGNAL("clicked()"), self.majModeDefinirSortie, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.definirZonePlacement, SIGNAL("clicked()"), self.majModeZonePlacement, Qt.UniqueConnection)
+
+        self.fenetre.connect(self.fenetre.ui.formeSimple, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeLigne, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeLigneOrientee, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeEllipseVide, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeEllipsePlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeRectVide, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.formeRectPlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
+
+        self.fenetre.connect(self.fenetre.ui.effFeu, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.effEau, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.effGlace, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.effPoison, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.effEffacer, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection)
+
+        self.fenetre.connect(self.fenetre.ui.cacheActif, SIGNAL("clicked()"), self.majEtatCacheEnCours, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.cacheVoir, SIGNAL("clicked()"), self.voirCacheEnCours, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.cachePlacer, SIGNAL("clicked()"), self.placerCacheEnCours, Qt.UniqueConnection)
+
+        self.fenetre.connect(self.fenetre.ui.combatDeplacement, SIGNAL("clicked()"), self.majModeCombatDeplacement, Qt.UniqueConnection)
+        self.fenetre.ui.combatDeplacement.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatAttaqueCaC, SIGNAL("clicked()"), self.majModeCombatAttaqueCaC, Qt.UniqueConnection)
+        self.fenetre.ui.combatAttaqueCaC.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatAttaqueDist, SIGNAL("clicked()"), self.majModeCombatAttaqueDist, Qt.UniqueConnection)
+        self.fenetre.ui.combatAttaqueDist.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatAttaqueZone, SIGNAL("clicked()"), self.fenetre.barreCombatZone, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.combatAttaqueZone, SIGNAL("clicked()"), self.majModeCombatZone, Qt.UniqueConnection)
+        self.fenetre.ui.combatAttaqueZone.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatVol, SIGNAL("clicked()"), self.fenetre.barreCombatVol, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("valueChanged(int)"), self.majZPion, Qt.UniqueConnection)
+        #self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("editingFinished()"), self.majVisibiliteBarreCombat)
+        self.fenetre.connect(self.fenetre.ui.combatZone_ligne, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
+        self.fenetre.ui.combatZone_ligne.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatZone_disque, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
+        self.fenetre.ui.combatZone_disque.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatZone_cone, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection)
+        self.fenetre.ui.combatZone_cone.setCheckable(True)
+        self.fenetre.connect(self.fenetre.ui.combatRetour, SIGNAL("clicked()"), self.fenetre.barreCombatMenu, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.combatPasserTour, SIGNAL("clicked()"), self.pionSuivant, Qt.UniqueConnection)
+        #self.connect(self.ui.combatInventaire, SIGNAL("clicked()"), self.majModePionSupprimer)
+
+        self.fenetre.connect(self.fenetre.ui.modeAffichagePlateau, SIGNAL("currentIndexChanged(int)"), self.majModeAffichage, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.listTerrains, SIGNAL("cellClicked(int,int)"), self.modeMajTerrainCase, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.listCreatures, SIGNAL("cellClicked(int,int)"), self.modeCreationCreaturePion, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.listDecors, SIGNAL("cellClicked(int,int)"), self.modeCreationDecor, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.epaisseurPinceau, SIGNAL("valueChanged(int)"), self.majEpaisseurPinceau, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.altitudeCase, SIGNAL("valueChanged(double)"), self.modeMajAltitudeCase, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.infoOrdreJeu, SIGNAL("cellClicked(int,int)"), self.clicListOrdreJeu, Qt.UniqueConnection)
+        
+        self.fenetre.connect(self.fenetre.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.editerAttaques, SIGNAL("clicked()"), self.afficheEcranEditionAttaques, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.notesPion, SIGNAL("textChanged()"), self.majNotesPion, Qt.UniqueConnection)
+
+        self.fenetre.connect(self.fenetre.ui.notesMjPlateau, SIGNAL("textChanged()"), self.majNotesPlateau, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.agrandirNotesMjPlateau, SIGNAL("clicked()"), self.agrandirNotesMjPlateau, Qt.UniqueConnection)
+        
+
+    def initialisationGraphique(self):
+        """cree la scene graphique et les parametres necessaires a son fonctionnement, et met a jour l'interface""" 
+        #on cree la scene graphique
+        kx = 1
+        if self.formeCases == "H":
+            kx = 0.866
+        marge = 240    
+        self.setSceneRect(0 - marge, 0 - marge, (kx*self.hCase*(self.nbCasesX+2)) + marge, (self.hCase*(self.nbCasesY+2)) + marge)
+        self.fenetre.ui.vuePlateau.setScene(self)
+        self.fenetre.ui.vuePlateau.scale(0.25, 0.25)
+        self.fenetre.ui.vuePlateau.centerOn(QPointF(0,0))
+        self.fenetre.ui.vuePlateau.setDragMode(1)
+        self.setItemIndexMethod(QGraphicsScene.BspTreeIndex)
+        
+        #self.setItemIndexMethod(QGraphicsScene.NoIndex)
+        self.nbZoomActuel = 0
+        self.epaisseurPinceau = 1
+        self.polygoneZonePlacement = None
+        self.polygonesCaches = {}
+        for i in range(1,5):
+            self.polygonesCaches[i] = None
+
+
+        #gestion du mode d'interaction avec le plateau
+        self.modeActif = "standard"
+        self.listMode = ["standard", "caseMajTerrain", "caseCopie", "caseMajEffet", "caseMajAltitude", "pionCreation", \
+                         "pionSelectionne", "pionDecorCreation", "pionDecorSelectionne", "pionSupprimer", "cachePlacer", \
+                         "combatDeplacement", "combatAttaqueCaC", "combatAttaqueDist", \
+                         "placementEntreeSortie", "majZonePlacement"]
+      
+        self.modeParam = {"terrain": None, "numPionSelectionne": 0, "pionNouveau": None, "creature": None, "decor": None, "effet":"", "couleurPion": QColor("grey"), \
+                          "coordProjectionPosition": (0,0), "formeProjectionPosition": None, "nbRotations": 0, \
+                          "typeFormeDessin": "simple", "formeDessin": None, "origineFormeDessin": None, "point2FormeDessin": None, "listeCasesFormeDessin": [], \
+                          "projectionFormeDessin": [], "formeCoordEnCours": (0,0), \
+                          "zoneAttaqueCaC": [], "cibleAttaqueCaC": None, "cibleAttaqueDist": None, "pionCibleAttaqueDist": None, "ligneAttaqueDist": None, \
+                          "typeAttaqueZone": "", "formeAttaqueZone": None, "origineAttaqueZone": None, "point2AttaqueZone": None, "listeCasesAttaqueZone": [], "ligneMireAttaqueZone": None, \
+                          "entreeSortie": None}
+  
+
+        #mise a jour de l'interface de creation
+        self.fenetre.majVisibilitePanneauxPlateau("creation")
+        self.fenetre.ui.nomPlateau.setText(QString.fromUtf8(self.nom))
+        self.fenetre.ui.nomPlateau.setText(QString.fromUtf8(self.nom))
+        self.majBoutonsCouleursPerso()
+        self.majBoutonsCaches()
+        self.majListTerrains()
+        self.majListCreatures()
+        self.majListDecors()
+        self.initListeOrdreJeu()
+        self.initListeAttaques()
+        self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(self.notes))
+        
+        if self.modeParam["couleurPion"].isValid(): 
+            self.fenetre.ui.pionCouleur.setStyleSheet("QPushButton {backGround:%s}" %(self.modeParam["couleurPion"].name()))
+            
+        #mise a jour de l'interface d'informations
+        self.majInfosPion(None)
+        self.majInfosDecor(None)
+
+    def estCree(self):
+        """renvoie vrai si des cases ont ete creees"""
+        if len(self.cases) > 0:
+            retour = True
+        else:
+            retour = False
+        return retour
+
+    def majBoutonsCouleursPerso(self):
+        """met a jour l'affichage des couleurs customisees dans la boite de dialogue de selection de couleur"""
+        for i in range(0,16):
+            rgb = QColorDialog(self.fenetre.ui.vuePlateau).customColor(i)
+            couleur = QColor(rgb)
+            bouton = self.fenetre.ui.outilsEditionPlateau.findChild(QToolButton, "terrainCouleurPerso{}".format(i+1))
+            if couleur.isValid():
+                bouton.setStyleSheet("QToolButton {backGround:%s}"%(couleur.name()))
+                self.fenetre.connect(bouton, SIGNAL("clicked()"), self.modePeintureCase_perso)
+
+    def chercherCouleur(self):
+        """ouvre la boite de dialogue de selection de couleur"""
+        couleur = QColorDialog(self.fenetre.ui.vuePlateau).getColor(QColor("white"), self.fenetre.ui.vuePlateau)
+        self.majBoutonsCouleursPerso()
+        return couleur
+
+    def majBoutonsCaches(self):
+        """met a jour l'affichage et connecte les boutons de caches"""
+        for i in range(1,5):
+            bouton = self.fenetre.ui.outilsEditionPlateau.findChild(QToolButton, "plateauCache{}".format(i))
+            self.fenetre.connect(bouton, SIGNAL("clicked()"), self.majAffichageMenuCache)
+
+    def majListesPions(self, numPion = None):
+        """met a jour les listes contenant des donnees liees aux pions"""
+##        self.majListeOrdreJeu()
+##        
+##        if numPion == None or numPion == self.pionSelectionne().numero:
+##            self.majListeAttributs()
+##        QApplication.processEvents()
+        pass
+
+    def majNotesPlateau(self):
+        """les notes du plateau ont ete maj a l'ecran"""
+        self.notes = str(self.fenetre.ui.notesMjPlateau.toPlainText().toUtf8())
+
+    def agrandirNotesMjPlateau(self):
+        """affiche les notes du plateau dans une QDialog, puis recupere les donnees qui y sont saisies"""
+        affichageTexte = EcranAffichageTexte(self.notes)
+        affichageTexte.setAttribute(Qt.WA_DeleteOnClose)
+        r = affichageTexte.exec_()
+        self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(affichageTexte.recupererTexte()))
+        
+    ##### affichage de la liste des terrains enregistres, et fonctions d'acces aux donnees""""     
+    def afficheEcranEditionTerrains(self, terrain = None):
+        """affiche l'ecran d'edition/creation de terrains"""
+        self.editionTerrain = EcranEditionTerrain(terrain)
+        self.connect(self.fenetre, SIGNAL("majListTerrains()"), self.majListTerrains)
+        self.connect(self.editionTerrain, SIGNAL("majListTerrains()"), self.majListTerrains)        
+        self.editionTerrain.setAttribute(Qt.WA_DeleteOnClose)
+        r = self.editionTerrain.exec_()
+ 
+    def majListTerrains(self):
+        """mise a jour de la liste des terrains depuis la sauvegarde"""
+        dico = afficheSvg("biblio\\terrain")
+        while self.fenetre.ui.listTerrains.rowCount() > 0:
+            self.fenetre.ui.listTerrains.removeRow(0)
+        index = 0    
+        #self.fenetre.ui.listTerrains.setColumnWidth(0,0)
+        self.fenetre.ui.listTerrains.hideColumn(0)
+        self.fenetre.ui.listTerrains.sizeHintForColumn(1)
+        for elt in dico:
+            terrain = dico[elt]
+            self.fenetre.ui.listTerrains.insertRow(int(index))
+            self.fenetre.ui.listTerrains.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(elt)))
+            icon = QIcon("img\\"+terrain.imgTexture)
+            item = QTableWidgetItem(icon,QString.fromUtf8(terrain.nom))
+            self.fenetre.ui.listTerrains.setItem(int(index),1,item)
+            index += 1
+        self.fenetre.ui.listTerrains.setIconSize(QSize(30,20))   
+        self.fenetre.ui.listTerrains.sizeHintForColumn(1)
+        self.fenetre.ui.listTerrains.sortItems(0)
+        self.majMode("standard")
+
+    def terrainEdit(self):
+        """ouvre la fenetre 'terrains' en mode edition"""
+        index = self.fenetre.ui.listTerrains.item(self.fenetre.ui.listTerrains.currentRow(), 0)
+        if index > 0:
+            terrain = charger("biblio\\terrain", str(index.text().toUtf8()))
+            self.afficheEcranEditionTerrains(terrain)
+        
+    def terrainNouveau(self):
+        """ouvre la fenetre 'terrains' en mode edition"""
+        self.afficheEcranEditionTerrains()
+    ###############
+
+    ##### affichage de la liste des creatures enregistrees, et fonctions d'acces aux donnees""""     
+    def afficheEcranEditionCreatures(self, creature = None):
+        """affiche l'ecran d'edition/creation de creatures"""
+        self.editionCreature = EcranEditionCreature(creature, self.formeCases)
+        self.editionCreature.setAttribute(Qt.WA_DeleteOnClose)
+        self.connect(self.fenetre, SIGNAL("majListCreatures()"), self.majListCreatures)
+        self.connect(self.editionCreature, SIGNAL("majListCreatures()"), self.majListCreatures)        
+        r = self.editionCreature.exec_()       
+        
+    def majListCreatures(self):
+        """mise a jour de la liste des creatures depuis la sauvegarde"""
+        dico = afficheSvg("biblio\\creature")
+        while self.fenetre.ui.listCreatures.rowCount() > 0:
+            self.fenetre.ui.listCreatures.removeRow(0)
+        index = 0    
+        #self.fenetre.ui.listTerrains.setColumnWidth(0,0)
+        self.fenetre.ui.listCreatures.hideColumn(0)
+        self.fenetre.ui.listCreatures.sizeHintForColumn(1)
+        for elt in dico:
+            creature = dico[elt]
+            self.fenetre.ui.listCreatures.insertRow(int(index))
+            self.fenetre.ui.listCreatures.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(elt)))
+            icon = QIcon("img\\"+creature.logo)
+            item = QTableWidgetItem(icon,QString.fromUtf8(creature.nom))
+            self.fenetre.ui.listCreatures.setItem(int(index),1,item)
+            index += 1
+        self.fenetre.ui.listCreatures.setIconSize(QSize(30,20))   
+        self.fenetre.ui.listCreatures.sizeHintForColumn(1)
+##        self.fenetre.ui.listCreatures.sortItems(0)
+        trierTable(self.fenetre.ui.listCreatures, 0, 0)
+        self.majMode("standard")
+
+    def creatureEdit(self):
+        """ouvre la fenetre 'creatures' en mode edition"""
+        index = self.fenetre.ui.listCreatures.item(self.fenetre.ui.listCreatures.currentRow(), 0)
+        if index > 0:
+            creature = charger("biblio\\creature", str(index.text().toUtf8()))
+            self.afficheEcranEditionCreatures(creature)
+        
+    def creatureNouveau(self):
+        """ouvre la fenetre 'creatures' en mode edition"""
+        self.afficheEcranEditionCreatures()
+        
+    ###############
+
+    ##### affichage de la liste des decors enregistrees, et fonctions d'acces aux donnees""""     
+    def afficheEcranEditionDecors(self, decor = None):
+        """affiche l'ecran d'edition/creation de decors"""
+        self.editionDecor = EcranEditionDecors(decor, self.formeCases)
+        self.editionDecor.setAttribute(Qt.WA_DeleteOnClose)
+        self.connect(self.fenetre, SIGNAL("majListDecors()"), self.majListDecors)
+        self.connect(self.editionDecor, SIGNAL("majListDecors()"), self.majListDecors)
+        r = self.editionDecor.exec_()
+        
+    def majListDecors(self):
+        """mise a jour de la liste des decors depuis la sauvegarde"""
+        dico = afficheSvg("biblio\\decor")
+        while self.fenetre.ui.listDecors.rowCount() > 0:
+            self.fenetre.ui.listDecors.removeRow(0)
+        index = 0    
+        #self.fenetre.ui.listTerrains.setColumnWidth(0,0)
+        self.fenetre.ui.listDecors.hideColumn(0)
+        self.fenetre.ui.listDecors.sizeHintForColumn(1)
+        for elt in dico:
+            decor = dico[elt]
+            self.fenetre.ui.listDecors.insertRow(int(index))
+            self.fenetre.ui.listDecors.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(elt)))
+            icon = QIcon("img\\"+decor.logo)
+            item = QTableWidgetItem(icon,QString.fromUtf8(decor.nom))
+            self.fenetre.ui.listDecors.setItem(int(index),1,item)
+            index += 1
+        self.fenetre.ui.listDecors.setIconSize(QSize(30,20))   
+        self.fenetre.ui.listDecors.sizeHintForColumn(1)
+##        self.fenetre.ui.listDecors.sortItems(0)
+        trierTable(self.fenetre.ui.listDecors, 0, 0)
+        self.majMode("standard")
+
+    def decorEdit(self):
+        """ouvre la fenetre 'decors' en mode edition"""
+        index = self.fenetre.ui.listDecors.item(self.fenetre.ui.listDecors.currentRow(), 0)
+        if index > 0:
+            decor = charger("biblio\\decor", str(index.text().toUtf8()))
+            self.afficheEcranEditionDecors(decor)
+        
+    def decorNouveau(self):
+        """ouvre la fenetre 'decors' en mode edition"""
+        self.afficheEcranEditionDecors()
+        
+    ###############
+
+    ########### affichage des curseurs personnalises ########
+    def curseurSelection(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\curseurEpee.png")#.scaledToHeight(55, Qt.FastTransformation)
+        curseurPix.setMask(curseurPix.createHeuristicMask())
+        curseurPointe = QCursor(curseurPix, 0, 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurPointe)
+
+    def curseurPinceau(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\curseurPinceau.png")
+        curseurPinceau = QCursor(curseurPix, 0, curseurPix.height())
+        self.fenetre.ui.vuePlateau.setCursor(curseurPinceau)
+
+    def curseurGomme(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\gomme.png")#.scaledToHeight(55, Qt.FastTransformation)
+        curseurGomme = QCursor(curseurPix, 0, 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurGomme)
+
+    def curseurSeringue(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\curseurSeringue.png")
+        curseurSeringue = QCursor(curseurPix, 0, 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurSeringue)
+
+    def curseurEpee(self, valide = True):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        if valide:
+            curseurPix = QPixmap("img\\curseurEpee.png")
+        curseurSeringue = QCursor(curseurPix, 0, 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurSeringue)
+
+    def curseurArc(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\arc.png")
+        curseurSeringue = QCursor(curseurPix, curseurPix.width(), 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurSeringue)
+
+    def curseurBaguette(self):
+        self.fenetre.ui.vuePlateau.setDragMode(0)
+        curseurPix = QPixmap("img\\baguette.png")
+        curseurBaguette = QCursor(curseurPix, curseurPix.width(), 0)
+        self.fenetre.ui.vuePlateau.setCursor(curseurBaguette)
+        
+        
+    ############
+
+    ##### activation des differents modes d'interaction avec le plateau et mises a jour des principaux parametres  #######
+    def plateauModeCreation(self):
+        self.fenetre.majVisibilitePanneauxPlateau("creation")
+        self.modePrincipal = "creation"
+
+    def plateauModeCombat(self):
+        self.fenetre.majVisibilitePanneauxPlateau("combat")
+        self.modePrincipal = "combat"
+        
+    def majModeAffichage(self, index):
+        """met a jour le mode d'affichage"""
+        nouveauMode = ""
+        if index == 0:
+            #passe a l'affichage standard
+            pass
+        elif index == 1:
+            #passe en mode affichage de l'altitude
+            nouveauMode = "altitude"    
+        elif index == 2:
+            #affichage des terrains slt
+            nouveauMode = "terrain"
+        elif index == 3:
+            #affichage tactique
+            nouveauMode = "tactique"
+            
+        for coord in self.cases:
+            self.cases[coord].majAffichageSpecial(nouveauMode)
+
+    def modePeintureCase(self):
+        """enclenche le mode peinture de case a partir de la couleur selectionnee"""
+        self.majMode("standard")
+        couleur = self.chercherCouleur()
+        if couleur.isValid():
+            self.majMode("caseMajTerrain", couleur)
+        else:
+            self.majMode("standard")
+
+    def modePeintureCase_perso(self):
+        origine = self.sender().objectName()
+        index = int(origine.replace("terrainCouleurPerso",""))-1
+        couleur = QColor(QColorDialog(self.fenetre.ui.vuePlateau).customColor(index))
+        if couleur.isValid():
+            self.majMode("caseMajTerrain", couleur)
+        else:
+            self.majMode("standard")            
+
+    def modeCopieTerrain(self):
+        """enclenche le mode copie de case"""
+        self.majMode("caseCopie") 
+
+    def modeCaseEffet(self):
+        """enclenche le mode de mise a jour de l'ffet actif des cases"""
+        self.majMode("standard")
+        origine = self.sender().objectName()
+        if origine == "effFeu":
+            effet = "brule"
+        elif origine == "effEau":
+            effet = "eau"
+        elif origine == "effGlace":
+            effet = "glace"   
+        elif origine == "effPoison":
+            effet = "poison"   
+        elif origine == "effEffacer":
+            effet = "aucun"   
+            
+        self.majMode("caseMajEffet", effet)
+        self.fenetre.ui.vuePlateau.setFocus()
+
+    def modeCreationPion(self):
+        """enclenche le mode de creation de pions simples"""
+        self.majMode("pionCreation")
+
+    def majModePionSupprimer(self):
+        """enclenche le mode suppression de pions sur clic gauche (creatures ou decors)"""
+        self.majMode("pionSupprimer")        
+    
+    def modeCreationDecor(self, ligne, col):
+        """enclenche le mode de creation de decors depuis la liste des decors"""
+        index = self.fenetre.ui.listDecors.item(ligne, 0)
+        decor = charger("biblio\\decor", str(index.text().toUtf8()))
+        self.majMode("pionDecorCreation", decor)
+        self.fenetre.ui.vuePlateau.setFocus()
+        
+    def modeCreationCreaturePion(self, ligne, col):
+        """enclenche le mode de creation de pions depuis la liste des creatures"""
+        index = self.fenetre.ui.listCreatures.item(ligne, 0)
+        creature = charger("biblio\\creature", str(index.text().toUtf8()))
+        self.majMode("pionCreation", creature)
+        self.fenetre.ui.vuePlateau.setFocus()
+
+    def modeMajTerrainCase(self, ligne, col):
+        """enclenche le mode permettant la mise a jour du terrain des cases"""
+        index = self.fenetre.ui.listTerrains.item(ligne, 0)
+        terrain = charger("biblio\\terrain", str(index.text().toUtf8()))
+        self.majMode("caseMajTerrain", terrain)
+        self.fenetre.ui.vuePlateau.setFocus()
+
+    def majCouleurPion(self):
+        """selectionne une nouvelle couleur"""
+        self.majMode("standard")
+        couleur = self.chercherCouleur()
+        if couleur.isValid():
+            self.modeParam["couleurPion"] = couleur
+            self.fenetre.ui.pionCouleur.setStyleSheet("QPushButton {backGround:%s}" %(self.modeParam["couleurPion"].name()))
+            
+    def majEpaisseurPinceau(self, epaisseur):
+        """met a jour l'epaisseur du pinceau (en cases)"""
+        self.fenetre.ui.valeurEpaisseurPinceau.setText(QString.fromUtf8(str(epaisseur)))
+        self.epaisseurPinceau = int(epaisseur)
+
+    def modeMajAltitudeCase(self):
+        self.majMode("caseMajAltitude")
+
+    def majModeForme(self):
+        """met a jour la forme utilisee pour la peinture"""
+        bouton = self.sender().objectName()
+        if bouton == "formeSimple":
+            self.modeParam["typeFormeDessin"] = "simple"
+        elif bouton == "formeLigne":
+            self.modeParam["typeFormeDessin"] = "ligne"
+        elif bouton == "formeLigneOrientee":
+            self.modeParam["typeFormeDessin"] = "frontiere"
+        elif bouton == "formeEllipseVide":
+            self.modeParam["typeFormeDessin"] = "ellipseV"
+        elif bouton == "formeEllipsePlein":
+            self.modeParam["typeFormeDessin"] = "ellipseP"
+        elif bouton == "formeRectVide":
+            self.modeParam["typeFormeDessin"] = "rectV"
+        elif bouton == "formeRectPlein":
+            self.modeParam["typeFormeDessin"] = "rectP"
+
+        if self.modeActif[0:7] != "caseMaj":    
+            self.majMode("caseMajTerrain", self.modeParam["terrain"])
+
+    def majAffichageMenuCache(self):
+        """un bouton 'cache' a ete clique, on met a jour les infos""" 
+        origine = self.sender().objectName()
+        index = int(origine.replace("plateauCache",""))
+        self.cacheEnCours = index
+        for i in range(1,5):
+            bouton = self.fenetre.ui.outilsEditionPlateau.findChild(QToolButton, "plateauCache{}".format(i))
+            bouton.setCheckable(True)
+            bouton.setChecked((i == index))
+        self.fenetre.ui.cacheActif.setChecked(self.caches[index]["actif"])
+        self.voirCacheEnCours()
+
+    def majModeCombatDeplacement(self):
+        """active le mode de combat 'deplacement' (mode standard)"""
+        self.majModeCombat("combatDeplacement")
+
+    def majModeCombatAttaqueCaC(self):
+        """active le mode de combat 'corps-a-corps'"""
+        self.majModeCombat("combatAttaqueCaC")
+
+    def majModeCombatAttaqueDist(self):
+        """active le mode de combat 'attaque a distance'"""
+        self.majModeCombat("combatAttaqueDist")
+
+    def majModeCombatZone(self):
+        if not len(self.modeParam["typeAttaqueZone"]) > 0: self.modeParam["typeAttaqueZone"] = "ligne"
+        self.majModeCombat("combatAttaqueZone")        
+
+    def majModeCombatZoneForme(self):
+        if self.modeCombat == "combatAttaqueZone":
+            origine = self.sender().objectName()
+            self.modeParam["typeAttaqueZone"] = str(origine).split("_")[1]
+            self.majModeCombat("combatAttaqueZone")
+
+    def majModeDefinirEntree(self):
+        self.modeParam["entreeSortie"] = EntreeSortie(self, "E")
+        self.modeParam["entreeSortie"].creerForme()
+        self.majMode("placementEntreeSortie")
+
+    def majModeDefinirSortie(self):
+        self.modeParam["entreeSortie"] = EntreeSortie(self, "S")
+        self.modeParam["entreeSortie"].creerForme()
+        self.majMode("placementEntreeSortie")
+
+    def majModeZonePlacement(self):
+        self.majMode("majZonePlacement")
+    
+    def majMode(self, mode = "standard", param = None):
+        """modifie ou reinitialise le type d'interaction avec le plateau"""   
+        reinit = True    #doit-on reinitialiser a la fin de l'operation
+        ##on desactive le mode precedent
+        if self.pionSelectionne() != None:
+            self.pionSelectionne().afficheOmbreSelection(False)
+            if self.modeActif == "pionSelectionne":    
+                 self.majModeCombat("")   
+            self.modeParam["numPionSelectionne"] = 0
+        elif self.pionDecorSelectionne() != None:
+            self.pionDecorSelectionne().afficheOmbreSelection(False)
+            self.modeParam["numPionSelectionne"] = 0
+
+        if self.modeActif == "pionSelectionne" or self.modeActif == "pionCreation" or self.modeActif == "pionDecorSelectionne" or self.modeActif == "pionDecorCreation":  
+            self.majProjectionPosition(False)
+            self.modeParam["formeProjectionPosition"] = None
+            self.modeParam["coordProjectionPosition"] = None
+            self.modeParam["nbRotations"] = 0
+                
+        if self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
+            if self.modeParam["formeDessin"] != None:
+                self.modeParam["formeDessin"].prepareGeometryChange()
+                self.removeItem(self.modeParam["formeDessin"])    
+            self.modeParam["formeDessin"] = None
+            self.modeParam["origineFormeDessin"] = None
+            self.modeParam["point2FormeDessin"] = None
+            
+            self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
+            self.modeParam["listeCasesFormeDessin"] = []
+
+        if self.modeActif == "placementEntreeSortie":            
+            if self.modeParam["entreeSortie"] != None:
+                self.modeParam["entreeSortie"].prepareGeometryChange()
+                self.removeItem(self.modeParam["entreeSortie"])
+                self.modeParam["entreeSortie"] = None
+   
+        ### definition du nouveau mode
+        if mode in self.listMode and mode != "standard":
+            self.modeActif = mode
+            reinit = False
+            if mode == "caseMajTerrain":
+                #curseur pinceau, on ajoute des terrains au cases
+                if param != None:
+                    self.curseurPinceau()
+                    self.fenetre.ui.vuePlateau.setDragMode(0)
+                    self.modeParam["terrain"] = param                
+                    
+            elif mode == "caseCopie":
+                #curseur seringue, on 'preleve' le terrain sur la case cliquee, avant de passer en mode majTerrain
+                self.curseurSeringue()
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+
+            elif mode == "caseMajEffet":
+                #on met a jour l'effet actif sur les cases
+                if param != None:
+                    self.curseurPinceau()
+                    self.fenetre.ui.vuePlateau.setDragMode(0)
+                    self.modeParam["effet"] = param                
+
+            elif mode == "caseMajAltitude":
+                self.curseurPinceau()
+                self.fenetre.ui.vuePlateau.setDragMode(0)                           
+
+            elif mode == "cachePlacer":
+                self.curseurPinceau()
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+                self.modeParam["typeFormeDessin"] = "rectP"
+
+            elif mode == "majZonePlacement":
+                self.curseurPinceau()
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+                self.modeParam["typeFormeDessin"] = "rectP"
+
+            elif mode == "placementEntreeSortie":
+                self.fenetre.ui.vuePlateau.setDragMode(0)               
+                
+            elif mode == "pionDecorCreation":
+                #curseur 'plus', on cree de nouveaux decors
+                self.modeParam["decor"] = None
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
+                self.modeParam["nbRotations"] = 0
+                if param != None:
+                    if param.__class__.__name__ == "Decor":
+                         self.modeParam["decor"] = param
+                         self.modeParam["formeProjectionPosition"].definirForme(self.modeParam["decor"].formeDef[self.formeCases])
+
+            elif mode == "pionDecorSelectionne":
+                #un pion decor est selectionne
+                if param != None:
+                    self.modeParam["numPionSelectionne"] = param
+                    self.pionDecorSelectionne().afficheOmbreSelection(True)
+                    self.fenetre.ui.vuePlateau.setCursor(QCursor(Qt.ArrowCursor))
+                    self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
+                    self.modeParam["formeProjectionPosition"].definirForme(self.pionDecorSelectionne().forme.formeDef)
+                    self.modeParam["nbRotations"] = self.pionDecorSelectionne().nbRotations 
+
+            elif mode == "pionCreation":
+                #curseur 'plus', on cree de nouveaux pions
+                self.modeParam["creature"] = None
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
+                self.modeParam["nbRotations"] = 0
+                if param != None:
+                    if param.__class__.__name__ == "Creature":
+                         self.modeParam["creature"] = param
+                         self.modeParam["formeProjectionPosition"].definirForme(self.modeParam["creature"].formeDef[self.formeCases])
+                
+            elif mode == "pionSupprimer":
+                #mode suppression de pions/pions decors
+                self.curseurGomme()
+                self.fenetre.ui.vuePlateau.setDragMode(0)
+
+            elif mode == "pionSelectionne":
+                #un pion est selectionne, on affiche les deplacements possibles
+                if param != None:
+                    self.modeParam["numPionSelectionne"] = param
+                    self.pionSelectionne().afficheOmbreSelection(True)
+                    self.numPionEnCours = param
+                    for i in range(0, self.fenetre.ui.infoOrdreJeu.rowCount()):
+                        if str(self.fenetre.ui.infoOrdreJeu.item(i, 0).text().toUtf8()) == str(param):
+                            self.fenetre.ui.infoOrdreJeu.setCurrentCell(i,0)
+                            
+                    self.majAffichagePionSelectionne()
+                    self.majListeAttributs()
+                    self.afficherNotesPion()
+                    self.majListeAttaques()
+                    self.majModeCombat("aucun")                  
+
+        elif not mode in self.listMode:
+            print("mode non reconnu")
+
+        ##on reinitialise si necessaire    
+        if reinit:
+            #mode standard : pas d'interaction avec les cases, on deplace le plateau en le saisissant ou les pions en cliquant dessus
+            self.modeActif = "standard"
+            self.majAffichagePionSelectionne()
+            self.majInfosPion()
+            self.majInfosDecor()
+            self.majListeAttributs()
+            self.majListeAttaques()
+            self.afficherNotesPion()
+            self.fenetre.majVisibiliteBarreCombat("menu")
+            QApplication.processEvents()
+            self.fenetre.ui.vuePlateau.setCursor(QCursor(Qt.ArrowCursor))
+            self.fenetre.ui.vuePlateau.setDragMode(1)
+        else:
+            self.fenetre.ui.vuePlateau.setFocus()
+
+    def majModeCombat(self, mode = ""):
+        """met a jour le mode de combat actif pour le pion selectionne"""
+        ## on desactive le mode precedent si besoin
+        #la projection de position
+        
+        if self.modeCombat == "combatDeplacement":
+            #le champ de deplacement
+            if self.modePrincipal == "combat":
+                self.afficherChampDeplacement(False)
+            self.majProjectionPosition(False)
+            self.modeParam["formeProjectionPosition"] = None
+            self.modeParam["coordProjectionPosition"] = None
+            self.modeParam["nbRotations"] = 0    
+                
+        elif self.modeCombat == "combatAttaqueCaC":        
+            #la zone d'attaque au cac
+            self.materialiserPions(True)
+            self.majZoneAttaqueCaC(False)
+            self.modeParam["zoneAttaqueCaC"] = []
+            if self.modeParam["cibleAttaqueCaC"] != None:
+                self.modeParam["cibleAttaqueCaC"].estCibleAttaque(False)
+                self.modeParam["cibleAttaqueCaC"] = None
+                
+        elif self.modeCombat == "combatAttaqueDist":
+            self.materialiserPions(True)
+            self.majLigneMireAttaqueDist()
+            
+        elif self.modeCombat == "combatAttaqueZone":  
+            #l'attaque de zone
+            self.materialiserPions(True)
+            QApplication.processEvents()
+            self.reinitAttaqueZone()
+            if mode != "combatAttaqueZone": self.fenetre.majVisibiliteBarreCombat("menu")
+            self.modeParam["listeCasesAttaqueZone"] = []
+               
+        ## maj de l'aspect des boutons selon le mode demande  
+        for item in self.fenetre.ui.barreBasCombat.children():
+            if item.__class__.__name__ == "QToolButton":
+                if item.isCheckable():
+                    item.setChecked((item.objectName() == mode and self.pionSelectionne() != None))
+                    if mode == "combatAttaqueZone":
+                        item.setChecked((item.objectName() == "combatZone_{}".format(self.modeParam["typeAttaqueZone"])\
+                                                  and self.pionSelectionne() != None))    
+        
+        ## definition du nouveau mode de combat
+        if self.pionSelectionne() != None:
+            self.modeCombat = mode
+            self.fenetre.ui.vuePlateau.setDragMode(0)
+            self.fenetre.ui.combatVol_altitude.setValue(self.pionSelectionne().z)
+            if mode == "aucun":
+                self.fenetre.ui.vuePlateau.setCursor(QCursor(Qt.ArrowCursor))
+            
+            if mode == "combatDeplacement":
+                self.fenetre.ui.vuePlateau.setCursor(QCursor(Qt.ArrowCursor))
+                self.modeParam["formeProjectionPosition"] = Forme(self.formeCases)
+                self.modeParam["formeProjectionPosition"].definirForme(self.pionSelectionne().forme.formeDef)
+                self.modeParam["nbRotations"] = self.pionSelectionne().nbRotations
+
+                if self.modePrincipal == "combat":
+                    #si mode combat, affichage de la zone de deplacement
+                    self.afficherChampDeplacement(True)
+                         
+            elif mode == "combatAttaqueCaC":
+                self.curseurEpee()
+                self.materialiserPions(False)
+                self.modeParam["zoneAttaqueCaC"] = self.zone(self.pionSelectionne().position, self.pionSelectionne().creature.allonge, True, True)
+                self.majZoneAttaqueCaC(True)
+                
+            elif mode == "combatAttaqueDist":
+                self.curseurArc()
+                self.materialiserPions(False)
+
+            elif mode == "combatAttaqueZone":
+                self.curseurBaguette()
+                self.materialiserPions(False)
+                self.majFormeAttaqueZone()
+        else:
+            self.fenetre.ui.combatVol_altitude.setValue(0)
+            
+    ###############
+
+    ########## Gestion du combat ##############
+    def majAffichageTour(self):
+        """met a jour l'affichage du tour en cours"""
+        self.fenetre.ui.combatTour.setText(QString.fromUtf8("Tour: {}".format(self.tour)))
+
+    def majAffichagePionSelectionne(self):
+        """affiche le nom et le logo du pion actuellement selectionne"""
+        if self.pionSelectionne() != None:
+            self.fenetre.ui.combatPionSelectionne.setText(QString.fromUtf8(self.pionSelectionne().txtId()))
+            if len(self.pionSelectionne().creature.img["nom"]) > 0:
+                pix = QPixmap(QString.fromUtf8("img\\"+self.pionSelectionne().creature.img["nom"]))
+                pix = pix.scaled(44, 44, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.combatPionSelectionne_img.setPixmap(pix)
+            else:    
+                self.fenetre.ui.combatPionSelectionne_img.setPixmap(QPixmap())    
+        else:
+            self.fenetre.ui.combatPionSelectionne_img.setPixmap(QPixmap())  
+            self.fenetre.ui.combatPionSelectionne.setText(QString.fromUtf8("Pas de pion selectionné"))
+
+    def initListeOrdreJeu(self):
+        """cree les colonnes et met en forme la table ordre jeu"""
+##        self.fenetre.ui.infoOrdreJeu.setColumnWidth(0, 20)
+        self.fenetre.ui.infoOrdreJeu.setColumnWidth(2, 30)
+        self.fenetre.ui.infoOrdreJeu.hideColumn(0)
+##        self.fenetre.ui.infoOrdreJeu.hideColumn(2)      
+        self.fenetre.ui.infoOrdreJeu.setIconSize(QSize(30,20))   
+            
+    def majListeOrdreJeu(self):
+        """met a jour la liste des pions infoOrdreJeu"""
+        while self.fenetre.ui.infoOrdreJeu.rowCount() > 0:
+            self.fenetre.ui.infoOrdreJeu.removeRow(0)
+        index = 0
+        for num in self.ordreJeu:
+            self.fenetre.ui.infoOrdreJeu.insertRow(int(index))
+            self.fenetre.ui.infoOrdreJeu.setItem(int(index), 0, QTableWidgetItem(QString.fromUtf8(str(num))))
+            icon = QIcon("img\\"+self.pions[num].creature.logo)
+            item = QTableWidgetItem(icon,QString.fromUtf8(self.pions[num].txtId()))
+            self.fenetre.ui.infoOrdreJeu.setItem(int(index), 1, item)
+            self.fenetre.ui.infoOrdreJeu.setItem(int(index), 2, QTableWidgetItem(QString.fromUtf8(str(self.ordreJeu[num]))))
+            index += 1
+
+        self.fenetre.ui.infoOrdreJeu.sizeHintForColumn(1)
+        trierTable(self.fenetre.ui.infoOrdreJeu, 2, 0)
+
+    def clicListOrdreJeu(self, ligne, col):
+        """on a clique dans la liste d'ordre de jeu, le pion correspondant est selectionne et centre sur la carte"""
+        numPion = int(self.fenetre.ui.infoOrdreJeu.item(ligne, 0).text().toUtf8())  
+        self.fenetre.ui.vuePlateau.centerOn(self.cases[self.pions[numPion].position].centreGraphique)
+        self.pionSaisir(numPion)
+
+    def pionSuivant(self):
+        """selection du pion suivant dans la liste d'ordre de jeu"""
+        if self.numPionEnCours in self.pions:
+            suivant = self.ordreJeu[self.numPionEnCours] + 1
+        else:
+            suivant = 1
+        if suivant > len(self.ordreJeu):
+            self.tour += 1
+            self.majAffichageTour()
+            suivant = 1
+        for num in self.ordreJeu:
+            if self.ordreJeu[num] == suivant:
+                numPion = num
+                break
+
+        for ligne in range(0, self.fenetre.ui.infoOrdreJeu.rowCount()):
+            item = self.fenetre.ui.infoOrdreJeu.item(ligne, 0)
+            item.setSelected(int(self.fenetre.ui.infoOrdreJeu.item(ligne, 0).text().toUtf8()) == numPion)
+            if int(item.text().toUtf8()) == numPion:
+                self.fenetre.ui.infoOrdreJeu.scrollToItem(item)
+
+        self.fenetre.ui.vuePlateau.centerOn(self.cases[self.pions[numPion].position].centreGraphique)
+        self.pionSaisir(numPion)        
+ 
+    def afficheEcranGestionCombat(self):
+        #*egc
+        """affiche l'ecran de gestion du combat"""
+        self.gestionCombat = EcranGestionCombat(self)
+        self.gestionCombat.show()
+        self.connect(self.fenetre, SIGNAL("majListesPions"), self.majListesPions)
+        self.connect(self.gestionCombat, SIGNAL("majListesPions"), self.majListesPions)
+        QApplication.processEvents()
+##        r = self.gestionCombat.exec_()
+
+    def majOrdreJeu(self):
+        """met a jour l'ordre de jeu des pions en fonction de l'attribut prevu par les regles s'il existe,
+           ou en fonction de l'ordre de jeu parametre sinon"""
+        attribut = regles.attributOrdreJeu()
+        if attribut != None:
+            dico = {}
+            for numPion in self.pions:
+                dico[numPion] = int(self.pions[numPion].lstCarac[attribut])
+            ordre = sorted(dico, key = dico.get, reverse=(regles.sensTriOrdreJeu() == 1)) 
+            self.ordreJeu = {}    
+            for numPion in self.pions:
+                self.ordreJeu[numPion] = ordre.index(numPion) + 1
+        self.majListeOrdreJeu()  
+
+    def pionDeplacerDansOrdreJeu(self, numPion, nouvellePosition):
+        """deplace un pion dans le dictionnaire gerant l'ordre de jeu de maniere a assurer sa coherence
+           nouvellePosition = 0 supprime le pion de la liste"""
+        if numPion in self.ordreJeu:
+            if nouvellePosition == 0:
+                del self.ordreJeu[numPion]
+        if len(self.ordreJeu) > 0:        
+            i = 0    
+            tmp = sorted(self.ordreJeu, key=self.ordreJeu.get)
+            if numPion in tmp:
+                tmp.remove(numPion)
+            for num in tmp:
+                i += 1
+                if i == nouvellePosition:
+                    self.ordreJeu[numPion] = i
+                    i += 1
+                self.ordreJeu[num] = i
+            if i < nouvellePosition:
+                self.ordreJeu[numPion] = i + 1 
+        elif nouvellePosition > 0:
+            self.ordreJeu[numPion] = 1
+        self.majOrdreJeu()
+        
+    def majListeAttributs(self):
+        """met a jour la liste des attributs dans le panneau de combat"""
+        self.fenetre.ui.listeAttributs.setColumnWidth(0, (0.4*self.fenetre.ui.listeAttributs.width())) 
+        self.fenetre.ui.listeAttributs.setColumnWidth(1, (0.4*self.fenetre.ui.listeAttributs.width()))
+        self.disconnect(self.fenetre.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+        
+        #on vide la liste
+        while self.fenetre.ui.listeAttributs.rowCount() > 0:
+            self.fenetre.ui.listeAttributs.removeRow(0)
+        self.fenetre.ui.listeAttributs.setVisible((self.pionSelectionne() != None))    
+        if self.pionSelectionne() != None:        
+            #creation des lignes de base    
+            lignesBase = ["Nom","Etat","Alt."]   #attention: modifier aussi dans listeAttributCelluleModifiee
+            for i in range(0, 10):    #10 premieres colonnes reservees pour les infos de base
+                self.fenetre.ui.listeAttributs.insertRow(i)
+                item = QTableWidgetItem()
+                if i < len(lignesBase):
+                    item.setText(QString.fromUtf8(lignesBase[i]))
+                item.setFlags(Qt.NoItemFlags)    
+                self.fenetre.ui.listeAttributs.setItem(i, 0, item)
+                self.fenetre.ui.listeAttributs.setRowHidden(i, (i >= len(lignesBase)))
+
+            #maj des donnees de base    
+            self.fenetre.ui.listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom))))
+            self.fenetre.ui.listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat))))
+            self.fenetre.ui.listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z))))
+            
+            #attributs issus des regles utilisees    
+            ordre = regles.ordreAttributs()
+            for elt in ordre:
+                ligne = 10 + ordre.index(elt)
+                self.fenetre.ui.listeAttributs.insertRow(ligne)
+                item = QTableWidgetItem(QString.fromUtf8(elt))
+                item.setFlags(Qt.NoItemFlags)
+                self.fenetre.ui.listeAttributs.setItem(ligne, 0, item)
+                self.fenetre.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().lstCarac[elt]))))
+                
+            self.connect(self.fenetre.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+            
+    def listeAttributCelluleModifiee(self, ligne, colonne):
+        """une cellule de la liste des attributs a ete modifiee"""
+        if colonne != 1:
+            print("valeur non modifiable")
+        else:
+            #on verifie la validite de la donnee entree
+            lignesBase = ["Nom","Etat","Alt."]   #attention: modifier aussi dans majListeAttribut
+            if ligne < len(lignesBase):
+                pass
+            elif ligne >= 10:
+                attribut = regles.ordreAttributs()[(ligne - 10)]
+                nouvelleVal = str(self.fenetre.ui.listeAttributs.item(ligne, 1).text().toUtf8())
+                valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal)
+                if valVerifiee != None:
+                    self.pionSelectionne().lstCarac[attribut] = valVerifiee
+                    if attribut == regles.attributOrdreJeu():
+                        print("maj ordre (a implementer)")
+                else:    
+                    self.fenetre.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().lstCarac[attribut]))))
+
+    def initListeAttaques(self):
+        """met en forme et connecte la liste des attaques du pion"""
+        self.fenetre.ui.listeAttaques.setColumnWidth(0, 0) 
+        self.fenetre.ui.listeAttaques.setColumnWidth(1, (0.3*self.fenetre.ui.listeAttaques.width()))
+        self.fenetre.ui.listeAttaques.setColumnWidth(2, (0.7*self.fenetre.ui.listeAttaques.width()))
+        self.connect(self.fenetre.ui.listeAttaques, SIGNAL("itemSelectionChanged()"), self.majInfosAttaqueEC)
+        self.connect(self.fenetre.ui.listeAttaques, SIGNAL("cellClicked(int, int)"), self.listeAttaquesCelluleCliquee)
+        self.connect(self.fenetre.ui.notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC)
+        self.fenetre.ui.listeAttributsAttaqueEC.setColumnWidth(0, (0.49*self.fenetre.ui.listeAttributsAttaqueEC.width())) 
+        self.fenetre.ui.listeAttributsAttaqueEC.setColumnWidth(1, (0.5*self.fenetre.ui.listeAttributsAttaqueEC.width()))
+        
+    def majListeAttaques(self):
+        #*eea
+        """met a jour la liste des attaques du pion dans le panneau de combat"""
+        #on vide la liste
+        while self.fenetre.ui.listeAttaques.rowCount() > 0:
+            self.fenetre.ui.listeAttaques.removeRow(0)
+            
+        self.fenetre.ui.listeAttaques.setVisible((self.pionSelectionne() != None))
+        self.fenetre.ui.titreAttaques.setVisible((self.pionSelectionne() != None))
+        self.fenetre.ui.editerAttaques.setVisible((self.pionSelectionne() != None))
+        self.fenetre.ui.panneauAttaqueEC.setVisible((self.pionSelectionne() != None))
+
+        i = 0
+        if self.pionSelectionne() != None:        
+            for attaque in self.pionSelectionne().attaques:
+                self.fenetre.ui.listeAttaques.insertRow(i)
+                self.fenetre.ui.listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().attaques.index(attaque)))))
+                icone = None
+                if attaque.typ == "cac":
+                    icone = QIcon("img\\curseurEpee.png")
+                if attaque.typ == "dist":
+                    icone = QIcon("img\\arc.png")
+                if attaque.typ == "zone":
+                    icone = QIcon("img\\baguette.png")
+                if icone != None:
+                    self.fenetre.ui.listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8("")))
+                self.fenetre.ui.listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom)))
+        self.majInfosAttaqueEC()                                                 
+
+    def listeAttaquesCelluleCliquee(self, ligne, colonne):
+        """on a clique sur une cellule de la liste des attaques"""
+        numAttaque = int(str(self.fenetre.ui.listeAttaques.item(ligne, 0).text().toUtf8()))
+        if numAttaque >= 0:
+            self.utiliserAttaque(numAttaque)  
+
+    def utiliserAttaque(self, numAttaque):
+        """le pion selectionne utilise son attaque n"""
+        if self.pionSelectionne() != None:
+            if numAttaque < len(self.pionSelectionne().attaques):
+                attaque = self.pionSelectionne().attaques[numAttaque]
+                if attaque.typ == "cac":
+                    self.majModeCombat("combatAttaqueCaC")
+                if attaque.typ == "dist":
+                    self.majModeCombat("combatAttaqueDist")                
+                if attaque.typ == "zone":
+                    self.modeParam["typeAttaqueZone"] = attaque.formeZone
+                    self.fenetre.ui.combatZone_disqueRayon.setValue(attaque.rayon)
+                    self.majModeCombat("combatAttaqueZone")
+
+    def majInfosAttaqueEC(self):
+        #*aec
+        """met a jour les infos de l'attaque en cours (selectionnee)"""
+        selection = self.fenetre.ui.listeAttaques.selectedItems()
+        self.fenetre.ui.panneauAttaqueEC.setVisible(self.pionSelectionne() != None and len(selection) > 0)
+        if self.pionSelectionne() != None and len(selection) > 0:
+            ligne = selection[0].row()
+            numAttaque = int(str(self.fenetre.ui.listeAttaques.item(ligne, 0).text().toUtf8()))
+            self.disconnect(self.fenetre.ui.listeAttributsAttaqueEC, SIGNAL("cellChanged(int,int)"), self.attaqueECCelluleModifiee)
+            #on vide la liste
+            while self.fenetre.ui.listeAttributsAttaqueEC.rowCount() > 0:
+                self.fenetre.ui.listeAttributsAttaqueEC.removeRow(0)
+                
+            self.fenetre.ui.listeAttributsAttaqueEC.insertRow(0)
+            self.fenetre.ui.listeAttributsAttaqueEC.setItem(0, 0, QTableWidgetItem(QString.fromUtf8("numAtt")))
+            self.fenetre.ui.listeAttributsAttaqueEC.setItem(0, 1, QTableWidgetItem(QString.fromUtf8(str(numAttaque))))
+            self.fenetre.ui.listeAttributsAttaqueEC.setRowHidden(0, True)
+            
+            #attributs issus des regles utilisees    
+            ordre = regles.ordreAttributsAttaques()
+            for elt in ordre:
+                ligne = 1 + ordre.index(elt)
+                self.fenetre.ui.listeAttributsAttaqueEC.insertRow(ligne)
+                item = QTableWidgetItem(QString.fromUtf8(elt))
+                item.setFlags(Qt.NoItemFlags)
+                self.fenetre.ui.listeAttributsAttaqueEC.setItem(ligne, 0, item)
+                self.fenetre.ui.listeAttributsAttaqueEC.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().attaques[numAttaque].attributs[elt]))))
+                
+            self.connect(self.fenetre.ui.listeAttributsAttaqueEC, SIGNAL("cellChanged(int,int)"), self.attaqueECCelluleModifiee)
+            #maj des notes
+            self.disconnect(self.fenetre.ui.notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC)
+            self.fenetre.ui.notesAttaqueEC.setText(QString.fromUtf8(self.pionSelectionne().attaques[numAttaque].notes))
+            self.connect(self.fenetre.ui.notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC)
+            
+    def attaqueECCelluleModifiee(self, ligne, colonne):
+        """une cellule de la liste d'attributs de l'attaque en cours a ete modifiee"""
+        pass
+
+    def majNotesAttaqueEC(self):
+        """met a jour les notes de l'attaque en cours (selectionnee)"""
+        selection = self.fenetre.ui.listeAttaques.selectedItems()
+        self.fenetre.ui.panneauAttaqueEC.setVisible(self.pionSelectionne() != None and len(selection) > 0)
+        if self.pionSelectionne() != None and len(selection) > 0:
+            ligne = selection[0].row()
+            numAttaque = int(str(self.fenetre.ui.listeAttaques.item(ligne, 0).text().toUtf8()))        
+            self.pionSelectionne().attaques[numAttaque].notes = str(self.fenetre.ui.notesAttaqueEC.toPlainText().toUtf8())
+
+    def afficheEcranEditionAttaques(self):
+        """affiche l'ecran d'edition/creation d'attaques"""
+        if self.pionSelectionne() != None:
+            self.editionAttaques = QDialog()
+            frame = EcranEditionAttaques(self.pionSelectionne())
+            frame.setParent(self.editionAttaques)
+            self.editionAttaques.setAttribute(Qt.WA_DeleteOnClose) 
+            r = self.editionAttaques.exec_()
+            del self.editionAttaques
+            self.majListeAttaques()
+
+    def majNotesPion(self):
+        """les notes du pion ont ete mises a jour"""
+        if self.pionSelectionne() != None:
+            self.pionSelectionne().notes = str(self.fenetre.ui.notesPion.toPlainText().toUtf8())
+        else:
+            pass
+
+    def afficherNotesPion(self):
+        """affiche les notes du pion selectionne dans le QTextEdit dedie"""
+        self.fenetre.ui.notesPion.setVisible((self.pionSelectionne() != None))
+        if self.pionSelectionne() != None:
+            self.fenetre.ui.notesPion.setText(QString.fromUtf8(self.pionSelectionne().notes))
+            
+    ###############
+
+    ############### fonctions de calcul ################ 
+    def zone(self, origine, distance, z=0, conditionFranchissable = False, conditionVisible = False):
+        """renvoie un dictionnaire representant la liste des coordonnees des cases comprises dans la zone
+           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
+           [cf methode A* (A-star)]"""
+        
+        aVerifier = []
+        aVerifier2 = []
+        resultat = {}
+        k = 0           
+        #on part de la premiere case, puis on itere a partir de chaque nouveau depart
+        if origine in self.cases:
+            aVerifier.append(origine)
+            while k <= distance:
+                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
+         
+        return resultat
+
+    def coordonneesValides(self, coord):
+        """les coordonnees entrees en parametre sont elles celles d'une case du plateau"""
+        return (coord[0] >= 0 and coord[1] >= 0 and coord[0] < self.nbCasesX and coord[1] < self.nbCasesY)
+
+    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)"""
+        pointsPolygone = []
+        segments = []
+        case = Case(self)
+        
+        #on verifie que toutes les cases sont adjacentes les unes aux autres
+        valide = True
+        if len(listeCases) > 1:
+            for coord in listeCases:
+                if not len(set(listeCases).intersection(self.lstCoordAdjacentes(coord[0], coord[1]))) > 0: valide = False
+        if not len(listeCases) > 0:
+            valide = False
+        
+        if valide:
+            #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])
+                voisins =  self.lstCoordAdjacentes(coord[0], coord[1])
+                for i in range(0, len(voisins)):
+                    if not voisins[i] in listeCases:
+                       j = i+1
+                       if j > len(voisins) - 1:
+                           j = 0
+                       segments.append(QLineF(polygone[i], polygone[j]))
+
+            #on 'accroche' les segments les uns aux autres, dans l'ordre
+            segments2 = [segments[0]]
+            for segment2 in segments2:
+                for segment in segments:
+                    if not QLineF(segment.p1(), segment.p2()) in segments2 and not QLineF(segment.p2(), segment.p1()) in segments2:
+                        if sqrt((segment.p1().x()-segment2.p2().x())**2+(segment.p1().y()-segment2.p2().y())**2) < 1:
+                            segments2.append(QLineF(segment.p1(), segment.p2()))
+                        elif sqrt((segment.p2().x()-segment2.p2().x())**2+(segment.p2().y()-segment2.p2().y())**2) < 1:   
+                            segments2.append(QLineF(segment.p2(), segment.p1()))
+
+            pointsPolygone = []
+            premierPoint = segments2[0].p1()
+            pointsPolygone.append(premierPoint)
+            for segment in segments2:
+                pointSuivant = segment.p2()
+                if pointSuivant != premierPoint:
+                     pointsPolygone.append(pointSuivant)
+
+            #creation du polygone
+            polygone = QPolygonF()
+            for point in pointsPolygone:   
+                polygone.append(point)   
+        else:
+            polygone = None
+
+        return polygone  
+
+    def lstCoordAdjacentes(self, x, y):
+        """renvoie la liste des coordonnees adjacentes, sans condition d'existence sur le plateau
+           attention: l'ordre est important"""
+        if self.formeCases == "H":
+            voisins = [(x, y-1), (x+1, y-0.5), (x+1, y+0.5), (x,  y+1), (x-1, y+0.5), (x-1, y-0.5)]         
+        else:
+            voisins = [(x, y-1), (x+1, y), (x,   y+1), (x-1, y)]
+        return voisins                                        
+
+    def coordCentreListeCases(self, listeCases):
+        """renvoie les coordonnees centrales d'une liste de cases"""
+        retour = None
+        if len(listeCases) > 0:
+            listeTriee = sorted(listeCases)
+            posMilieu = int(len(listeCases)/2)
+            retour = listeTriee[posMilieu]
+        return retour    
+
+    def coordonneesAuPoint(self, point):
+        """renvoie les coordonnees de la case situee au QPointF entre en parametre"""
+        coord = None
+        if point != None:
+            lstObjets = self.fenetre.ui.vuePlateau.scene().items(point)
+            for objet in lstObjets:
+                if objet:
+                    if objet.__class__.__name__ == "Case":
+                        coord = (objet.x, objet.y)
+                        break       
+        return coord            
+
+    def creerOrigineFormeDessin(self, coord):
+        """place le point d'origine de la forme de selection"""
+        self.modeParam["listeCasesFormeDessin"] = []
+        self.modeParam["origineFormeDessin"] = self.cases[coord].centreGraphique
+        self.modeParam["point2FormeDessin"] = self.cases[coord].centreGraphique
+        self.modeParam["listeCasesFormeDessin"] = [coord]
+        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
+        
+    def majFormeDessin(self):
+        """cree/maj la forme utilisee pour selectionner les cases et met a jour la liste des cases selectionnes"""
+        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
+        
+        pinceau = QPen()
+        pinceau.setColor(QColor("black"))
+        point2 = self.modeParam["point2FormeDessin"]
+        
+        if self.modeParam["typeFormeDessin"] == "simple":
+            #pas de forme: on ajoute les cases survolees a la liste des cases
+            coordPoint2 = self.coordonneesAuPoint(point2)
+            zone = self.zone(coordPoint2, self.epaisseurPinceau-1)
+            for coord in zone:
+                if not coord in self.modeParam["listeCasesFormeDessin"]:
+                    self.modeParam["listeCasesFormeDessin"].append(coord)
+
+        elif self.modeParam["typeFormeDessin"] == "frontiere":
+            #droite qui selectionne toutes les cases situees au dessus d'elle
+            if self.modeParam["formeDessin"] == None:
+                self.modeParam["formeDessin"] = QGraphicsLineItem()
+                self.modeParam["formeDessin"].setPen(pinceau)
+                self.addItem(self.modeParam["formeDessin"])    
+            ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
+            orientation = int((1+int(ligne.angle()/22.5))/2)
+            ligne.setAngle(orientation*45)
+            self.modeParam["formeDessin"].setLine(ligne)
+            self.modeParam["listeCasesFormeDessin"] = self.selectionFrontiere()
+
+        else:    
+            if self.modeParam["typeFormeDessin"] == "ligne":
+                #segment simple
+                if self.modeParam["formeDessin"] == None:
+                    self.modeParam["formeDessin"] = QGraphicsLineItem()
+                    self.modeParam["formeDessin"].setPen(pinceau)
+                    self.modeParam["formeDessin"].prepareGeometryChange()
+                    self.addItem(self.modeParam["formeDessin"])
+                ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
+                self.modeParam["formeDessin"].setLine(ligne)
+            
+            elif self.modeParam["typeFormeDessin"] == "rectV" or self.modeParam["typeFormeDessin"] == "rectP":
+                #rectangle
+                if self.modeParam["formeDessin"] == None:
+                    self.modeParam["formeDessin"] = QGraphicsRectItem()
+                    self.modeParam["formeDessin"].prepareGeometryChange()
+                    self.modeParam["formeDessin"].setPen(pinceau)
+                    self.addItem(self.modeParam["formeDessin"])
+                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
+                self.modeParam["formeDessin"].setRect(rect)
+            
+            elif self.modeParam["typeFormeDessin"] == "ellipseV" or self.modeParam["typeFormeDessin"] == "ellipseP":
+                #ellipse
+                if self.modeParam["formeDessin"] == None:
+                    self.modeParam["formeDessin"] = QGraphicsEllipseItem()
+                    self.modeParam["formeDessin"].prepareGeometryChange()
+                    self.modeParam["formeDessin"].setPen(pinceau)
+                    self.addItem(self.modeParam["formeDessin"])
+                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
+                self.modeParam["formeDessin"].setRect(rect)
+
+            #on liste les cases intersectant la forme
+            plein = (self.modeParam["typeFormeDessin"][len(self.modeParam["typeFormeDessin"])-1:] == "P")
+            self.modeParam["listeCasesFormeDessin"] = self.casesSousForme(self.modeParam["formeDessin"], plein, self.epaisseurPinceau - 1)      
+        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
+
+    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()            
+ 
+        #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 selectionFrontiere(self):
+        """retourne les cases selectionnees lors de l'utilisation de la forme 'frontiere'"""
+        listeCases = []
+        ligne = self.modeParam["formeDessin"].line()
+        normale = ligne.normalVector()
+        normale = normale.unitVector()
+        coordOrigine = self.coordonneesAuPoint(self.modeParam["origineFormeDessin"])
+        dx = normale.p2().x() - normale.p1().x()
+        dy = normale.p2().y() - normale.p1().y()
+        for coord in self.cases:
+            if dx < 0 and dy == 0:  #normale pointe vers la gauche
+                if (coord[0] - coordOrigine[0]) <= 0:
+                    listeCases.append(coord)
+            if dx > 0 and dy == 0:  #normale pointe vers la droite
+                if (coord[0]  - coordOrigine[0]) >= 0:
+                    listeCases.append(coord)   
+            if dx == 0 and dy < 0:  #pointe vers le haut (rappel: axe y vers le bas)
+                if (coord[1] - coordOrigine[1]) <= 0:
+                    listeCases.append(coord)
+            elif dx == 0 and dy > 0:  #pointe vers le bas
+                if (coord[1] - coordOrigine[1]) >= 0:
+                    listeCases.append(coord)
+            if dx > 0 and dy < 0:  #pointe vers le haut droite
+                if (coord[0] - coordOrigine[0]) + -1*(coord[1] - coordOrigine[1]) >= 0:
+                    listeCases.append(coord)
+            elif dx > 0 and dy > 0:  #pointe vers le bas droite
+                if -1*(coord[0] - coordOrigine[0]) + -1*(coord[1] - coordOrigine[1]) <= 0:
+                    listeCases.append(coord)
+            if dx < 0 and dy < 0:  #pointe vers le haut gauche
+                if (coord[0] - coordOrigine[0]) + (coord[1] - coordOrigine[1]) <= 0:
+                    listeCases.append(coord)
+            elif dx < 0 and dy > 0:  #pointe vers le bas gauche
+                if -1*(coord[0] - coordOrigine[0]) + (coord[1] - coordOrigine[1]) >= 0:
+                    listeCases.append(coord)
+        return listeCases
+        
+    def validerFormeDessin(self):
+        """la projection des cases a peindre a ete acceptee, on peint ces cases"""
+        if self.modeActif[0:7] == "caseMaj" or self.modeActif == "caseCopie" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
+            self.majListeCases(self.modeParam["listeCasesFormeDessin"])
+        self.majMode(self.modeActif)    
+##        self.majMode("standard")
+            
+    def rectFormeDessin(self, point1, point2):
+        """retourne le rectangle repesentant la forme de selection
+           determine pour ce faire les points A et B, cad le point haut-droit et le point bas-gauche"""
+        pointA = QPointF(min(point1.x(), point2.x()), min(point1.y(), point2.y()))
+        pointB = QPointF(max(point1.x(), point2.x()), max(point1.y(), point2.y()))             
+        rect = QRectF(pointA, pointB)
+        return rect
+
+    def majLigneMireAttaqueDist(self, coordCible = None):
+        """met a jour la ligne de mire representant l'attaque a distance"""
+        if self.modeParam["cibleAttaqueDist"] != None and self.modeParam["cibleAttaqueDist"] != coordCible:
+            self.cases[self.modeParam["cibleAttaqueDist"]].majEstCibleCurseur(False)
+##        if self.modeParam["pionCibleAttaqueDist"] != None and self.modeParam["pionCibleAttaqueDist"] != self.cases[coordCible].pionOccupant():
+        if self.modeParam["pionCibleAttaqueDist"] != None:
+            self.modeParam["pionCibleAttaqueDist"].estCibleAttaque(False)
+            
+        if coordCible != None and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":
+            if coordCible == None:
+                coordCible = pion.position
+                
+            if coordCible != self.modeParam["cibleAttaqueDist"]:
+                if self.modeParam["ligneAttaqueDist"] == None:
+                    self.modeParam["ligneAttaqueDist"] = QGraphicsLineItem()
+                    self.modeParam["ligneAttaqueDist"].setZValue(100)
+                    pinceau = QPen()
+                    pinceau.setWidth(6)
+                    self.modeParam["ligneAttaqueDist"].setPen(pinceau)
+                    self.modeParam["ligneAttaqueDist"].prepareGeometryChange()
+                    self.addItem(self.modeParam["ligneAttaqueDist"])
+
+                z = 0
+                pionSurCase = self.cases[coordCible].pionOccupant()
+                if pionSurCase != None:
+                    z = pionSurCase.z
+                cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible, z)
+
+                if pionSurCase != None:
+                    pionSurCase.estCibleAttaque(True, cibleValide)
+                    self.modeParam["pionCibleAttaqueDist"] = pionSurCase
+                else:
+                    self.cases[coordCible].majEstCibleCurseur(True, cibleValide)
+                self.modeParam["cibleAttaqueDist"] = coordCible
+                    
+                point1 = self.cases[self.pionSelectionne().position].centreGraphique
+                point2 = self.cases[coordCible].centreGraphique
+                ligne = QLineF(point1, point2)
+                self.modeParam["ligneAttaqueDist"].setLine(ligne)
+        else:
+            if self.modeParam["ligneAttaqueDist"] != None:
+                self.modeParam["ligneAttaqueDist"].prepareGeometryChange()
+                self.removeItem(self.modeParam["ligneAttaqueDist"])
+            self.modeParam["ligneAttaqueDist"] = None
+            self.modeParam["cibleAttaqueDist"] = None
+            
+##        if pion == None:
+##            self.modeParam["pionCibleAttaqueDist"] = None
+                
+    def estCibleAttaqueDistValide(self, coordOrigine, coordCible, zPion = 0):
+         """la case cible est elle valide pour une attaque a distance depuis la position et hauteur
+            du pion selectionne? on compare pour ce faire les altitudes des cases sur la ligne de mire"""
+         casesLigneMire = []
+         #on preselectionne les cases concernees
+         preSelection = self.preSelectionCollision(self.cases[coordOrigine].centreGraphique, self.cases[coordCible].centreGraphique)
+         if coordOrigine in preSelection:
+             preSelection.remove(coordOrigine)
+         if coordCible in preSelection:
+             preSelection.remove(coordCible)    
+         for coord in preSelection:
+             ligne = QLineF(self.cases[coordOrigine].centreGraphique, self.cases[coordCible].centreGraphique)
+             ligneGraphique = QGraphicsLineItem(ligne)
+             ligneGraphique.prepareGeometryChange()
+             self.addItem(ligneGraphique)
+             if self.cases[coord].collidesWithItem(ligneGraphique, Qt.IntersectsItemShape):
+                  casesLigneMire.append(coord)
+             self.removeItem(ligneGraphique)     
+             del ligneGraphique     
+
+         #on trie les cases par distance au point d'origine (de la plus proche a la plus eloignee)
+         casesLigneMireDistance = {} #distance: coord
+         for coord in casesLigneMire:
+             distance = sqrt((coordOrigine[0] - coord[0])**2 + (coordOrigine[1] - coord[1])**2)
+             casesLigneMireDistance[coord] = distance
+
+         #on compare enfin les altitudes de chaque case en fonction de la distance
+         zOrigine = self.cases[coordOrigine].altitude + self.pionSelectionne().z + self.pionSelectionne().creature.hauteur 
+         zCible = self.cases[coordCible].altitude + zPion
+         distanceTot = sqrt((coordCible[0] - coordOrigine[0])**2 + (coordCible[1] - coordOrigine[1])**2)
+         valide = True
+         for coord in casesLigneMireDistance:
+              if self.cases[coord].terrain.visibilite == False:
+                  valide = False
+                  break
+              else:  
+                  if zOrigine >= zCible:
+                      z = (zOrigine - zCible) * (casesLigneMireDistance[coord] / distanceTot)
+                  else:
+                      z = (zCible - zOrigine) * ((distanceTot - casesLigneMireDistance[coord]) / distanceTot)
+                  if self.cases[coord].estOccupee(int(z)):
+                      if self.modeParam["pionCibleAttaqueDist"] != None:
+                          if self.cases[coord].estOccupeePar(int(z)) != self.modeParam["pionCibleAttaqueDist"]:
+                              valide = False
+                      else:        
+                          valide = False
+                      break
+         return valide       
+
+    def validerAttaqueDist(self):
+        """on essaie de valider une attaque a distance vers un pion ou une case"""
+        if self.modeParam["pionCibleAttaqueDist"] != None:
+            msg = "{} attaque a distance le pion {}".format(self.pionSelectionne().txtId(),
+                                                              self.modeParam["pionCibleAttaqueDist"].txtId())
+            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"], self.modeParam["pionCibleAttaqueDist"].z)
+        else:
+            msg = "{} attaque a distance la case {}".format(self.pionSelectionne().txtId(), 
+                                                              self.modeParam["cibleAttaqueDist"])
+            valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"])
+        if not valide:
+            msg += " [INVALIDE]"
+        print(msg)
+        self.majModeCombat("aucun")
+
+
+    def rectEllipseCirculaire(self, centre, rayon):
+        """renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param
+           attention: l'ellipse n'est pas tout a fait circulaire, elle couvre horizontalement et
+           verticalement le nombre de cases demandees"""
+        rect = QRectF()
+        if rayon > 0:
+            p1 = QPointF((centre.x() - (rayon*self.hCase)), (centre.y() - (rayon*self.hCase)))
+            p2 = QPointF((centre.x() + (rayon*self.hCase)), (centre.y() + (rayon*self.hCase)))
+            rect.setTopLeft(p1)
+            rect.setBottomRight(p2)
+        else:
+            rect = None
+        return rect
+
+    def polygoneCone(self, point1, point2):
+        """renvoie le polygone du cone defini par les deux points (origine, distance)"""
+        ligne1 = QLineF(point1, point2)
+        longueur = ligne1.length()
+        ligne1.setAngle(ligne1.angle() + 22.5)
+        ligne1.setLength(1.1547*longueur)
+        ligne2 = QLineF(point1, point2)    
+        ligne2.setAngle(ligne2.angle() - 22.5)
+        ligne2.setLength(1.1547*longueur)
+        polygone = QPolygonF()
+        polygone.append(point1)
+        polygone.append(ligne1.p2())
+        polygone.append(ligne2.p2())
+        return polygone
+
+    def majFormeAttaqueZone(self):
+        """cree la forme de l'attaque de zone"""
+        for coord in self.modeParam["listeCasesAttaqueZone"]:
+            self.cases[coord].majEstCibleAttaque(False)
+        for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+             self.pions[numPion].estCibleAttaque(False)
+        
+        if self.modeCombat == "combatAttaqueZone" and self.pionSelectionne() != None:
+            if self.modeParam["typeAttaqueZone"] == "ligne":
+                if self.modeParam["formeAttaqueZone"] == None:
+                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["formeAttaqueZone"] = QGraphicsLineItem()
+                    self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
+                    self.modeParam["formeAttaqueZone"].prepareGeometryChange()
+                    self.addItem(self.modeParam["formeAttaqueZone"])
+                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: 
+                    ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
+                    self.modeParam["formeAttaqueZone"].setLine(ligne)
+                    self.modeParam["listeCasesAttaqueZone"] = []
+                    lst = self.casesSousForme(self.modeParam["formeAttaqueZone"],False)
+                    for coord in lst:
+                        self.modeParam["listeCasesAttaqueZone"].append(coord)                
+                    #on retire la case du pion selectionne si besoin:
+                    if self.pionSelectionne().position in self.modeParam["listeCasesAttaqueZone"]:
+                        self.modeParam["listeCasesAttaqueZone"].remove(self.pionSelectionne().position)
+                                                 
+            elif self.modeParam["typeAttaqueZone"] == "disque":
+                if self.modeParam["ligneMireAttaqueZone"] == None:
+                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["ligneMireAttaqueZone"] = QGraphicsLineItem()
+                    self.modeParam["ligneMireAttaqueZone"].setPen(QPen(QColor("black")))
+                    self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange()
+                    self.addItem(self.modeParam["ligneMireAttaqueZone"])
+   
+                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: 
+                    ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
+                    self.modeParam["ligneMireAttaqueZone"].setLine(ligne)
+                    coordCible = self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])
+                    cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible)
+                    
+                    if cibleValide:
+                        rayon = self.fenetre.ui.combatZone_disqueRayon.value()
+                        if self.modeParam["formeAttaqueZone"] == None:
+                            self.modeParam["formeAttaqueZone"] = QGraphicsEllipseItem()
+                            self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
+                            self.modeParam["formeAttaqueZone"].prepareGeometryChange()
+                            self.addItem(self.modeParam["formeAttaqueZone"])
+                        rect = self.rectEllipseCirculaire(self.modeParam["point2AttaqueZone"], rayon)
+                        self.modeParam["listeCasesAttaqueZone"] = []
+                        if rect != None and rect.bottomRight() != rect.topLeft():
+                            self.modeParam["formeAttaqueZone"].setRect(rect)
+                            lst = self.zone(coordCible, rayon, 0)   #zone bcp plus rapide que casesSousforme
+                            self.modeParam["listeCasesAttaqueZone"] = lst
+                    else:
+                        self.cases[coordCible].majEstCibleCurseur(True, False)
+                        self.modeParam["listeCasesAttaqueZone"] = []
+                    
+                    if self.modeParam["formeAttaqueZone"] != None:        
+                        self.modeParam["formeAttaqueZone"].setVisible(cibleValide == True and rect != None)    
+                
+            elif self.modeParam["typeAttaqueZone"] == "cone":
+                if self.modeParam["formeAttaqueZone"] == None:
+                    self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique
+                    self.modeParam["formeAttaqueZone"] = QGraphicsPolygonItem()
+                    self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black")))
+                    self.modeParam["formeAttaqueZone"].prepareGeometryChange()
+                    self.addItem(self.modeParam["formeAttaqueZone"])
+                    
+                if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]:
+                    cone = self.polygoneCone(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"])
+                    self.modeParam["formeAttaqueZone"].setPolygon(cone)
+                    lst = self.casesSousForme(self.modeParam["formeAttaqueZone"], True, True)
+                    self.modeParam["listeCasesAttaqueZone"] = []
+                    for coord in lst:
+                        if coord != self.pionSelectionne().position:
+                            self.modeParam["listeCasesAttaqueZone"].append(coord)
+
+            for coord in self.modeParam["listeCasesAttaqueZone"]:
+                self.cases[coord].majEstCibleAttaque(True)
+            for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+                self.pions[numPion].estCibleAttaque(True)
+
+
+    def validerAttaqueZone(self):
+        """l'attaque de zone est validee"""
+        if self.modeActif == "pionSelectionne" and self.modeCombat == "combatAttaqueZone":
+            for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+                print("{} a lance une attaque de zone sur {}".format(self.pionSelectionne().nom, self.pionSelectionne().numero , \
+                                                                     self.pions[numPion].nom, self.pions[numPion].numero))
+        self.majModeCombat("aucun")        
+
+    def reinitAttaqueZone(self):
+        if self.modeParam["formeAttaqueZone"] != None:
+            self.modeParam["formeAttaqueZone"].prepareGeometryChange()
+            self.removeItem(self.modeParam["formeAttaqueZone"])
+            self.modeParam["formeAttaqueZone"] = None
+        if self.modeParam["ligneMireAttaqueZone"] != None:
+            self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange()
+            self.removeItem(self.modeParam["ligneMireAttaqueZone"])
+            self.modeParam["ligneMireAttaqueZone"] = None
+        if self.modeParam["point2AttaqueZone"] != None:
+            self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False)
+        for coord in self.modeParam["listeCasesAttaqueZone"]:
+            self.cases[coord].majEstCibleAttaque(False)
+        for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+            self.pions[numPion].estCibleAttaque(False)
+                      
+    def pionSurCase(self, coord):
+        """renvoie le pion present sur la case, none sinon"""
+        retour = None
+        for num in self.pions:
+            if self.pions[num].position == coord:
+                retour = num
+        return retour        
+
+    def pionsSurListeCase(self, listeCases):
+        """renvoie la liste des pions presents sur la liste de cases"""
+        retour = []
+        for coord in listeCases:
+            pion = self.cases[coord].pionOccupant()
+            if pion != None and not pion.numero in retour:
+                retour.append(pion.numero)
+        return retour   
+
+    def majZonePlacement(self, listeCases):
+        """met a jour la forme et l'affichage de la zone de placement initale des joueurs"""
+        if len(listeCases) > 0:
+            if self.polygoneZonePlacement == None:
+                self.polygoneZonePlacement = QGraphicsPolygonItem(scene=self)
+                self.polygoneZonePlacement.setZValue(0)
+                qCouleurFond = QColor("white")
+                qCouleurFond.setAlpha(50)
+                self.polygoneZonePlacement.setBrush(qCouleurFond)
+                pinceau = QPen(QColor("orange"))
+                pinceau.setWidth(20)
+                self.polygoneZonePlacement.setPen(pinceau)
+                self.polygoneZonePlacement.setAcceptedMouseButtons(Qt.NoButton)
+                self.polygoneZonePlacement.setAcceptHoverEvents(False)
+                self.addItem(self.polygoneZonePlacement)
+            listeCases2 = []    
+            for coord in listeCases:
+                if self.cases[coord].estFranchissable():
+                    listeCases2.append(coord)
+            self.polygoneZonePlacement.setPolygon(self.polygoneAgglo(listeCases2))
+            self.listeCasesZonePlacement = listeCases
+
+    def materialiserPions(self,actif):
+        """avtive/desactive la reception par les pions (autres que le pion selectionne) des hover events"""
+        for numPion in self.pions:
+            if numPion != self.modeParam["numPionSelectionne"]:
+                self.pions[numPion].setAcceptsHoverEvents(actif)
+                self.pions[numPion].polygoneGraphique.setAcceptsHoverEvents(actif)
+        for numPion in self.decors:
+            self.decors[numPion].setAcceptsHoverEvents(actif)
+            self.decors[numPion].polygoneGraphique.setAcceptsHoverEvents(actif)
+                
+    #######################
+
+    ######## interaction avec les cases, decors et pions  #############
+    def pionSelectionne(self):
+        """renvoie le pion actuellement selectionne"""
+        if self.modeParam["numPionSelectionne"] in self.pions:
+            retour = self.pions[self.modeParam["numPionSelectionne"]]
+        else:
+            retour = None
+        return retour    
+
+    def pionDecorSelectionne(self):
+        """renvoie le pion actuellement selectionne"""
+        if self.modeParam["numPionSelectionne"] in self.decors:
+            retour = self.decors[self.modeParam["numPionSelectionne"]]
+        else:
+            retour = None
+        return retour    
+            
+    def caseCliquee(self, coord):
+        """on a clique sur la case (clic gauche)"""
+        accepte = False
+        if coord in self.cases:
+            case = self.cases[coord]
+            if self.modeActif == "caseCopie":
+                if len(case.terrain.nom) > 0:
+                     self.majMode("caseMajTerrain", case.terrain)
+                     accepte = True
+                else:
+                     self.majMode("caseMajTerrain", case.couleur)
+                     accepte = True
+                 
+            elif self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
+                self.creerOrigineFormeDessin(coord)
+                accepte = True
+                
+            elif self.modeActif == "pionDecorSelectionne":
+                if coord != self.pionDecorSelectionne().position:
+                    self.pionDeposer(coord)
+                    accepte = True
+                    
+            elif self.modeActif == "pionSelectionne":
+                if self.modeCombat == "combatDeplacement":
+                    if self.pionSelectionne() != None:
+                        if coord != self.pionSelectionne().position:
+                            self.pionDeposer(coord)
+                            accepte = True
+                elif self.modeCombat == "combatAttaqueCaC":
+                    if self.modeParam["cibleAttaqueCaC"] in self.modeParam["zoneAttaqueCaC"]:
+                        print("{} attaque {} au corps a corps".format(self.pionSelectionne().nom, self.modeParam["cibleAttaqueCaC"]))
+                        self.majMode("pionSelectionne", None)
+                        accepte = True
+                    else:
+                        print("cette case est invalide pour une corps a corps")
+                        accepte = True
+                elif self.modeCombat == "combatAttaqueDist":
+                    self.validerAttaqueDist()
+                    accepte = True
+                        
+                elif self.modeCombat == "combatAttaqueZone":
+                    self.validerAttaqueZone()
+                    accepte = True
+                    
+            elif self.modeActif == "pionCreation":
+                self.pionCreer(coord)
+                accepte = True
+                
+            elif self.modeActif == "pionDecorCreation":
+                self.pionDecorCreer(coord)
+                accepte = True    
+        return accepte       
+
+    def caseSurvolClicEnfonce(self, coordCase):
+        """une case est survolee par le curseur (le clic gauche est enfonce)"""
+        if self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
+            if self.cases[coordCase].centreGraphique != self.modeParam["point2FormeDessin"]:
+                if self.modeParam["origineFormeDessin"] == None: self.modeParam["origineFormeDessin"] = self.cases[coordCase].centreGraphique
+                self.modeParam["point2FormeDessin"] = self.cases[coordCase].centreGraphique
+                self.majFormeDessin()
+
+    def clicGaucheRelache(self):
+       """si une forme de selection etait affichee, elle est validee""" 
+       if len(self.modeParam["listeCasesFormeDessin"]) > 0:
+            self.validerFormeDessin()
+
+    def caseSurvol(self, case):
+        """une case est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        self.majInfosCase(case)
+        if (self.modeActif == "pionSelectionne" and self.modeCombat == "combatDeplacement") or self.modeActif == "pionCreation"\
+           or self.modeActif == "pionDecorSelectionne" or self.modeActif == "pionDecorCreation":
+            self.majProjectionPosition(False)
+            self.modeParam["coordProjectionPosition"] = (case.x, case.y)
+            self.majProjectionPosition(True)
+        elif self.modeActif == "pionSelectionne" and self.modeCombat == "combatAttaqueDist" and self.modeParam["cibleAttaqueDist"] != (case.x, case.y):
+            self.majLigneMireAttaqueDist((case.x,case.y))
+        elif self.modeActif == "pionSelectionne" and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueZone":
+            if case.centreGraphique != self.modeParam["point2AttaqueZone"]:
+                self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False)
+                self.modeParam["point2AttaqueZone"] = case.centreGraphique
+                self.majFormeAttaqueZone()                       
+
+    def afficherListeCases(self, listeCases, actif):
+        """met ou non en evidence les cases selectionnees"""
+        for coord in listeCases:
+            self.cases[coord].majEstCibleCurseur(actif)
+        
+    def majListeCases(self, listeCases):
+        """met a jour les cases dont les coordonnees sont dans la liste"""
+        self.afficherListeCases(listeCases, False)    
+            
+        if self.modeActif[0:7] == "caseMaj":
+            for coord in listeCases:
+                self.caseMaj(coord)
+        elif self.modeActif == "cachePlacer":
+            self.majAffichageCache(self.cacheEnCours, False)
+            self.caches[self.cacheEnCours]["listeCases"] = listeCases
+            self.majAffichageCache(self.cacheEnCours, True)
+        elif self.modeActif == "majZonePlacement":
+            self.majZonePlacement(listeCases)
+
+    def caseMaj(self, coordCase):
+        """met a jour la case selon le mode actif (et les cases adjacentes selon l'epaisseur du pinceau)"""
+        if self.modeActif == "caseMajTerrain":
+            if self.modeParam["terrain"] != None:
+                if self.modeParam["terrain"].__class__.__name__ == "Terrain":
+                     self.cases[coordCase].majTerrain(self.modeParam["terrain"])
+                elif self.modeParam["terrain"].__class__.__name__ == "QColor":
+                     if self.modeParam["terrain"].isValid():
+                         self.cases[coordCase].majTerrain(None)
+                         self.cases[coordCase].majCouleur(self.modeParam["terrain"])
+                self.cases[coordCase].majAltitude(int(self.fenetre.ui.altitudeCase.value()))
+        elif self.modeActif == "caseMajEffet":
+            self.cases[coordCase].majEffet(self.modeParam["effet"])
+        elif self.modeActif == "caseMajAltitude":
+            self.cases[coordCase].majAltitude(int(self.fenetre.ui.altitudeCase.value()))
+        
+    def majInfosCase(self, case=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if case != None:
+            if len(case.terrain.nom) > 0:
+                self.fenetre.ui.infoCaseEnCours_terrain.setText(QString.fromUtf8(case.terrain.nom))
+            else:
+                self.fenetre.ui.infoCaseEnCours_terrain.setText(QString.fromUtf8("Case"))
+            self.fenetre.ui.infoCaseEnCours_coord.setText(QString.fromUtf8("X: {}  Y: {}".format(case.x, case.y)))
+            self.fenetre.ui.infoCaseEnCours_altitude.setText(QString.fromUtf8("Alt.: {}".format(case.altitude)))
+            if case.effetActif != "":
+                pix = QPixmap(QString.fromUtf8("img\\"+case.imgEffet[case.effetActif]))
+                pix = pix.scaled(21, 21, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.infoCaseEnCours_effetImg.setPixmap(pix)                
+                self.fenetre.ui.infoCaseEnCours_effetNom.setText(QString.fromUtf8(case.effetActif))
+            else:
+                self.fenetre.ui.infoCaseEnCours_effetImg.clear()
+                self.fenetre.ui.infoCaseEnCours_effetNom.clear()
+            self.fenetre.ui.infoCase.setVisible(True)
+        else:
+            self.fenetre.ui.infoCase.setVisible(False)
+
+    def pionClique(self, numPion):
+        """on a clique sur ce pion"""
+        accepte = False
+        if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":    
+            self.validerAttaqueDist()
+            accepte = True
+            
+        elif self.modeActif == "standard" and self.pionSelectionne() == None:
+            self.pionSaisir(numPion)
+            accepte = True
+        return accepte    
+
+    def pionSurvol(self, numPion):
+        """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        if numPion in self.pions:
+            pion = self.pions[numPion]
+        else:
+            pion = None
+        self.majInfosPion(pion)
+        if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueCaC":
+            self.majProjectionAttaqueCaC(pion)
+            pass
+        if numPion in self.pions:
+            case = self.cases[self.pions[numPion].position]
+            self.caseSurvol(case)
+
+    def pionDoubleClic(self, numPion):
+        """on a double-clique sur le pion"""
+        accepte = False
+        if self.pionSelectionne() == self.pions[numPion] and self.modeCombat == "aucun":
+##            self.pionSaisir(numPion)
+            self.majModeCombat("combatDeplacement")
+            accepte = True
+        return accepte          
+
+    def pionCreer(self, coordCase):
+        """creer un jeton aux coordonnees indiquees"""
+        valide = True
+        for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase):
+            if not coord in self.cases:
+                valide = False
+            else:    
+                 if not self.cases[coord].estFranchissable():
+                      valide = False
+        if valide:
+            numero = 1
+            if len(self.pions) > 0:
+                numero = max(self.pions) + 1   
+            pion = Pion(self, numero)
+            if self.modeParam["creature"] != None:
+                nom = self.modeParam["creature"].nom
+            elif len(self.fenetre.ui.pionSimple_nom.text().toUtf8()) > 0:
+                nom = self.fenetre.ui.pionSimple_nom.text().toUtf8()            
+            numTxt = self.numeroterNom(nom)
+            self.pions[numero] = pion
+            pion.creer(coordCase[0], coordCase[1], nom, numTxt, self.modeParam["creature"], self.modeParam["couleurPion"], self.modeParam["nbRotations"])
+            self.pionDeplacerDansOrdreJeu(numero, len(self.ordreJeu) + 2)
+
+    def numeroterNom(self, nom):
+        """renvoie le nom du pion avec un numero complementaire si necessaire """
+        i = 1
+        for numPion in self.pions:
+            if self.pions[numPion].nom == nom:
+                i += 1     
+        if i == 1:
+            retour = ""
+        else:
+            retour = str(i)
+        return retour
+    
+    def pionSaisir(self, numPion):
+        """on saisit un pion"""
+        if numPion != self.modeParam["numPionSelectionne"]:
+            self.majMode("pionSelectionne", numPion)
+        
+    def pionDeposer(self, coordCase):
+        """on depose le pion sur la case voulue"""
+        if self.pionSelectionne() != None:
+            pion = self.pionSelectionne()
+        else:
+            pion = self.pionDecorSelectionne()
+        
+        if pion != None:
+           valide = True
+           for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase, self.modeParam["nbRotations"]):
+               if coord in self.cases:
+                    if not self.cases[coord].estFranchissable(pion.z):
+                        if not self.cases[coord].estOccupeePar(pion.z) == pion:
+                             #si la case est occupee par le pion qu'on depose, elle est donc valide pour un deplacement  
+                             valide = False
+               else:
+                   valide = False
+           if valide:        
+               positionPrecedente = pion.position 
+               #mise a jour de la position du pion selon le mode
+               if self.modePrincipal == "combat":
+##                   if coordCase in pion.champDeplacement:
+##                       print("le pion a ete deplace de {} vers {} \n    -> soit une distance de {} cases"\
+##                             "".format(positionPrecedente, coordCase, self.pionSelectionne().champDeplacement[coordCase]))
+                   self.majInfosPion()
+               pion.majPosition(coordCase, self.modeParam["nbRotations"])
+               self.majModeCombat("aucun")
+           else:
+               print("Deplacement impossible!")
+
+    def afficherChampDeplacement(self, actif):
+        """cree et affiche ou efface et detruit le champ de deplacement du pion selectionne"""
+        if self.pionSelectionne() != None:
+            if actif:
+                self.pionSelectionne().champDeplacement = self.zone(self.pionSelectionne().position, \
+                                                                           self.pionSelectionne().deplacementRestant, \
+                                                                           True)
+            for coord in self.pionSelectionne().champDeplacement:
+                 self.cases[coord].majEstDansChampDeplacement(actif)
+             
+            if not actif:
+                self.pionSelectionne().champDeplacement = {}
+            
+    def majInfosPion(self, pionSurvole=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if pionSurvole != None:
+            pion = pionSurvole
+        else:
+            if self.pionSelectionne() != None:
+                pion = self.pionSelectionne()
+            else:
+                pion = None
+
+        if pion != None:  
+            self.fenetre.ui.infoPionEnCours_nom.setText(QString.fromUtf8(pion.nom))
+            self.fenetre.ui.infoPionEnCours_depRestant.setText(QString.fromUtf8("Dep.: {}".format(pion.deplacementRestant)))
+            if len(pion.creature.img["nom"]) > 0:
+                pix = QPixmap(QString.fromUtf8("img\\"+pion.creature.img["nom"]))
+                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.infoPionEnCours_image.setPixmap(pix)
+            self.fenetre.ui.infoPion.setVisible(True)
+            self.fenetre.ui.infoPionEnCours_etourdi.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_brule.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_mouille.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_vol.setVisible((pion.z != 0))
+            self.fenetre.ui.infoPionEnCours_endormi.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_paralyse.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_entrave.setVisible(False)
+            self.fenetre.ui.infoPionEnCours_mort.setVisible(False)
+        else:
+            self.fenetre.ui.infoPion.setVisible(False)
+
+    def majZPion(self, valeur):
+        """met a jour l'altitude du pion selectionne"""
+        if self.pionSelectionne() != None:
+            self.pionSelectionne().majZ(valeur)
+
+
+    def pionDecorSurvol(self, numPionDecor):
+        """le pion-decor est survole par le curseur, on affiche ses informations dans la zone prevue"""
+        if numPionDecor in self.decors:
+            self.majInfosDecor(self.decors[numPionDecor])
+        else:
+            self.majInfosDecor(None)
+
+    def pionDecorSaisir(self, numPionDecor):
+        """on saisit un pion decor (mode creation seulement)"""
+        if numPionDecor != self.modeParam["numPionSelectionne"]:
+            self.majMode("pionDecorSelectionne", numPionDecor)
+
+    def majInfosDecor(self, pionDecor=None):
+        """met a jour les informations d'un pion dans la zone prevue"""
+        if pionDecor != None:  
+            self.fenetre.ui.infoDecorEnCours_nom.setText(QString.fromUtf8(pionDecor.decor.nom))
+            self.fenetre.ui.infoDecorEnCours_hauteur.setText(QString.fromUtf8("Haut.: {}".format(pionDecor.decor.hauteur)))
+            if len(pionDecor.decor.img["nom"]) > 0:
+                pix = QPixmap(QString.fromUtf8("img\\"+pionDecor.decor.img["nom"]))
+                pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.fenetre.ui.infoDecorEnCours_image.setPixmap(pix)
+            self.fenetre.ui.infoDecor.setVisible(True)
+        else:
+            self.fenetre.ui.infoDecor.setVisible(False)
+
+    def majProjectionPosition(self, activer, z=0):
+        """maj l'affichage de la projection de la position d'un objet avant creation ou deplacement (pion, decor...)"""
+        valide = True
+        possible = True
+
+        if self.modeParam["formeProjectionPosition"] != None and self.modeParam["coordProjectionPosition"] != None:
+            proj = self.modeParam["formeProjectionPosition"].listeCases(self.modeParam["coordProjectionPosition"], self.modeParam["nbRotations"])
+                 
+            for coord in proj:
+                if not coord in self.cases:
+                    valide = False   #deplacement valide? (pas d'occupation d'une case hors plateau)
+    
+            if valide == True:
+                for coord in proj:
+                    if self.cases[coord].estFranchissable(z) or self.cases[coord].estOccupeePar(z) == self.pionSelectionne():
+                    #la case est franchissable, ou elle ne l'est pas mais est occupée par le pion meme qu'on deplace
+                        self.cases[coord].majEstCibleCurseur(activer, True)
+                             
+                        #on affiche la distance correspondante en bulle-info
+                        if activer and self.modeActif == "pionSelectionne" and self.modePrincipal == "combat":
+                             if coord in self.pionSelectionne().champDeplacement:
+                                  msg = "Distance {}".format(self.pionSelectionne().champDeplacement[coord])
+                                  QToolTip.showText(QCursor.pos(), msg, self.fenetre.ui.vuePlateau)
+                    else:
+                        self.cases[coord].majEstCibleCurseur(activer, False)
+
+
+    def majProjectionAttaqueCaC(self, pionCible):
+        """affiche ou non la cible de l'attaque au corps a corps, selon sa validite ou non"""
+        if self.modeActif == "pionSelectionne" and self.modeCombat == "combatAttaqueCaC":
+            if pionCible != self.pionSelectionne():
+                if pionCible != None:
+                    conditionPossible = (pionCible.position in self.modeParam["zoneAttaqueCaC"])
+                    pionCible.estCibleAttaque(True, conditionPossible)
+                else:
+                    if self.modeParam["cibleAttaqueCaC"] != None:
+                        self.modeParam["cibleAttaqueCaC"].estCibleAttaque(False)
+                self.modeParam["cibleAttaqueCaC"] = pionCible
+             
+
+    def majZoneAttaqueCaC(self, actif = True):
+        """affiche ou non les cases a portee du pion selectionne pour une attaque au corps-a-corps"""
+        for coord in self.modeParam["zoneAttaqueCaC"]:
+            self.cases[coord].majEstDansChampDeplacement(actif)
+
+    def pionDecorCreer(self, coordCase):
+        """creer un jeton aux coordonnees indiquees"""
+        valide = True
+        for coord in self.modeParam["formeProjectionPosition"].listeCases(coordCase, self.modeParam["nbRotations"]):
+            if not self.cases[coord].estFranchissable():
+                 valide = False
+        if valide:  
+            numero = 10001
+            if len(self.decors) > 0:
+                numero = max(self.decors) + 10001 
+            pionDecor = PionDecor(self, numero)
+            pionDecor.creer(coordCase[0], coordCase[1], self.modeParam["decor"], self.modeParam["nbRotations"])
+            self.decors[numero] = pionDecor
+ 
+    def pionSupprimer(self, num):
+        """supprime le pion entre en parametre"""
+        #settrace(trace_calls)
+        if num in self.pions:    
+            for coord in self.pions[num].forme.listeCases(self.pions[num].position, self.pions[num].nbRotations):
+                 self.cases[coord].majOccupation(self.pions[num])
+            self.pionSurvol(None)     
+            self.pionDeplacerDansOrdreJeu(num, 0)
+            pionSuppr = self.pions.pop(num)
+            pionSuppr.supprimer()
+        else:
+            print("erreur: ce pion n'est pas dans la liste des pions")
+            
+    def pionDecorSupprimer(self, num):
+        """supprime le pion entre en parametre"""
+        if num in self.decors:
+            for coord in self.decors[num].forme.listeCases(self.decors[num].position, self.decors[num].nbRotations):
+                 self.cases[coord].majOccupation(self.decors[num])
+            self.pionDecorSurvol(None)
+            pionDecorASuppr = self.decors.pop(num)
+            pionDecorASuppr.supprimer()
+        else:
+            print("ce pion n'est pas dans la liste des decors")
+            
+    ###############
+
+    ######### caches ###############
+    def voirCacheEnCours(self):
+        """centre la vue sur et met en evidence le cache actif"""
+        if len(self.caches[self.cacheEnCours]["listeCases"]) > 0: 
+            #centre la vue sur le premier point du polygone d'une case du milieu de la liste
+            indiceMilieu = int((len(self.caches[self.cacheEnCours]["listeCases"])/2))
+            self.fenetre.ui.vuePlateau.centerOn(self.cases[self.caches[self.cacheEnCours]["listeCases"][indiceMilieu]].polygon()[0])
+            #mettre en surbrillance
+            #for coord in self.caches[self.cacheEnCours]["listeCases"]:
+            #    self.
+
+    def placerCacheEnCours(self):
+        """active le mode de mise a jour de la liste des cases cachees par ce cache"""
+        self.majMode("cachePlacer")
+        self.fenetre.ui.cacheActif.setChecked(True)
+        self.majEtatCacheEnCours()
+
+    def majEtatCacheEnCours(self):
+        """met a jour l'etat (actif ou non) du cache selon l'etat de la case correspondante"""
+        self.caches[self.cacheEnCours]["actif"] = self.fenetre.ui.cacheActif.isChecked()
+        self.majAffichageCache(self.cacheEnCours, self.caches[self.cacheEnCours]["actif"])
+
+    def majAffichageCache(self, numCache, afficher = True):
+        """met a jour l'affichage des cases selon les parametres enregistres pour le cache"""
+        if self.polygonesCaches[numCache] == None:
+            self.polygonesCaches[numCache] = Cache(self, numCache)
+        self.polygonesCaches[numCache].afficher(afficher, self.caches[numCache]["listeCases"])    
+        
+    ###############"
+        
+    ######### gestion des evenements souris et clavier ###############
+    #*ES 
+    def wheelEvent(self, event):
+        """zoom/dezoom avec la molette de la souris"""
+        #on zoom/dezoom et on recentre sur la position du curseur
+        #super (Plateau, self).wheelEvent(event)
+        zoom = 1.00
+        if event.delta() > 0:
+            if self.nbZoomActuel <= 10:
+                self.nbZoomActuel += 1
+                zoom = 1.25
+        elif event.delta() < 0:
+            if self.nbZoomActuel >= -10:
+                zoom = 0.8
+                self.nbZoomActuel -= 1 
+        if zoom != 0.00:
+           self.fenetre.ui.vuePlateau.scale(zoom, zoom)
+           self.fenetre.ui.vuePlateau.centerOn(event.scenePos())
+        event.accept() #pour considerer l'evenement comme resolu, sans ca les barres de defilement reagissent aussi  
+
+    def mouseMoveEvent(self, event):
+        super(Plateau, self).mouseMoveEvent(event)
+        if event.buttons() == Qt.LeftButton and self.fenetre.ui.vuePlateau.dragMode() != QGraphicsView.ScrollHandDrag:
+            coord = self.coordonneesAuPoint(event.scenePos())
+            if coord != None:
+                self.caseSurvolClicEnfonce(coord)  
+        else:
+            if self.modeActif == "placementEntreeSortie":
+                self.modeParam["entreeSortie"].majProjection(event.scenePos())
+            event.ignore() 
+
+    def mousePressEvent(self, event):
+        super(Plateau, self).mousePressEvent(event)
+        if event.button() == 1 and self.fenetre.ui.vuePlateau.dragMode() != QGraphicsView.ScrollHandDrag:
+            if self.modeActif == "placementEntreeSortie" and not event.isAccepted():
+                self.modeParam["entreeSortie"].positionner()
+                self.entreesSorties.append(self.modeParam["entreeSortie"])
+                self.modeParam["entreeSortie"] = None
+                self.majMode("standard")
+            elif self.modeActif == "pionSupprimer":
+                for item in self.items(event.scenePos()):
+                    if item.__class__.__name__ == "PionDecor":
+                        self.pionDecorSupprimer(item.numero)
+                        break  
+                    elif item.parentItem().__class__.__name__ == "Pion":
+                        self.pionSupprimer(item.parentItem().numero)
+                        break
+                      
+            else:
+##                if not event.isAccepted():
+##                    self.caseCliquee(self.coordonneesAuPoint(event.scenePos()))
+                event.ignore()
+        elif event.button() == 2:
+            if self.pionSelectionne() != None and self.modeCombat != "" and self.modeCombat != "aucun":
+                self.majModeCombat("aucun")
+            else:    
+                self.majMode("standard")
+            event.accept()
+        #event.ignore()
+
+    def mouseReleaseEvent(self, event):
+        super(Plateau, self).mouseReleaseEvent(event)
+        self.clicGaucheRelache()
+
+    def keyPressEvent(self, event):
+        """gestion des evenements clavier"""
+        toucheClavier = event.key()
+        if self.modeActif == "pionCreation" or self.modeActif == "pionSelectionne" or self.modeActif == "pionDecorSelectionne" or self.modeActif == "pionDecorCreation":
+            #pivots de la projection du deplacement
+            if toucheClavier == Qt.Key_Right:
+                self.majProjectionPosition(False)
+                self.modeParam["nbRotations"] += 1
+                self.majProjectionPosition(True)
+                event.accept()
+            elif toucheClavier == Qt.Key_Left:
+                self.majProjectionPosition(False)
+                self.modeParam["nbRotations"] -= 1
+                self.majProjectionPosition(True)
+                event.accept()
+        elif self.modeActif == "creerEntreeSortie":
+            if toucheClavier == Qt.Key_Right: self.modeParam["entreeSortie"].nbRotations += 1
+            if toucheClavier == Qt.Key_Left: self.modeParam["entreeSortie"].nbRotations -= 1
+            self.modeParam["entreeSortie"].majProjection()
+        if self.modeActif[0:7] == "caseMaj":             
+            if toucheClavier == Qt.Key_Up:
+                self.fenetre.ui.epaisseurPinceau.setValue(self.fenetre.ui.epaisseurPinceau.value()+1)
+            elif toucheClavier == Qt.Key_Down:
+                self.fenetre.ui.epaisseurPinceau.setValue(self.fenetre.ui.epaisseurPinceau.value()-1)
+        if toucheClavier == Qt.Key_Delete:
+            if self.pionSelectionne() != None:
+                num = self.pionSelectionne().numero
+                if self.modeActif == "pionSelectionne":
+                    self.pionSupprimer(num)
+                elif self.modeActif == "pionDecorSelectionne":            
+                    self.pionDecorSupprimer(num)
+                self.majMode("standard")    
+            elif self.modeActif == "placementEntreeSortie":
+                self.modeParam["entreeSortie"].plateau = None
+                self.removeItem(self.modeParam["entreeSortie"])
+                self.entreesSorties.remove(self.modeParam["entreeSortie"])
+                self.modeParam["entreeSortie"] = None
+                self.majMode("standard")
+            
+    ################   
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        
+  
+
+

lib/Terrain.py

@@ -0,0 +1,15 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+        
+class Terrain():
+    """terrain a affecter a une case"""
+    def __init__(self, parent=None):
+        self.id = "00"
+        self.nom = ""                #libelle a afficher dans la liste 
+        self.couleur = QColor("")    #couleur si pas de texture
+        self.imgTexture = ""         #image source de la texture
+        self.franchissable = True    #peut on franchir cette case
+        self.visibilite = True       #peut on voir au travers 
+        self.modDeplacement = 1.00   #modificateur a appliquer au deplacement
+

lib/lancer.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+"""lancer de des"""
+from random import *
+from operator import add
+
+def de(faces):
+    """resultat d'un de avec nbre de faces en parametre"""
+    return randint(1,faces)
+   
+def jet(expr = ""):
+    """effectue un jet de de a partir d'expressions de type '1d20+3' -
+    retourne un resultat chiffre et un resultat detaille."""
+    decoupage = []
+    lancer = []
+    estDe = False
+    nbDes = 0
+    res = 0
+    resDetaille = ""
+    signe = ""
+    tmp = ""
+    valide = True
+
+    #on decoupe la chaine en se basant sur tout ce qui n'est pas un chiffre:
+    expr.replace(" ","")
+    if len(expr) > 0:
+        expr += " " #pour forcer la prise en compte du dernier membre
+        for car in expr:
+            if estEntier(car):
+                tmp += car
+            else:
+                if car.lower() == "d":
+                   estDe = True
+                   nbDes = int(tmp)
+                   lancer = []
+                   tmp = ""
+                else:
+                   if estDe:
+                       for i in range(0, nbDes):
+                           lancer.append(de(int(tmp)))
+                       decoupage.append(lancer)
+                       estDe = False
+                   else:
+                       decoupage.append(tmp)
+                   if car != " ":    
+                       decoupage.append(car)
+                   tmp = ""
+        
+        #on calcule ensuite tout ca:
+        for elt in decoupage:
+            if type(elt) == list:
+               elt = int(sum(elt[:]))
+
+            if estEntier(elt):
+               elt = int(elt)
+               if signe == "-": elt = -1 * elt
+               res += elt    
+            else:
+               if elt == "+" or elt == "-":  
+                   signe = elt
+               else:
+                   valide = False
+                   break
+
+        #on met en forme le resultat detaille
+        for elt in decoupage:
+           if type(elt) == list:
+               elt = map(str, elt) 
+               elt = ",".join(elt)
+           resDetaille += (" "+elt)       
+        resDetaille = resDetaille.replace(" ","")
+
+    if not valide or len(expr) == 0:
+        res = None
+        resDetaille = ""
+            
+    return (res, resDetaille)
+
+def estEntier(val):
+    """renvoie vrai si val est convertible en entier"""
+    retour = False
+    try:
+        val3 = float(val)
+        val2 = int(val3)
+        retour = (val2 == val3)
+    except:
+        pass
+    return retour
+
+def estJetValide(expr):
+    """renvoie vrai si la syntaxe est bien celle d'un lancer de des"""
+    valide = True
+    if len(expr) > 0:
+        for car in expr:
+            valide = (estEntier(car) or (car in ["d","D","+","-"]))
+    else:
+        valide = False
+    return valide    
+
+if __name__ == "__main__":
+# si lancement direct:
+    while True:
+##        lancer = jet(raw_input(" > "))
+##        print("{} ({})".format(lancer[0], lancer[1]))
+        print estJetValide(raw_input(" > "))
+  
+

lib/outilsSvg.py

@@ -0,0 +1,115 @@
+# -*-coding:Latin-1 -*
+"""enregistre et recupere les objets crees depuis une classe dans un dictionnaire"""
+import cPickle as pickle #lecture/ecriture d'objets dans un fichier
+                         #(cpickle remplace pickle, en + rapide)
+from time import time
+import os
+#import pickle
+
+
+def enregistrer(nomObj, obj, fichier = "", remplacer = True):
+     """enregistre un objet. le nom du fichier est le nom de la classe de l'objet"""
+     #on récupère le dictionnaire s'il existe, sinon on le cree
+     #t0 = time()
+     if len(fichier) == 0 :
+          fichier = "{}".format(obj.__class__.__name__)
+          
+     try:
+         with open(fichier, 'rb') as input:
+             dico = pickle.load(input) 
+         input.close() 
+     except IOError:
+         dico = {}
+        
+     #on ajoute notre nouvel objet (si remplacer est faux, en le renommant s'il existe déja)
+     if dico.has_key(nomObj) and not remplacer:
+        k = 1 
+        while dico.has_key("{}{}".format(nomObj, k)):
+            k += 1 
+        dico["{}{}".format(nomObj,k)]=obj  
+     else:    
+        dico[nomObj]=obj   
+          
+     #on remet le dictionnaire dans le fichier
+     with open(fichier, 'wb') as output:
+         pickle.dump(dico, output, protocol=pickle.HIGHEST_PROTOCOL)
+     output.close()
+     chaine = "{} sauvegarde.".format(nomObj)
+     #print (time() - t0)
+     return chaine
+
+def enregistrerUnique(obj, fichier = "", remplacer = True):
+     """comme enregistrer, mais stocke l'objet dans un fichier a part (ex: plateau)"""
+     if len(fichier) == 0 :
+          fichier = "{}".format(obj.__class__.__name__)
+     with open(fichier, 'wb') as output:
+         pickle.dump(obj, output, protocol=pickle.HIGHEST_PROTOCOL)
+     output.close()  
+
+def charger(fichier, nomObj):
+    """recupere un objet enregistre"""
+    fichier = "{}".format(fichier)
+    #on recupere le dictionnaire
+    retour = None
+    try:
+        with open(fichier, 'rb') as input:
+            dico = pickle.load(input)
+        retour = dico[nomObj]
+        input.close()
+    except IOError:
+        retour = None
+    return retour
+
+def chargerUnique(fichier):
+    """comme charger, mais charge un objet stocke dans un fichier a part (ex: plateau)"""
+    fichier = "{}".format(fichier) 
+    #on recupere l'objet
+    try:
+        with open(fichier, 'rb') as input:
+            objet = pickle.load(input)
+        input.close()
+    except IOError:
+        objet = None
+    return objet
+
+def afficheSvg(fichier):
+    """renvoie le contenu enregistre dans un fichier"""
+    #on récupère le dictionnaire s'il existe
+    try: 
+        with open(fichier, 'rb') as input:
+           dico = pickle.load(input)
+        input.close()  
+        #on met en forme le retour:
+        #chaine = ""   
+        #for clef in dico.keys():
+        #    chaine = chaine + "\n '{}': {}".format(clef,dico[clef])
+    except IOError:
+        #chaine = "Erreur pour afficher la sauvegarde du fichier {}".format(fichier)
+        dico = {}
+    return dico
+
+def supprSvg(fichier, nomObj):
+    """supprime un objet enregistré dans le fichier"""
+    fichier = "{}".format(fichier)
+    try:
+        #on recupere le dictionnaire
+        with open(fichier, 'rb') as input:
+            dico = pickle.load(input)
+        input.close()    
+        #on supprime l'enregistrement    
+        del dico[nomObj]
+        #on remet le dictionnaire dans le fichier
+        with open(fichier, 'wb') as output:
+            pickle.dump(dico, output, -1)
+        output.close()    
+        chaine = "{} supprimé.".format(nomObj)
+    except IOError:
+        chaine = "Erreur: {} non trouve dans le fichier {}.".format(nomObj, fichier)
+        pass
+    return chaine
+
+
+
+
+
+    

lib/regles.py

@@ -0,0 +1,166 @@
+from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+##from __future__ import division
+##import os
+
+def attributOrdreJeu():
+    """renvoie l'attribut utilise pour definir l'ordre de jeu, None s'il n'existe pas"""
+    return "init"
+
+def sensTriOrdreJeu():
+    """renvoie le type de tri pour l'ordre de jeu: 0 = croissant / 1 = decroissant"""
+    return 1
+
+def ordreAttributs():
+    """renvoie la liste des attributs avec leur position relative"""
+    lst = ["init", "PV", "TotalPV", "CA", "BBA", "Ref", "Vig", "Vol", "F", "D", "C", "I", "S", "Ch", "B_init", "Special"]
+    return lst     
+
+def listeAttributs():
+    """renvoie un dictionnaire vide des attributs d'une creature ou joueur"""
+    dico = {}
+    ctrl = listeControle()
+    for attr in ctrl:
+        dico[attr] = ctrl[attr].defaut
+    return dico
+
+def listeControle():
+    """retourne la liste de controle des attributs de la creature ou joueur"""
+    dico = {\
+           "F": Attribut("Force", "F", "entier", 0, None, 10, True, False, False), \
+           "D": Attribut("Dexterite", "D", "entier", 0, None, 10, True, False, False), \
+           "C": Attribut("Constitution", "C", "entier", 0, None, 10, True, False, False), \
+           "I": Attribut("Intelligence", "I", "entier", 0, None, 10, True, False, False), \
+           "S": Attribut("Sagesse", "S", "entier", 0, None, 10, True, False, False), \
+           "Ch": Attribut("Charisme", "Ch", "entier", 0, None, 10, True, False, False), \
+           "Ref": Attribut("Reflexes", "Ref", "entier", None, None, 0, True, False, False), \
+           "Vig": Attribut("Vigueur", "Vig", "entier", None, None, 0, True, False, False), \
+           "Vol": Attribut("Volonte", "Vol", "entier", None, None, 0, True, False, False), \
+           "TotalPV": Attribut("Points de vie totaux", "TotalPV", "entier", None, None, 0, True, False, False), \
+           "PV": Attribut("Points de vie", "PV", "entier", None, None, 0, True, True, False), \
+           "CA": Attribut("Capacite d'armure", "CA", "entier", 0, None, 10, True, False, False), \
+           "B_init": Attribut("Bonus d'initiative", "B_init", "entier", None, None, 0, True, False, False), \
+           "init": Attribut("Initiative", "B_init", "entier", None, None, 10, True, True, False), \
+           "BBA": Attribut("Bonus de base a l'attaque", "BBA", "entier", 0, None, 0, True, False, False), \
+           "Special": Attribut("Special", "Special", "texte", 0, None, "", True, False, False)
+           }
+    return dico 
+
+def attribut(nomCourt):
+    """renvoie l'attribut demande"""
+    dico = listeControle()
+    if nomCourt in dico:
+        retour = dico[nomCourt]
+    else:
+        retour = None
+    return retour    
+
+def ordreAttributsAttaques():
+    """renvoie la liste des attributs avec leur position relative"""
+    lst = ["BA", "Dgts", "Crit.", "PorteeS", "DD", "svg", "Special"]
+    return lst     
+
+def listeAttributsAttaques():
+    """renvoie un dictionnaire vide des attributs d'une creature ou joueur"""
+    dico = {}
+    ctrl = listeControleAttaques()
+    for attr in ctrl:
+        dico[attr] = ctrl[attr].defaut
+    return dico
+
+def listeControleAttaques():
+    """retourne la liste caracteristiques des attaques de la creature / joueur"""
+    dico = {\
+           "BA": Attribut("Bonus d'attaque", "BA", "entier", None, None, 0, True, False, False), \
+           "Dgts": Attribut("Degats", "Dgts", "texte", None, None, "", True, False, False), \
+           "Crit.": Attribut("Critique", "Crit.", "texte", None, None, "20/x2", True, False, False), \
+           "PorteeS": Attribut("Portee", "PorteeS", "texte", 0, None, "", True, False, False), \
+           "DD": Attribut("DD", "DD", "entier", None, None, 10, True, False, False), \
+           "svg": Attribut("Type de sauvegarde", "svg", "texte", None, None, "", True, False, False), \
+           "Special": Attribut("Special", "special", "texte", None, None, "", True, False, False)
+           }
+    return dico 
+
+def attributAttaque(nomCourt):
+    """renvoie l'attribut d'attaque demande"""
+    dico = listeControleAttaques()
+    if nomCourt in dico:
+        retour = dico[nomCourt]
+    else:
+        retour = None
+    return retour    
+
+class Attribut():
+    """attribut des pions et personnages"""
+    def __init__(self, nom, nomCourt, typ, mini, maxi, defaut, afficherCombat, combatSeulement, joueursSeulement):
+        """initialisation de l'attribut"""
+        self.nom = nom
+        self.nomCourt = nomCourt
+        self.typ = typ
+        self.mini = mini   #tests sur les valeurs pour les nombres, sur les longueurs pour les textes
+        self.maxi = maxi
+        self.defaut = defaut
+        self.afficherCombat = afficherCombat   #afficher dans les tables de combat
+        self.combatSeulement = combatSeulement   #afficher dans les tables de combat seulement      
+        self.joueursSeulement = joueursSeulement     #n'afficher que chez les joueurs
+
+        self.valeur = defaut
+
+    def controler(self, val):
+        """renvoie la la valeur entrée si celle ci est valide pour cet attribut, None sinon"""
+        if self.typ == "entier":
+            try:
+                retour = long(val)
+            except:
+                retour = None
+            if retour != None:
+                if self.mini != None:
+                    if not retour >= self.mini:
+                        retour = None
+                if self.maxi != None:
+                    if not retour <= self.maxi:
+                        retour = None
+        elif self.typ == "booleen":
+            try:
+                retour = bool(val)
+            except:
+                retour = None
+        else:
+            try:
+                retour = str(val)
+            except:
+                retour = None
+                
+            if retour != None:
+                if self.mini != None:
+                    if not len(retour) >= self.mini:
+                        retour = None
+                if self.maxi != None:
+                    if not len(retour) <= self.maxi:
+                        retour = None                
+        return retour
+
+
+
+if __name__ == "__main__":
+     val = "3"
+     dico = listeControleAttaques()
+     print(dico["svg"].controler(val))
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+            

lib/ui/affichageTexte.ui

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>affichageTexte</class>
+ <widget class="QDialog" name="affichageTexte">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>338</width>
+    <height>329</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <widget class="QTextEdit" name="texte">
+   <property name="geometry">
+    <rect>
+     <x>10</x>
+     <y>10</y>
+     <width>321</width>
+     <height>311</height>
+    </rect>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

lib/ui/convert.cmd

@@ -0,0 +1 @@
+pyuic4 -x mainwindow.ui -o ecran_principal.py

lib/ui/convertAttaques.cmd

@@ -0,0 +1 @@
+pyuic4 -x editionAttaques.ui -o ecran_editionAttaques.py

lib/ui/convertCreature.cmd

@@ -0,0 +1 @@
+pyuic4 -x editionCreature.ui -o ecran_editionCreature.py

lib/ui/convertDecor.cmd

@@ -0,0 +1 @@
+pyuic4 -x editionDecor.ui -o ecran_editionDecor.py

lib/ui/convertGestionCombat.cmd

@@ -0,0 +1 @@
+pyuic4 -x gestionCombat.ui -o ecran_gestionCombat.py

lib/ui/convertPlateau.cmd

@@ -0,0 +1 @@
+pyuic4 -x creationPlateau.ui -o ecran_creationPlateau.py

lib/ui/convertTerrain.cmd

@@ -0,0 +1 @@
+pyuic4 -x editionTerrain.ui -o ecran_editionTerrain.py

lib/ui/convertTexte.cmd

@@ -0,0 +1 @@
+pyuic4 -x affichageTexte.ui -o ecran_affichageTexte.py

lib/ui/ecran_affichageTexte.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'affichageTexte.ui'
+#
+# Created: Thu Nov 27 15:08:38 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_affichageTexte(object):
+    def setupUi(self, affichageTexte):
+        affichageTexte.setObjectName(_fromUtf8("affichageTexte"))
+        affichageTexte.resize(338, 329)
+        self.texte = QtGui.QTextEdit(affichageTexte)
+        self.texte.setGeometry(QtCore.QRect(10, 10, 321, 311))
+        self.texte.setObjectName(_fromUtf8("texte"))
+
+        self.retranslateUi(affichageTexte)
+        QtCore.QMetaObject.connectSlotsByName(affichageTexte)
+
+    def retranslateUi(self, affichageTexte):
+        affichageTexte.setWindowTitle(_translate("affichageTexte", "Dialog", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    affichageTexte = QtGui.QDialog()
+    ui = Ui_affichageTexte()
+    ui.setupUi(affichageTexte)
+    affichageTexte.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_creationPlateau.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'creationPlateau.ui'
+#
+# Created: Fri Nov 28 17:04:37 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_creationPlateau(object):
+    def setupUi(self, creationPlateau):
+        creationPlateau.setObjectName(_fromUtf8("creationPlateau"))
+        creationPlateau.resize(631, 323)
+        self.label_6 = QtGui.QLabel(creationPlateau)
+        self.label_6.setGeometry(QtCore.QRect(10, 80, 61, 16))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.toutAfficherPlateau = QtGui.QCheckBox(creationPlateau)
+        self.toutAfficherPlateau.setGeometry(QtCore.QRect(549, 21, 16, 20))
+        self.toutAfficherPlateau.setText(_fromUtf8(""))
+        self.toutAfficherPlateau.setObjectName(_fromUtf8("toutAfficherPlateau"))
+        self.listPlateau = QtGui.QTableWidget(creationPlateau)
+        self.listPlateau.setGeometry(QtCore.QRect(280, 50, 311, 191))
+        self.listPlateau.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listPlateau.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+        self.listPlateau.setShowGrid(True)
+        self.listPlateau.setGridStyle(QtCore.Qt.SolidLine)
+        self.listPlateau.setCornerButtonEnabled(True)
+        self.listPlateau.setObjectName(_fromUtf8("listPlateau"))
+        self.listPlateau.setColumnCount(7)
+        self.listPlateau.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(1, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(2, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(3, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(4, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(5, item)
+        item = QtGui.QTableWidgetItem()
+        self.listPlateau.setHorizontalHeaderItem(6, item)
+        self.listPlateau.horizontalHeader().setVisible(True)
+        self.listPlateau.horizontalHeader().setDefaultSectionSize(80)
+        self.listPlateau.verticalHeader().setVisible(False)
+        self.listPlateau.verticalHeader().setDefaultSectionSize(24)
+        self.label_7 = QtGui.QLabel(creationPlateau)
+        self.label_7.setGeometry(QtCore.QRect(280, 20, 181, 21))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label_7.setFont(font)
+        self.label_7.setObjectName(_fromUtf8("label_7"))
+        self.label_5 = QtGui.QLabel(creationPlateau)
+        self.label_5.setGeometry(QtCore.QRect(10, 210, 141, 21))
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.nomPlateau = QtGui.QLineEdit(creationPlateau)
+        self.nomPlateau.setGeometry(QtCore.QRect(62, 50, 191, 20))
+        self.nomPlateau.setObjectName(_fromUtf8("nomPlateau"))
+        self.hauteurPlateau = QtGui.QSpinBox(creationPlateau)
+        self.hauteurPlateau.setGeometry(QtCore.QRect(200, 170, 51, 22))
+        self.hauteurPlateau.setMinimum(5)
+        self.hauteurPlateau.setMaximum(300)
+        self.hauteurPlateau.setSingleStep(1)
+        self.hauteurPlateau.setProperty("value", 25)
+        self.hauteurPlateau.setObjectName(_fromUtf8("hauteurPlateau"))
+        self.groupBox = QtGui.QGroupBox(creationPlateau)
+        self.groupBox.setGeometry(QtCore.QRect(10, 110, 241, 51))
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.formeCase_hexagone = QtGui.QRadioButton(self.groupBox)
+        self.formeCase_hexagone.setGeometry(QtCore.QRect(10, 20, 82, 17))
+        self.formeCase_hexagone.setChecked(True)
+        self.formeCase_hexagone.setObjectName(_fromUtf8("formeCase_hexagone"))
+        self.formeCase_carres = QtGui.QRadioButton(self.groupBox)
+        self.formeCase_carres.setGeometry(QtCore.QRect(130, 20, 82, 17))
+        self.formeCase_carres.setObjectName(_fromUtf8("formeCase_carres"))
+        self.chapitreChargementPlateau = QtGui.QSpinBox(creationPlateau)
+        self.chapitreChargementPlateau.setGeometry(QtCore.QRect(470, 20, 41, 22))
+        self.chapitreChargementPlateau.setMinimum(1)
+        self.chapitreChargementPlateau.setObjectName(_fromUtf8("chapitreChargementPlateau"))
+        self.supprimerPlateau = QtGui.QPushButton(creationPlateau)
+        self.supprimerPlateau.setEnabled(False)
+        self.supprimerPlateau.setGeometry(QtCore.QRect(280, 240, 121, 31))
+        self.supprimerPlateau.setObjectName(_fromUtf8("supprimerPlateau"))
+        self.label_4 = QtGui.QLabel(creationPlateau)
+        self.label_4.setGeometry(QtCore.QRect(60, 20, 181, 21))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label_4.setFont(font)
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.label_3 = QtGui.QLabel(creationPlateau)
+        self.label_3.setGeometry(QtCore.QRect(10, 50, 46, 21))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.largeurPlateau = QtGui.QSpinBox(creationPlateau)
+        self.largeurPlateau.setGeometry(QtCore.QRect(70, 170, 51, 22))
+        self.largeurPlateau.setMinimum(5)
+        self.largeurPlateau.setMaximum(300)
+        self.largeurPlateau.setSingleStep(1)
+        self.largeurPlateau.setProperty("value", 50)
+        self.largeurPlateau.setObjectName(_fromUtf8("largeurPlateau"))
+        self.selectionCouleur = QtGui.QPushButton(creationPlateau)
+        self.selectionCouleur.setGeometry(QtCore.QRect(190, 210, 61, 21))
+        self.selectionCouleur.setObjectName(_fromUtf8("selectionCouleur"))
+        self.chargerPlateau = QtGui.QPushButton(creationPlateau)
+        self.chargerPlateau.setEnabled(False)
+        self.chargerPlateau.setGeometry(QtCore.QRect(450, 240, 141, 31))
+        self.chargerPlateau.setObjectName(_fromUtf8("chargerPlateau"))
+        self.creerPlateau = QtGui.QPushButton(creationPlateau)
+        self.creerPlateau.setEnabled(False)
+        self.creerPlateau.setGeometry(QtCore.QRect(50, 240, 141, 31))
+        self.creerPlateau.setObjectName(_fromUtf8("creerPlateau"))
+        self.label_2 = QtGui.QLabel(creationPlateau)
+        self.label_2.setGeometry(QtCore.QRect(140, 170, 46, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.label = QtGui.QLabel(creationPlateau)
+        self.label.setGeometry(QtCore.QRect(10, 170, 46, 21))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.chapitrePlateau = QtGui.QSpinBox(creationPlateau)
+        self.chapitrePlateau.setGeometry(QtCore.QRect(71, 80, 41, 22))
+        self.chapitrePlateau.setMinimum(1)
+        self.chapitrePlateau.setObjectName(_fromUtf8("chapitrePlateau"))
+        self.couleurCasesPlateau = QtGui.QLabel(creationPlateau)
+        self.couleurCasesPlateau.setGeometry(QtCore.QRect(150, 210, 31, 21))
+        self.couleurCasesPlateau.setFrameShape(QtGui.QFrame.Box)
+        self.couleurCasesPlateau.setFrameShadow(QtGui.QFrame.Sunken)
+        self.couleurCasesPlateau.setText(_fromUtf8(""))
+        self.couleurCasesPlateau.setObjectName(_fromUtf8("couleurCasesPlateau"))
+        self.label_8 = QtGui.QLabel(creationPlateau)
+        self.label_8.setGeometry(QtCore.QRect(520, 0, 71, 21))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_8.setFont(font)
+        self.label_8.setObjectName(_fromUtf8("label_8"))
+        self.chargerPlateauEC = QtGui.QPushButton(creationPlateau)
+        self.chargerPlateauEC.setEnabled(False)
+        self.chargerPlateauEC.setGeometry(QtCore.QRect(360, 280, 141, 31))
+        self.chargerPlateauEC.setDefault(False)
+        self.chargerPlateauEC.setObjectName(_fromUtf8("chargerPlateauEC"))
+
+        self.retranslateUi(creationPlateau)
+        QtCore.QMetaObject.connectSlotsByName(creationPlateau)
+
+    def retranslateUi(self, creationPlateau):
+        creationPlateau.setWindowTitle(_translate("creationPlateau", "Dialog", None))
+        self.label_6.setText(_translate("creationPlateau", "Chapitre : ", None))
+        item = self.listPlateau.horizontalHeaderItem(0)
+        item.setText(_translate("creationPlateau", "index", None))
+        item = self.listPlateau.horizontalHeaderItem(1)
+        item.setText(_translate("creationPlateau", "Chapitre", None))
+        item = self.listPlateau.horizontalHeaderItem(2)
+        item.setText(_translate("creationPlateau", "Nom", None))
+        item = self.listPlateau.horizontalHeaderItem(3)
+        item.setText(_translate("creationPlateau", "Creation", None))
+        item = self.listPlateau.horizontalHeaderItem(4)
+        item.setText(_translate("creationPlateau", "Sauvegarde", None))
+        item = self.listPlateau.horizontalHeaderItem(5)
+        item.setText(_translate("creationPlateau", "Public", None))
+        item = self.listPlateau.horizontalHeaderItem(6)
+        item.setText(_translate("creationPlateau", "En cours", None))
+        self.label_7.setText(_translate("creationPlateau", "Charger un plateau du chapitre:", None))
+        self.label_5.setText(_translate("creationPlateau", "Couleur initiale des cases : ", None))
+        self.groupBox.setTitle(_translate("creationPlateau", "Forme des cases", None))
+        self.formeCase_hexagone.setText(_translate("creationPlateau", "Hexagones", None))
+        self.formeCase_carres.setText(_translate("creationPlateau", "Carrés", None))
+        self.supprimerPlateau.setText(_translate("creationPlateau", "Supprimer", None))
+        self.label_4.setText(_translate("creationPlateau", "Créer un nouveau plateau", None))
+        self.label_3.setText(_translate("creationPlateau", "Nom : ", None))
+        self.selectionCouleur.setText(_translate("creationPlateau", "Modifier", None))
+        self.chargerPlateau.setText(_translate("creationPlateau", "Charger ce plateau", None))
+        self.creerPlateau.setText(_translate("creationPlateau", "Creer un nouveau plateau", None))
+        self.label_2.setText(_translate("creationPlateau", "Hauteur", None))
+        self.label.setText(_translate("creationPlateau", "Largeur", None))
+        self.label_8.setText(_translate("creationPlateau", "Tout afficher:", None))
+        self.chargerPlateauEC.setText(_translate("creationPlateau", "Charger le plus récent", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    creationPlateau = QtGui.QDialog()
+    ui = Ui_creationPlateau()
+    ui.setupUi(creationPlateau)
+    creationPlateau.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_editionAttaques.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'editionAttaques.ui'
+#
+# Created: Tue Nov 25 15:42:12 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_editionAttaques(object):
+    def setupUi(self, editionAttaques):
+        editionAttaques.setObjectName(_fromUtf8("editionAttaques"))
+        editionAttaques.resize(532, 253)
+        editionAttaques.setFrameShape(QtGui.QFrame.StyledPanel)
+        editionAttaques.setFrameShadow(QtGui.QFrame.Raised)
+        self.notesAttaqueSelect = QtGui.QTextBrowser(editionAttaques)
+        self.notesAttaqueSelect.setGeometry(QtCore.QRect(0, 200, 411, 51))
+        self.notesAttaqueSelect.setObjectName(_fromUtf8("notesAttaqueSelect"))
+        self.nouvelleAttaque = QtGui.QToolButton(editionAttaques)
+        self.nouvelleAttaque.setGeometry(QtCore.QRect(450, 200, 31, 21))
+        icon = QtGui.QIcon()
+        icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/plus.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.nouvelleAttaque.setIcon(icon)
+        self.nouvelleAttaque.setObjectName(_fromUtf8("nouvelleAttaque"))
+        self.editionListeAttaques = QtGui.QTableWidget(editionAttaques)
+        self.editionListeAttaques.setGeometry(QtCore.QRect(0, 0, 531, 201))
+        self.editionListeAttaques.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+        self.editionListeAttaques.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+        self.editionListeAttaques.setObjectName(_fromUtf8("editionListeAttaques"))
+        self.editionListeAttaques.setColumnCount(0)
+        self.editionListeAttaques.setRowCount(0)
+        self.supprimerAttaque = QtGui.QToolButton(editionAttaques)
+        self.supprimerAttaque.setGeometry(QtCore.QRect(490, 200, 31, 21))
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8("img/gomme.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.supprimerAttaque.setIcon(icon1)
+        self.supprimerAttaque.setObjectName(_fromUtf8("supprimerAttaque"))
+
+        self.retranslateUi(editionAttaques)
+        QtCore.QMetaObject.connectSlotsByName(editionAttaques)
+
+    def retranslateUi(self, editionAttaques):
+        editionAttaques.setWindowTitle(_translate("editionAttaques", "Edition des attaques", None))
+        self.nouvelleAttaque.setText(_translate("editionAttaques", "...", None))
+        self.supprimerAttaque.setText(_translate("editionAttaques", "...", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    editionAttaques = QtGui.QFrame()
+    ui = Ui_editionAttaques()
+    ui.setupUi(editionAttaques)
+    editionAttaques.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_editionCreature.py

@@ -0,0 +1,391 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'editionCreature.ui'
+#
+# Created: Thu Nov 27 14:32:09 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_editionCreature(object):
+    def setupUi(self, editionCreature):
+        editionCreature.setObjectName(_fromUtf8("editionCreature"))
+        editionCreature.resize(712, 559)
+        self.affichageCouleurCreature = QtGui.QLabel(editionCreature)
+        self.affichageCouleurCreature.setGeometry(QtCore.QRect(110, 50, 51, 21))
+        self.affichageCouleurCreature.setFrameShape(QtGui.QFrame.Box)
+        self.affichageCouleurCreature.setFrameShadow(QtGui.QFrame.Sunken)
+        self.affichageCouleurCreature.setText(_fromUtf8(""))
+        self.affichageCouleurCreature.setObjectName(_fromUtf8("affichageCouleurCreature"))
+        self.label_11 = QtGui.QLabel(editionCreature)
+        self.label_11.setGeometry(QtCore.QRect(30, 120, 141, 20))
+        self.label_11.setObjectName(_fromUtf8("label_11"))
+        self.annulerCreature = QtGui.QPushButton(editionCreature)
+        self.annulerCreature.setGeometry(QtCore.QRect(490, 520, 81, 23))
+        self.annulerCreature.setObjectName(_fromUtf8("annulerCreature"))
+        self.label_3 = QtGui.QLabel(editionCreature)
+        self.label_3.setGeometry(QtCore.QRect(30, 20, 46, 16))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.imgLogoCreature = QtGui.QLineEdit(editionCreature)
+        self.imgLogoCreature.setGeometry(QtCore.QRect(180, 90, 191, 20))
+        self.imgLogoCreature.setObjectName(_fromUtf8("imgLogoCreature"))
+        self.hauteurCreature = QtGui.QDoubleSpinBox(editionCreature)
+        self.hauteurCreature.setGeometry(QtCore.QRect(560, 50, 41, 22))
+        self.hauteurCreature.setPrefix(_fromUtf8(""))
+        self.hauteurCreature.setDecimals(0)
+        self.hauteurCreature.setMinimum(1.0)
+        self.hauteurCreature.setMaximum(50.0)
+        self.hauteurCreature.setSingleStep(1.0)
+        self.hauteurCreature.setProperty("value", 1.0)
+        self.hauteurCreature.setObjectName(_fromUtf8("hauteurCreature"))
+        self.label_10 = QtGui.QLabel(editionCreature)
+        self.label_10.setGeometry(QtCore.QRect(470, 50, 81, 21))
+        self.label_10.setObjectName(_fromUtf8("label_10"))
+        self.volCreature = QtGui.QCheckBox(editionCreature)
+        self.volCreature.setGeometry(QtCore.QRect(560, 90, 61, 17))
+        self.volCreature.setChecked(False)
+        self.volCreature.setObjectName(_fromUtf8("volCreature"))
+        self.idCreature = QtGui.QLineEdit(editionCreature)
+        self.idCreature.setEnabled(False)
+        self.idCreature.setGeometry(QtCore.QRect(52, 20, 31, 20))
+        self.idCreature.setObjectName(_fromUtf8("idCreature"))
+        self.nomCreature = QtGui.QLineEdit(editionCreature)
+        self.nomCreature.setGeometry(QtCore.QRect(122, 20, 281, 20))
+        self.nomCreature.setObjectName(_fromUtf8("nomCreature"))
+        self.label_5 = QtGui.QLabel(editionCreature)
+        self.label_5.setGeometry(QtCore.QRect(180, 50, 191, 21))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_5.setFont(font)
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.deplacementCreature = QtGui.QDoubleSpinBox(editionCreature)
+        self.deplacementCreature.setGeometry(QtCore.QRect(560, 20, 41, 22))
+        self.deplacementCreature.setPrefix(_fromUtf8(""))
+        self.deplacementCreature.setDecimals(0)
+        self.deplacementCreature.setSingleStep(1.0)
+        self.deplacementCreature.setProperty("value", 1.0)
+        self.deplacementCreature.setObjectName(_fromUtf8("deplacementCreature"))
+        self.label_2 = QtGui.QLabel(editionCreature)
+        self.label_2.setGeometry(QtCore.QRect(130, 90, 71, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.label = QtGui.QLabel(editionCreature)
+        self.label.setGeometry(QtCore.QRect(30, 90, 141, 20))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.enregistrerCreature = QtGui.QPushButton(editionCreature)
+        self.enregistrerCreature.setEnabled(False)
+        self.enregistrerCreature.setGeometry(QtCore.QRect(120, 520, 101, 23))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.enregistrerCreature.setFont(font)
+        self.enregistrerCreature.setObjectName(_fromUtf8("enregistrerCreature"))
+        self.imgTextureCreature = QtGui.QLineEdit(editionCreature)
+        self.imgTextureCreature.setGeometry(QtCore.QRect(180, 120, 191, 20))
+        self.imgTextureCreature.setObjectName(_fromUtf8("imgTextureCreature"))
+        self.label_4 = QtGui.QLabel(editionCreature)
+        self.label_4.setGeometry(QtCore.QRect(90, 20, 46, 16))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.couleurCreature = QtGui.QPushButton(editionCreature)
+        self.couleurCreature.setGeometry(QtCore.QRect(20, 50, 75, 23))
+        self.couleurCreature.setObjectName(_fromUtf8("couleurCreature"))
+        self.supprimerCreature = QtGui.QPushButton(editionCreature)
+        self.supprimerCreature.setEnabled(False)
+        self.supprimerCreature.setGeometry(QtCore.QRect(400, 520, 75, 23))
+        self.supprimerCreature.setObjectName(_fromUtf8("supprimerCreature"))
+        self.label_6 = QtGui.QLabel(editionCreature)
+        self.label_6.setGeometry(QtCore.QRect(480, 20, 81, 21))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.ongletsCreation = QtGui.QTabWidget(editionCreature)
+        self.ongletsCreation.setGeometry(QtCore.QRect(20, 160, 681, 351))
+        self.ongletsCreation.setObjectName(_fromUtf8("ongletsCreation"))
+        self.tabForme = QtGui.QWidget()
+        self.tabForme.setObjectName(_fromUtf8("tabForme"))
+        self.groupBox_2 = QtGui.QGroupBox(self.tabForme)
+        self.groupBox_2.setGeometry(QtCore.QRect(460, 20, 131, 291))
+        self.groupBox_2.setObjectName(_fromUtf8("groupBox_2"))
+        self.txtAfficherCreature = QtGui.QCheckBox(self.groupBox_2)
+        self.txtAfficherCreature.setGeometry(QtCore.QRect(100, 10, 21, 21))
+        self.txtAfficherCreature.setText(_fromUtf8(""))
+        self.txtAfficherCreature.setChecked(True)
+        self.txtAfficherCreature.setObjectName(_fromUtf8("txtAfficherCreature"))
+        self.txtPosYCreature = QtGui.QSlider(self.groupBox_2)
+        self.txtPosYCreature.setGeometry(QtCore.QRect(10, 210, 111, 19))
+        self.txtPosYCreature.setMinimum(-1000)
+        self.txtPosYCreature.setMaximum(1000)
+        self.txtPosYCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.txtPosYCreature.setObjectName(_fromUtf8("txtPosYCreature"))
+        self.label_17 = QtGui.QLabel(self.groupBox_2)
+        self.label_17.setGeometry(QtCore.QRect(10, 70, 111, 20))
+        self.label_17.setObjectName(_fromUtf8("label_17"))
+        self.label_19 = QtGui.QLabel(self.groupBox_2)
+        self.label_19.setGeometry(QtCore.QRect(10, 150, 111, 20))
+        self.label_19.setObjectName(_fromUtf8("label_19"))
+        self.txtTaillePoliceCreature = QtGui.QSlider(self.groupBox_2)
+        self.txtTaillePoliceCreature.setGeometry(QtCore.QRect(10, 90, 111, 19))
+        self.txtTaillePoliceCreature.setMinimum(8)
+        self.txtTaillePoliceCreature.setMaximum(99)
+        self.txtTaillePoliceCreature.setProperty("value", 20)
+        self.txtTaillePoliceCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.txtTaillePoliceCreature.setObjectName(_fromUtf8("txtTaillePoliceCreature"))
+        self.txtRotationCreature = QtGui.QSlider(self.groupBox_2)
+        self.txtRotationCreature.setGeometry(QtCore.QRect(10, 50, 111, 19))
+        self.txtRotationCreature.setMinimum(-180)
+        self.txtRotationCreature.setMaximum(180)
+        self.txtRotationCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.txtRotationCreature.setObjectName(_fromUtf8("txtRotationCreature"))
+        self.label_20 = QtGui.QLabel(self.groupBox_2)
+        self.label_20.setGeometry(QtCore.QRect(10, 30, 111, 20))
+        self.label_20.setObjectName(_fromUtf8("label_20"))
+        self.txtPosXCreature = QtGui.QSlider(self.groupBox_2)
+        self.txtPosXCreature.setGeometry(QtCore.QRect(10, 170, 111, 19))
+        self.txtPosXCreature.setMinimum(-800)
+        self.txtPosXCreature.setMaximum(800)
+        self.txtPosXCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.txtPosXCreature.setObjectName(_fromUtf8("txtPosXCreature"))
+        self.label_21 = QtGui.QLabel(self.groupBox_2)
+        self.label_21.setGeometry(QtCore.QRect(10, 190, 111, 20))
+        self.label_21.setObjectName(_fromUtf8("label_21"))
+        self.txtReinitCreature = QtGui.QPushButton(self.groupBox_2)
+        self.txtReinitCreature.setGeometry(QtCore.QRect(10, 240, 111, 20))
+        self.txtReinitCreature.setObjectName(_fromUtf8("txtReinitCreature"))
+        self.txtGrasCreature = QtGui.QCheckBox(self.groupBox_2)
+        self.txtGrasCreature.setGeometry(QtCore.QRect(10, 120, 41, 21))
+        self.txtGrasCreature.setObjectName(_fromUtf8("txtGrasCreature"))
+        self.groupBox = QtGui.QGroupBox(self.tabForme)
+        self.groupBox.setGeometry(QtCore.QRect(310, 20, 131, 291))
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.imgAfficherCreature = QtGui.QCheckBox(self.groupBox)
+        self.imgAfficherCreature.setGeometry(QtCore.QRect(100, 10, 21, 21))
+        self.imgAfficherCreature.setText(_fromUtf8(""))
+        self.imgAfficherCreature.setChecked(True)
+        self.imgAfficherCreature.setObjectName(_fromUtf8("imgAfficherCreature"))
+        self.imgPosYCreature = QtGui.QSlider(self.groupBox)
+        self.imgPosYCreature.setGeometry(QtCore.QRect(10, 200, 111, 19))
+        self.imgPosYCreature.setMinimum(-400)
+        self.imgPosYCreature.setMaximum(400)
+        self.imgPosYCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosYCreature.setObjectName(_fromUtf8("imgPosYCreature"))
+        self.label_12 = QtGui.QLabel(self.groupBox)
+        self.label_12.setGeometry(QtCore.QRect(10, 60, 111, 20))
+        self.label_12.setObjectName(_fromUtf8("label_12"))
+        self.label_13 = QtGui.QLabel(self.groupBox)
+        self.label_13.setGeometry(QtCore.QRect(10, 100, 111, 20))
+        self.label_13.setObjectName(_fromUtf8("label_13"))
+        self.label_14 = QtGui.QLabel(self.groupBox)
+        self.label_14.setGeometry(QtCore.QRect(10, 140, 111, 20))
+        self.label_14.setObjectName(_fromUtf8("label_14"))
+        self.imgTailleXCreature = QtGui.QSlider(self.groupBox)
+        self.imgTailleXCreature.setGeometry(QtCore.QRect(10, 80, 111, 19))
+        self.imgTailleXCreature.setMinimum(0)
+        self.imgTailleXCreature.setProperty("value", 10)
+        self.imgTailleXCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleXCreature.setObjectName(_fromUtf8("imgTailleXCreature"))
+        self.imgRotationCreature = QtGui.QSlider(self.groupBox)
+        self.imgRotationCreature.setGeometry(QtCore.QRect(10, 40, 111, 19))
+        self.imgRotationCreature.setMinimum(-180)
+        self.imgRotationCreature.setMaximum(180)
+        self.imgRotationCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.imgRotationCreature.setObjectName(_fromUtf8("imgRotationCreature"))
+        self.label_16 = QtGui.QLabel(self.groupBox)
+        self.label_16.setGeometry(QtCore.QRect(10, 20, 111, 20))
+        self.label_16.setObjectName(_fromUtf8("label_16"))
+        self.imgPosXCreature = QtGui.QSlider(self.groupBox)
+        self.imgPosXCreature.setGeometry(QtCore.QRect(10, 160, 111, 19))
+        self.imgPosXCreature.setMinimum(-400)
+        self.imgPosXCreature.setMaximum(400)
+        self.imgPosXCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosXCreature.setObjectName(_fromUtf8("imgPosXCreature"))
+        self.label_15 = QtGui.QLabel(self.groupBox)
+        self.label_15.setGeometry(QtCore.QRect(10, 180, 111, 20))
+        self.label_15.setObjectName(_fromUtf8("label_15"))
+        self.imgTailleYCreature = QtGui.QSlider(self.groupBox)
+        self.imgTailleYCreature.setGeometry(QtCore.QRect(10, 120, 111, 19))
+        self.imgTailleYCreature.setMinimum(0)
+        self.imgTailleYCreature.setProperty("value", 10)
+        self.imgTailleYCreature.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleYCreature.setObjectName(_fromUtf8("imgTailleYCreature"))
+        self.imgReinitCreature = QtGui.QPushButton(self.groupBox)
+        self.imgReinitCreature.setGeometry(QtCore.QRect(10, 260, 111, 20))
+        self.imgReinitCreature.setObjectName(_fromUtf8("imgReinitCreature"))
+        self.imgPivoteCreature = QtGui.QCheckBox(self.groupBox)
+        self.imgPivoteCreature.setGeometry(QtCore.QRect(10, 220, 101, 17))
+        self.imgPivoteCreature.setObjectName(_fromUtf8("imgPivoteCreature"))
+        self.imgMasqueCreature = QtGui.QCheckBox(self.groupBox)
+        self.imgMasqueCreature.setGeometry(QtCore.QRect(10, 240, 101, 17))
+        self.imgMasqueCreature.setObjectName(_fromUtf8("imgMasqueCreature"))
+        self.label_9 = QtGui.QLabel(self.tabForme)
+        self.label_9.setGeometry(QtCore.QRect(20, 0, 251, 20))
+        self.label_9.setObjectName(_fromUtf8("label_9"))
+        self.vueForme = QtGui.QGraphicsView(self.tabForme)
+        self.vueForme.setGeometry(QtCore.QRect(20, 20, 281, 291))
+        self.vueForme.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.HighQualityAntialiasing|QtGui.QPainter.TextAntialiasing)
+        self.vueForme.setObjectName(_fromUtf8("vueForme"))
+        self.ongletsCreation.addTab(self.tabForme, _fromUtf8(""))
+        self.tabAttaques = QtGui.QWidget()
+        self.tabAttaques.setObjectName(_fromUtf8("tabAttaques"))
+        self.ongletsCreation.addTab(self.tabAttaques, _fromUtf8(""))
+        self.tabAttributs = QtGui.QWidget()
+        self.tabAttributs.setObjectName(_fromUtf8("tabAttributs"))
+        self.listeAttributs = QtGui.QTableWidget(self.tabAttributs)
+        self.listeAttributs.setGeometry(QtCore.QRect(10, 30, 191, 261))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        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.listeAttributs.setPalette(palette)
+        self.listeAttributs.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listeAttributs.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeAttributs.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
+        self.listeAttributs.setAlternatingRowColors(True)
+        self.listeAttributs.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.listeAttributs.setShowGrid(True)
+        self.listeAttributs.setObjectName(_fromUtf8("listeAttributs"))
+        self.listeAttributs.setColumnCount(2)
+        self.listeAttributs.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributs.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributs.setHorizontalHeaderItem(1, item)
+        self.listeAttributs.horizontalHeader().setVisible(False)
+        self.listeAttributs.horizontalHeader().setDefaultSectionSize(50)
+        self.listeAttributs.verticalHeader().setVisible(False)
+        self.label_18 = QtGui.QLabel(self.tabAttributs)
+        self.label_18.setGeometry(QtCore.QRect(10, 2, 221, 16))
+        self.label_18.setObjectName(_fromUtf8("label_18"))
+        self.listeInventaireCreature = QtGui.QTableWidget(self.tabAttributs)
+        self.listeInventaireCreature.setGeometry(QtCore.QRect(230, 30, 291, 131))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        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.listeInventaireCreature.setPalette(palette)
+        self.listeInventaireCreature.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listeInventaireCreature.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeInventaireCreature.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
+        self.listeInventaireCreature.setAlternatingRowColors(True)
+        self.listeInventaireCreature.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.listeInventaireCreature.setShowGrid(True)
+        self.listeInventaireCreature.setObjectName(_fromUtf8("listeInventaireCreature"))
+        self.listeInventaireCreature.setColumnCount(2)
+        self.listeInventaireCreature.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeInventaireCreature.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeInventaireCreature.setHorizontalHeaderItem(1, item)
+        self.listeInventaireCreature.horizontalHeader().setVisible(False)
+        self.listeInventaireCreature.horizontalHeader().setDefaultSectionSize(50)
+        self.listeInventaireCreature.verticalHeader().setVisible(False)
+        self.label_22 = QtGui.QLabel(self.tabAttributs)
+        self.label_22.setGeometry(QtCore.QRect(230, 10, 221, 16))
+        self.label_22.setObjectName(_fromUtf8("label_22"))
+        self.notesCreature = QtGui.QTextEdit(self.tabAttributs)
+        self.notesCreature.setGeometry(QtCore.QRect(230, 200, 291, 91))
+        self.notesCreature.setObjectName(_fromUtf8("notesCreature"))
+        self.label_23 = QtGui.QLabel(self.tabAttributs)
+        self.label_23.setGeometry(QtCore.QRect(230, 180, 46, 13))
+        self.label_23.setObjectName(_fromUtf8("label_23"))
+        self.ajouterInventaireCreature = QtGui.QToolButton(self.tabAttributs)
+        self.ajouterInventaireCreature.setGeometry(QtCore.QRect(470, 10, 21, 20))
+        icon = QtGui.QIcon()
+        icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/plus.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.ajouterInventaireCreature.setIcon(icon)
+        self.ajouterInventaireCreature.setObjectName(_fromUtf8("ajouterInventaireCreature"))
+        self.supprimerInventaireCreature = QtGui.QToolButton(self.tabAttributs)
+        self.supprimerInventaireCreature.setGeometry(QtCore.QRect(500, 10, 21, 20))
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8("img/gomme.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.supprimerInventaireCreature.setIcon(icon1)
+        self.supprimerInventaireCreature.setObjectName(_fromUtf8("supprimerInventaireCreature"))
+        self.ongletsCreation.addTab(self.tabAttributs, _fromUtf8(""))
+
+        self.retranslateUi(editionCreature)
+        self.ongletsCreation.setCurrentIndex(2)
+        QtCore.QMetaObject.connectSlotsByName(editionCreature)
+
+    def retranslateUi(self, editionCreature):
+        editionCreature.setWindowTitle(_translate("editionCreature", "Dialog", None))
+        self.label_11.setText(_translate("editionCreature", "Image (.png, .jpg) : ...img\\", None))
+        self.annulerCreature.setText(_translate("editionCreature", "Annuler", None))
+        self.label_3.setText(_translate("editionCreature", "Id : ", None))
+        self.label_10.setText(_translate("editionCreature", "Taille (en cases) : ", None))
+        self.volCreature.setText(_translate("editionCreature", "Vole", None))
+        self.label_5.setText(_translate("editionCreature", "(Couleur du pion si pas d\'image)", None))
+        self.label_2.setText(_translate("editionCreature", "...img\\", None))
+        self.label.setText(_translate("editionCreature", "Logo (.png, .jpg) : ", None))
+        self.enregistrerCreature.setText(_translate("editionCreature", "Enregistrer", None))
+        self.label_4.setText(_translate("editionCreature", "Nom : ", None))
+        self.couleurCreature.setText(_translate("editionCreature", "Couleur", None))
+        self.supprimerCreature.setText(_translate("editionCreature", "Supprimer", None))
+        self.label_6.setText(_translate("editionCreature", "Déplacement : ", None))
+        self.groupBox_2.setTitle(_translate("editionCreature", "Texte", None))
+        self.label_17.setText(_translate("editionCreature", "Taille de la police", None))
+        self.label_19.setText(_translate("editionCreature", "Position (X)", None))
+        self.label_20.setText(_translate("editionCreature", "Rotation", None))
+        self.label_21.setText(_translate("editionCreature", "Position (Y)", None))
+        self.txtReinitCreature.setText(_translate("editionCreature", "Ré-initialiser", None))
+        self.txtGrasCreature.setText(_translate("editionCreature", "Gras", None))
+        self.groupBox.setTitle(_translate("editionCreature", "Image", None))
+        self.label_12.setText(_translate("editionCreature", "Taille (X)", None))
+        self.label_13.setText(_translate("editionCreature", "Taille (Y)", None))
+        self.label_14.setText(_translate("editionCreature", "Position (X)", None))
+        self.label_16.setText(_translate("editionCreature", "Rotation", None))
+        self.label_15.setText(_translate("editionCreature", "Position (Y)", None))
+        self.imgReinitCreature.setText(_translate("editionCreature", "Ré-initialiser", None))
+        self.imgPivoteCreature.setText(_translate("editionCreature", "Image pivote", None))
+        self.imgMasqueCreature.setText(_translate("editionCreature", "Masque auto.", None))
+        self.label_9.setText(_translate("editionCreature", "Forme du pion : ", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabForme), _translate("editionCreature", "Forme et apparence", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabAttaques), _translate("editionCreature", "Attaques", None))
+        item = self.listeAttributs.horizontalHeaderItem(0)
+        item.setText(_translate("editionCreature", "Nouvelle colonne", None))
+        item = self.listeAttributs.horizontalHeaderItem(1)
+        item.setText(_translate("editionCreature", "Valeur", None))
+        self.label_18.setText(_translate("editionCreature", "Attributs / caractéristiques :  ", None))
+        item = self.listeInventaireCreature.horizontalHeaderItem(0)
+        item.setText(_translate("editionCreature", "nombre", None))
+        item = self.listeInventaireCreature.horizontalHeaderItem(1)
+        item.setText(_translate("editionCreature", "objet", None))
+        self.label_22.setText(_translate("editionCreature", "Inventaire de base :", None))
+        self.label_23.setText(_translate("editionCreature", "Notes :", None))
+        self.ajouterInventaireCreature.setText(_translate("editionCreature", "...", None))
+        self.supprimerInventaireCreature.setText(_translate("editionCreature", "...", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabAttributs), _translate("editionCreature", "Attributs et inventaire", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    editionCreature = QtGui.QDialog()
+    ui = Ui_editionCreature()
+    ui.setupUi(editionCreature)
+    editionCreature.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_editionDecor.py

@@ -0,0 +1,233 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'editionDecor.ui'
+#
+# Created: Tue Oct 07 16:41:52 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_editionDecor(object):
+    def setupUi(self, editionDecor):
+        editionDecor.setObjectName(_fromUtf8("editionDecor"))
+        editionDecor.resize(647, 511)
+        self.nomDecor = QtGui.QLineEdit(editionDecor)
+        self.nomDecor.setGeometry(QtCore.QRect(112, 10, 261, 20))
+        self.nomDecor.setObjectName(_fromUtf8("nomDecor"))
+        self.imgDecor = QtGui.QLineEdit(editionDecor)
+        self.imgDecor.setGeometry(QtCore.QRect(170, 110, 191, 20))
+        self.imgDecor.setObjectName(_fromUtf8("imgDecor"))
+        self.enregistrerDecor = QtGui.QPushButton(editionDecor)
+        self.enregistrerDecor.setEnabled(False)
+        self.enregistrerDecor.setGeometry(QtCore.QRect(120, 460, 81, 23))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.enregistrerDecor.setFont(font)
+        self.enregistrerDecor.setObjectName(_fromUtf8("enregistrerDecor"))
+        self.escaladeDecor = QtGui.QCheckBox(editionDecor)
+        self.escaladeDecor.setGeometry(QtCore.QRect(430, 50, 81, 17))
+        self.escaladeDecor.setChecked(True)
+        self.escaladeDecor.setObjectName(_fromUtf8("escaladeDecor"))
+        self.couvertDecor = QtGui.QCheckBox(editionDecor)
+        self.couvertDecor.setGeometry(QtCore.QRect(430, 70, 61, 17))
+        self.couvertDecor.setChecked(True)
+        self.couvertDecor.setObjectName(_fromUtf8("couvertDecor"))
+        self.label_3 = QtGui.QLabel(editionDecor)
+        self.label_3.setGeometry(QtCore.QRect(20, 10, 46, 16))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.label_2 = QtGui.QLabel(editionDecor)
+        self.label_2.setGeometry(QtCore.QRect(110, 80, 41, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.affichageCouleurDecor = QtGui.QLabel(editionDecor)
+        self.affichageCouleurDecor.setGeometry(QtCore.QRect(100, 40, 51, 21))
+        self.affichageCouleurDecor.setFrameShape(QtGui.QFrame.Box)
+        self.affichageCouleurDecor.setFrameShadow(QtGui.QFrame.Sunken)
+        self.affichageCouleurDecor.setText(_fromUtf8(""))
+        self.affichageCouleurDecor.setObjectName(_fromUtf8("affichageCouleurDecor"))
+        self.franchissableVolDecor = QtGui.QCheckBox(editionDecor)
+        self.franchissableVolDecor.setGeometry(QtCore.QRect(430, 30, 131, 17))
+        self.franchissableVolDecor.setChecked(True)
+        self.franchissableVolDecor.setObjectName(_fromUtf8("franchissableVolDecor"))
+        self.imgLogoDecor = QtGui.QLineEdit(editionDecor)
+        self.imgLogoDecor.setGeometry(QtCore.QRect(170, 80, 191, 20))
+        self.imgLogoDecor.setObjectName(_fromUtf8("imgLogoDecor"))
+        self.label_6 = QtGui.QLabel(editionDecor)
+        self.label_6.setGeometry(QtCore.QRect(430, 110, 101, 21))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.label_8 = QtGui.QLabel(editionDecor)
+        self.label_8.setGeometry(QtCore.QRect(20, 110, 141, 20))
+        self.label_8.setObjectName(_fromUtf8("label_8"))
+        self.label = QtGui.QLabel(editionDecor)
+        self.label.setGeometry(QtCore.QRect(20, 80, 131, 20))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.supprimerDecor = QtGui.QPushButton(editionDecor)
+        self.supprimerDecor.setEnabled(False)
+        self.supprimerDecor.setGeometry(QtCore.QRect(360, 460, 75, 23))
+        self.supprimerDecor.setObjectName(_fromUtf8("supprimerDecor"))
+        self.label_5 = QtGui.QLabel(editionDecor)
+        self.label_5.setGeometry(QtCore.QRect(170, 40, 191, 21))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_5.setFont(font)
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.hauteurDecor = QtGui.QDoubleSpinBox(editionDecor)
+        self.hauteurDecor.setGeometry(QtCore.QRect(540, 110, 41, 22))
+        self.hauteurDecor.setPrefix(_fromUtf8(""))
+        self.hauteurDecor.setDecimals(0)
+        self.hauteurDecor.setSingleStep(1.0)
+        self.hauteurDecor.setProperty("value", 1.0)
+        self.hauteurDecor.setObjectName(_fromUtf8("hauteurDecor"))
+        self.label_7 = QtGui.QLabel(editionDecor)
+        self.label_7.setGeometry(QtCore.QRect(110, 110, 41, 21))
+        self.label_7.setObjectName(_fromUtf8("label_7"))
+        self.label_9 = QtGui.QLabel(editionDecor)
+        self.label_9.setGeometry(QtCore.QRect(20, 140, 321, 20))
+        self.label_9.setObjectName(_fromUtf8("label_9"))
+        self.couleurDecor = QtGui.QPushButton(editionDecor)
+        self.couleurDecor.setGeometry(QtCore.QRect(10, 40, 75, 23))
+        self.couleurDecor.setObjectName(_fromUtf8("couleurDecor"))
+        self.franchissablePiedDecor = QtGui.QCheckBox(editionDecor)
+        self.franchissablePiedDecor.setGeometry(QtCore.QRect(430, 10, 151, 20))
+        self.franchissablePiedDecor.setChecked(True)
+        self.franchissablePiedDecor.setObjectName(_fromUtf8("franchissablePiedDecor"))
+        self.vueForme = QtGui.QGraphicsView(editionDecor)
+        self.vueForme.setGeometry(QtCore.QRect(20, 170, 341, 281))
+        self.vueForme.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.HighQualityAntialiasing|QtGui.QPainter.TextAntialiasing)
+        self.vueForme.setObjectName(_fromUtf8("vueForme"))
+        self.bruleDecor = QtGui.QCheckBox(editionDecor)
+        self.bruleDecor.setGeometry(QtCore.QRect(430, 90, 61, 17))
+        self.bruleDecor.setChecked(True)
+        self.bruleDecor.setObjectName(_fromUtf8("bruleDecor"))
+        self.groupBox = QtGui.QGroupBox(editionDecor)
+        self.groupBox.setGeometry(QtCore.QRect(370, 160, 141, 291))
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.imgAfficherDecor = QtGui.QCheckBox(self.groupBox)
+        self.imgAfficherDecor.setGeometry(QtCore.QRect(100, 10, 21, 21))
+        self.imgAfficherDecor.setText(_fromUtf8(""))
+        self.imgAfficherDecor.setChecked(True)
+        self.imgAfficherDecor.setObjectName(_fromUtf8("imgAfficherDecor"))
+        self.imgPosYDecor = QtGui.QSlider(self.groupBox)
+        self.imgPosYDecor.setGeometry(QtCore.QRect(10, 200, 111, 19))
+        self.imgPosYDecor.setMinimum(-400)
+        self.imgPosYDecor.setMaximum(400)
+        self.imgPosYDecor.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosYDecor.setObjectName(_fromUtf8("imgPosYDecor"))
+        self.label_12 = QtGui.QLabel(self.groupBox)
+        self.label_12.setGeometry(QtCore.QRect(10, 60, 111, 20))
+        self.label_12.setObjectName(_fromUtf8("label_12"))
+        self.label_13 = QtGui.QLabel(self.groupBox)
+        self.label_13.setGeometry(QtCore.QRect(10, 100, 111, 20))
+        self.label_13.setObjectName(_fromUtf8("label_13"))
+        self.label_14 = QtGui.QLabel(self.groupBox)
+        self.label_14.setGeometry(QtCore.QRect(10, 140, 111, 20))
+        self.label_14.setObjectName(_fromUtf8("label_14"))
+        self.imgTailleXDecor = QtGui.QSlider(self.groupBox)
+        self.imgTailleXDecor.setGeometry(QtCore.QRect(10, 80, 111, 19))
+        self.imgTailleXDecor.setMinimum(0)
+        self.imgTailleXDecor.setProperty("value", 10)
+        self.imgTailleXDecor.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleXDecor.setObjectName(_fromUtf8("imgTailleXDecor"))
+        self.imgRotationDecor = QtGui.QSlider(self.groupBox)
+        self.imgRotationDecor.setGeometry(QtCore.QRect(10, 40, 111, 19))
+        self.imgRotationDecor.setMinimum(-180)
+        self.imgRotationDecor.setMaximum(180)
+        self.imgRotationDecor.setOrientation(QtCore.Qt.Horizontal)
+        self.imgRotationDecor.setObjectName(_fromUtf8("imgRotationDecor"))
+        self.label_16 = QtGui.QLabel(self.groupBox)
+        self.label_16.setGeometry(QtCore.QRect(10, 20, 111, 20))
+        self.label_16.setObjectName(_fromUtf8("label_16"))
+        self.imgPosXDecor = QtGui.QSlider(self.groupBox)
+        self.imgPosXDecor.setGeometry(QtCore.QRect(10, 160, 111, 19))
+        self.imgPosXDecor.setMinimum(-400)
+        self.imgPosXDecor.setMaximum(400)
+        self.imgPosXDecor.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosXDecor.setObjectName(_fromUtf8("imgPosXDecor"))
+        self.label_15 = QtGui.QLabel(self.groupBox)
+        self.label_15.setGeometry(QtCore.QRect(10, 180, 111, 20))
+        self.label_15.setObjectName(_fromUtf8("label_15"))
+        self.imgTailleYDecor = QtGui.QSlider(self.groupBox)
+        self.imgTailleYDecor.setGeometry(QtCore.QRect(10, 120, 111, 19))
+        self.imgTailleYDecor.setMinimum(0)
+        self.imgTailleYDecor.setProperty("value", 10)
+        self.imgTailleYDecor.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleYDecor.setObjectName(_fromUtf8("imgTailleYDecor"))
+        self.imgReinitDecor = QtGui.QPushButton(self.groupBox)
+        self.imgReinitDecor.setGeometry(QtCore.QRect(10, 260, 111, 20))
+        self.imgReinitDecor.setObjectName(_fromUtf8("imgReinitDecor"))
+        self.imgPivoteDecor = QtGui.QCheckBox(self.groupBox)
+        self.imgPivoteDecor.setGeometry(QtCore.QRect(10, 220, 101, 17))
+        self.imgPivoteDecor.setObjectName(_fromUtf8("imgPivoteDecor"))
+        self.imgMasqueDecor = QtGui.QCheckBox(self.groupBox)
+        self.imgMasqueDecor.setGeometry(QtCore.QRect(10, 240, 101, 17))
+        self.imgMasqueDecor.setObjectName(_fromUtf8("imgMasqueDecor"))
+        self.idDecor = QtGui.QLineEdit(editionDecor)
+        self.idDecor.setEnabled(False)
+        self.idDecor.setGeometry(QtCore.QRect(42, 10, 31, 20))
+        self.idDecor.setObjectName(_fromUtf8("idDecor"))
+        self.label_4 = QtGui.QLabel(editionDecor)
+        self.label_4.setGeometry(QtCore.QRect(80, 10, 46, 16))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.annulerDecor = QtGui.QPushButton(editionDecor)
+        self.annulerDecor.setGeometry(QtCore.QRect(460, 460, 81, 23))
+        self.annulerDecor.setObjectName(_fromUtf8("annulerDecor"))
+
+        self.retranslateUi(editionDecor)
+        QtCore.QMetaObject.connectSlotsByName(editionDecor)
+
+    def retranslateUi(self, editionDecor):
+        editionDecor.setWindowTitle(_translate("editionDecor", "Dialog", None))
+        self.enregistrerDecor.setText(_translate("editionDecor", "Enregistrer", None))
+        self.escaladeDecor.setText(_translate("editionDecor", "Escalade", None))
+        self.couvertDecor.setText(_translate("editionDecor", "Couvert", None))
+        self.label_3.setText(_translate("editionDecor", "Id : ", None))
+        self.label_2.setText(_translate("editionDecor", "...img\\", None))
+        self.franchissableVolDecor.setText(_translate("editionDecor", "Franchissable en vol", None))
+        self.label_6.setText(_translate("editionDecor", "Hauteur (en cases)", None))
+        self.label_8.setText(_translate("editionDecor", "Image (.png, .jpg)", None))
+        self.label.setText(_translate("editionDecor", "Logo (.png, .jpg)", None))
+        self.supprimerDecor.setText(_translate("editionDecor", "Supprimer", None))
+        self.label_5.setText(_translate("editionDecor", "(Couleur du décor si pas d\'image)", None))
+        self.label_7.setText(_translate("editionDecor", "...img\\", None))
+        self.label_9.setText(_translate("editionDecor", "Forme du décor : ", None))
+        self.couleurDecor.setText(_translate("editionDecor", "Couleur", None))
+        self.franchissablePiedDecor.setText(_translate("editionDecor", "Franchissable à pied", None))
+        self.bruleDecor.setText(_translate("editionDecor", "Brule", None))
+        self.groupBox.setTitle(_translate("editionDecor", "Image", None))
+        self.label_12.setText(_translate("editionDecor", "Taille (X)", None))
+        self.label_13.setText(_translate("editionDecor", "Taille (Y)", None))
+        self.label_14.setText(_translate("editionDecor", "Position (X)", None))
+        self.label_16.setText(_translate("editionDecor", "Rotation", None))
+        self.label_15.setText(_translate("editionDecor", "Position (Y)", None))
+        self.imgReinitDecor.setText(_translate("editionDecor", "Ré-initialiser", None))
+        self.imgPivoteDecor.setText(_translate("editionDecor", "Image pivote", None))
+        self.imgMasqueDecor.setText(_translate("editionDecor", "Masque auto.", None))
+        self.label_4.setText(_translate("editionDecor", "Nom : ", None))
+        self.annulerDecor.setText(_translate("editionDecor", "Annuler", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    editionDecor = QtGui.QDialog()
+    ui = Ui_editionDecor()
+    ui.setupUi(editionDecor)
+    editionDecor.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_editionTerrain.py

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'editionTerrain.ui'
+#
+# Created: Tue Oct 07 16:41:54 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_editionTerrain(object):
+    def setupUi(self, editionTerrain):
+        editionTerrain.setObjectName(_fromUtf8("editionTerrain"))
+        editionTerrain.resize(400, 273)
+        self.label_5 = QtGui.QLabel(editionTerrain)
+        self.label_5.setGeometry(QtCore.QRect(170, 70, 191, 21))
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_5.setFont(font)
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.franchissableTerrain = QtGui.QCheckBox(editionTerrain)
+        self.franchissableTerrain.setGeometry(QtCore.QRect(20, 190, 91, 17))
+        self.franchissableTerrain.setChecked(True)
+        self.franchissableTerrain.setTristate(False)
+        self.franchissableTerrain.setObjectName(_fromUtf8("franchissableTerrain"))
+        self.label_2 = QtGui.QLabel(editionTerrain)
+        self.label_2.setGeometry(QtCore.QRect(150, 110, 71, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.affichageCouleurTerrain = QtGui.QLabel(editionTerrain)
+        self.affichageCouleurTerrain.setGeometry(QtCore.QRect(100, 70, 51, 21))
+        self.affichageCouleurTerrain.setFrameShape(QtGui.QFrame.Box)
+        self.affichageCouleurTerrain.setFrameShadow(QtGui.QFrame.Sunken)
+        self.affichageCouleurTerrain.setText(_fromUtf8(""))
+        self.affichageCouleurTerrain.setObjectName(_fromUtf8("affichageCouleurTerrain"))
+        self.supprimerTerrain = QtGui.QPushButton(editionTerrain)
+        self.supprimerTerrain.setEnabled(False)
+        self.supprimerTerrain.setGeometry(QtCore.QRect(210, 230, 75, 23))
+        self.supprimerTerrain.setObjectName(_fromUtf8("supprimerTerrain"))
+        self.label = QtGui.QLabel(editionTerrain)
+        self.label.setGeometry(QtCore.QRect(20, 110, 141, 20))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.enregistrerTerrain = QtGui.QPushButton(editionTerrain)
+        self.enregistrerTerrain.setEnabled(False)
+        self.enregistrerTerrain.setGeometry(QtCore.QRect(20, 230, 81, 23))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.enregistrerTerrain.setFont(font)
+        self.enregistrerTerrain.setObjectName(_fromUtf8("enregistrerTerrain"))
+        self.imgTextureTerrain = QtGui.QLineEdit(editionTerrain)
+        self.imgTextureTerrain.setGeometry(QtCore.QRect(200, 110, 161, 20))
+        self.imgTextureTerrain.setObjectName(_fromUtf8("imgTextureTerrain"))
+        self.annulerTerrain = QtGui.QPushButton(editionTerrain)
+        self.annulerTerrain.setGeometry(QtCore.QRect(290, 230, 81, 23))
+        self.annulerTerrain.setObjectName(_fromUtf8("annulerTerrain"))
+        self.modDeplacementTerrain = QtGui.QDoubleSpinBox(editionTerrain)
+        self.modDeplacementTerrain.setGeometry(QtCore.QRect(170, 140, 62, 22))
+        self.modDeplacementTerrain.setSingleStep(0.1)
+        self.modDeplacementTerrain.setProperty("value", 1.0)
+        self.modDeplacementTerrain.setObjectName(_fromUtf8("modDeplacementTerrain"))
+        self.couleurTerrain = QtGui.QPushButton(editionTerrain)
+        self.couleurTerrain.setGeometry(QtCore.QRect(10, 70, 75, 23))
+        self.couleurTerrain.setObjectName(_fromUtf8("couleurTerrain"))
+        self.idTerrain = QtGui.QLineEdit(editionTerrain)
+        self.idTerrain.setEnabled(False)
+        self.idTerrain.setGeometry(QtCore.QRect(90, 10, 113, 20))
+        self.idTerrain.setObjectName(_fromUtf8("idTerrain"))
+        self.label_6 = QtGui.QLabel(editionTerrain)
+        self.label_6.setGeometry(QtCore.QRect(20, 140, 151, 21))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.visibiliteTerrain = QtGui.QCheckBox(editionTerrain)
+        self.visibiliteTerrain.setGeometry(QtCore.QRect(20, 170, 70, 17))
+        self.visibiliteTerrain.setChecked(True)
+        self.visibiliteTerrain.setObjectName(_fromUtf8("visibiliteTerrain"))
+        self.label_4 = QtGui.QLabel(editionTerrain)
+        self.label_4.setGeometry(QtCore.QRect(20, 40, 46, 16))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.label_3 = QtGui.QLabel(editionTerrain)
+        self.label_3.setGeometry(QtCore.QRect(20, 10, 46, 16))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.nomTerrain = QtGui.QLineEdit(editionTerrain)
+        self.nomTerrain.setGeometry(QtCore.QRect(90, 40, 113, 20))
+        self.nomTerrain.setObjectName(_fromUtf8("nomTerrain"))
+
+        self.retranslateUi(editionTerrain)
+        QtCore.QMetaObject.connectSlotsByName(editionTerrain)
+
+    def retranslateUi(self, editionTerrain):
+        editionTerrain.setWindowTitle(_translate("editionTerrain", "Dialog", None))
+        self.label_5.setText(_translate("editionTerrain", "(Couleur du terrain si pas de texture)", None))
+        self.franchissableTerrain.setText(_translate("editionTerrain", "Franchissable", None))
+        self.label_2.setText(_translate("editionTerrain", "...img\\", None))
+        self.supprimerTerrain.setText(_translate("editionTerrain", "Supprimer", None))
+        self.label.setText(_translate("editionTerrain", "Texture (.png, .jpg)", None))
+        self.enregistrerTerrain.setText(_translate("editionTerrain", "Enregistrer", None))
+        self.annulerTerrain.setText(_translate("editionTerrain", "Annuler", None))
+        self.modDeplacementTerrain.setPrefix(_translate("editionTerrain", "x", None))
+        self.couleurTerrain.setText(_translate("editionTerrain", "Couleur", None))
+        self.label_6.setText(_translate("editionTerrain", "Coût de déplacement : ", None))
+        self.visibiliteTerrain.setText(_translate("editionTerrain", "Visibilité", None))
+        self.label_4.setText(_translate("editionTerrain", "Nom : ", None))
+        self.label_3.setText(_translate("editionTerrain", "Id : ", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    editionTerrain = QtGui.QDialog()
+    ui = Ui_editionTerrain()
+    ui.setupUi(editionTerrain)
+    editionTerrain.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_gestionCombat.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'gestionCombat.ui'
+#
+# Created: Thu Nov 13 16:34:56 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_gestionCombat(object):
+    def setupUi(self, gestionCombat):
+        gestionCombat.setObjectName(_fromUtf8("gestionCombat"))
+        gestionCombat.resize(578, 512)
+        self.panneauAttaquant = QtGui.QFrame(gestionCombat)
+        self.panneauAttaquant.setGeometry(QtCore.QRect(10, 30, 561, 41))
+        self.panneauAttaquant.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.panneauAttaquant.setFrameShadow(QtGui.QFrame.Raised)
+        self.panneauAttaquant.setObjectName(_fromUtf8("panneauAttaquant"))
+        self.label_4 = QtGui.QLabel(self.panneauAttaquant)
+        self.label_4.setGeometry(QtCore.QRect(10, 0, 541, 31))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.label = QtGui.QLabel(gestionCombat)
+        self.label.setGeometry(QtCore.QRect(9, 9, 164, 16))
+        font = QtGui.QFont()
+        font.setFamily(_fromUtf8("Georgia"))
+        font.setPointSize(10)
+        font.setBold(True)
+        font.setWeight(75)
+        self.label.setFont(font)
+        self.label.setObjectName(_fromUtf8("label"))
+        self.listePions = QtGui.QTableWidget(gestionCombat)
+        self.listePions.setGeometry(QtCore.QRect(10, 70, 561, 281))
+        self.listePions.setMinimumSize(QtCore.QSize(561, 281))
+        self.listePions.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.listePions.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+        self.listePions.setObjectName(_fromUtf8("listePions"))
+        self.listePions.setColumnCount(0)
+        self.listePions.setRowCount(0)
+        self.panneauGestionCombat = QtGui.QFrame(gestionCombat)
+        self.panneauGestionCombat.setGeometry(QtCore.QRect(0, 350, 561, 161))
+        self.panneauGestionCombat.setMinimumSize(QtCore.QSize(561, 161))
+        self.panneauGestionCombat.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.panneauGestionCombat.setFrameShadow(QtGui.QFrame.Raised)
+        self.panneauGestionCombat.setObjectName(_fromUtf8("panneauGestionCombat"))
+        self.jetDes = QtGui.QLineEdit(self.panneauGestionCombat)
+        self.jetDes.setGeometry(QtCore.QRect(10, 10, 211, 20))
+        self.jetDes.setStatusTip(_fromUtf8(""))
+        self.jetDes.setInputMask(_fromUtf8(""))
+        self.jetDes.setObjectName(_fromUtf8("jetDes"))
+        self.afficherDetailDes = QtGui.QCheckBox(self.panneauGestionCombat)
+        self.afficherDetailDes.setGeometry(QtCore.QRect(140, 30, 101, 17))
+        font = QtGui.QFont()
+        font.setPointSize(7)
+        font.setItalic(True)
+        self.afficherDetailDes.setFont(font)
+        self.afficherDetailDes.setTristate(False)
+        self.afficherDetailDes.setObjectName(_fromUtf8("afficherDetailDes"))
+        self.affecterJetsDes = QtGui.QGroupBox(self.panneauGestionCombat)
+        self.affecterJetsDes.setGeometry(QtCore.QRect(10, 60, 521, 91))
+        self.affecterJetsDes.setObjectName(_fromUtf8("affecterJetsDes"))
+        self.majValeurRemplacer = QtGui.QRadioButton(self.affecterJetsDes)
+        self.majValeurRemplacer.setGeometry(QtCore.QRect(20, 60, 71, 17))
+        self.majValeurRemplacer.setChecked(True)
+        self.majValeurRemplacer.setObjectName(_fromUtf8("majValeurRemplacer"))
+        self.majValeurRetirer = QtGui.QRadioButton(self.affecterJetsDes)
+        self.majValeurRetirer.setGeometry(QtCore.QRect(20, 40, 61, 17))
+        self.majValeurRetirer.setObjectName(_fromUtf8("majValeurRetirer"))
+        self.majValeurAjouter = QtGui.QRadioButton(self.affecterJetsDes)
+        self.majValeurAjouter.setGeometry(QtCore.QRect(20, 20, 61, 17))
+        self.majValeurAjouter.setObjectName(_fromUtf8("majValeurAjouter"))
+        self.label_2 = QtGui.QLabel(self.affecterJetsDes)
+        self.label_2.setGeometry(QtCore.QRect(280, 40, 31, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.nomChampMaj = QtGui.QComboBox(self.affecterJetsDes)
+        self.nomChampMaj.setGeometry(QtCore.QRect(320, 41, 131, 21))
+        self.nomChampMaj.setObjectName(_fromUtf8("nomChampMaj"))
+        self.majChamp = QtGui.QPushButton(self.affecterJetsDes)
+        self.majChamp.setGeometry(QtCore.QRect(470, 39, 31, 24))
+        self.majChamp.setFocusPolicy(QtCore.Qt.NoFocus)
+        self.majChamp.setObjectName(_fromUtf8("majChamp"))
+        self.nomChampSourceMaj = QtGui.QComboBox(self.affecterJetsDes)
+        self.nomChampSourceMaj.setGeometry(QtCore.QRect(120, 40, 141, 21))
+        self.nomChampSourceMaj.setObjectName(_fromUtf8("nomChampSourceMaj"))
+        self.validerJetDes = QtGui.QToolButton(self.panneauGestionCombat)
+        self.validerJetDes.setGeometry(QtCore.QRect(230, 10, 25, 19))
+        icon = QtGui.QIcon()
+        icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/de.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.validerJetDes.setIcon(icon)
+        self.validerJetDes.setObjectName(_fromUtf8("validerJetDes"))
+        self.masquerHorsCombat = QtGui.QCheckBox(self.panneauGestionCombat)
+        self.masquerHorsCombat.setGeometry(QtCore.QRect(380, 39, 181, 21))
+        self.masquerHorsCombat.setObjectName(_fromUtf8("masquerHorsCombat"))
+        self.jetDesIndependants = QtGui.QCheckBox(self.panneauGestionCombat)
+        self.jetDesIndependants.setGeometry(QtCore.QRect(10, 30, 101, 17))
+        font = QtGui.QFont()
+        font.setPointSize(7)
+        font.setItalic(True)
+        self.jetDesIndependants.setFont(font)
+        self.jetDesIndependants.setChecked(True)
+        self.jetDesIndependants.setTristate(False)
+        self.jetDesIndependants.setObjectName(_fromUtf8("jetDesIndependants"))
+        self.selectionDefenseur = QtGui.QToolButton(self.panneauGestionCombat)
+        self.selectionDefenseur.setGeometry(QtCore.QRect(510, 10, 25, 19))
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8("img/bouclier.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.selectionDefenseur.setIcon(icon1)
+        self.selectionDefenseur.setObjectName(_fromUtf8("selectionDefenseur"))
+        self.label_3 = QtGui.QLabel(self.panneauGestionCombat)
+        self.label_3.setGeometry(QtCore.QRect(380, 10, 71, 21))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.selectionAttaquant = QtGui.QToolButton(self.panneauGestionCombat)
+        self.selectionAttaquant.setGeometry(QtCore.QRect(480, 10, 25, 19))
+        icon2 = QtGui.QIcon()
+        icon2.addPixmap(QtGui.QPixmap(_fromUtf8("img/btn_ModeCombat.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.selectionAttaquant.setIcon(icon2)
+        self.selectionAttaquant.setObjectName(_fromUtf8("selectionAttaquant"))
+        self.selectionPionEnCours = QtGui.QToolButton(self.panneauGestionCombat)
+        self.selectionPionEnCours.setGeometry(QtCore.QRect(450, 10, 25, 19))
+        icon3 = QtGui.QIcon()
+        icon3.addPixmap(QtGui.QPixmap(_fromUtf8("img/flecheDroite2.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.selectionPionEnCours.setIcon(icon3)
+        self.selectionPionEnCours.setObjectName(_fromUtf8("selectionPionEnCours"))
+        self.gestionCombatAide = QtGui.QToolButton(gestionCombat)
+        self.gestionCombatAide.setGeometry(QtCore.QRect(540, 10, 25, 19))
+        self.gestionCombatAide.setObjectName(_fromUtf8("gestionCombatAide"))
+
+        self.retranslateUi(gestionCombat)
+        QtCore.QMetaObject.connectSlotsByName(gestionCombat)
+
+    def retranslateUi(self, gestionCombat):
+        gestionCombat.setWindowTitle(_translate("gestionCombat", "Tableau de combat", None))
+        self.label_4.setText(_translate("gestionCombat", "Attaquant : ", None))
+        self.label.setText(_translate("gestionCombat", "GESTION DU COMBAT", None))
+        self.jetDes.setPlaceholderText(_translate("gestionCombat", "Entrer un jet de des ou une valeur", None))
+        self.afficherDetailDes.setText(_translate("gestionCombat", "Afficher le détail", None))
+        self.affecterJetsDes.setTitle(_translate("gestionCombat", "Utiliser les résultats : ", None))
+        self.majValeurRemplacer.setText(_translate("gestionCombat", "Remplacer", None))
+        self.majValeurRetirer.setText(_translate("gestionCombat", "Retirer", None))
+        self.majValeurAjouter.setText(_translate("gestionCombat", "Ajouter", None))
+        self.label_2.setText(_translate("gestionCombat", "=>", None))
+        self.majChamp.setText(_translate("gestionCombat", "OK", None))
+        self.validerJetDes.setText(_translate("gestionCombat", "...", None))
+        self.masquerHorsCombat.setText(_translate("gestionCombat", "Masquer les pions hors-combat", None))
+        self.jetDesIndependants.setText(_translate("gestionCombat", "Jets indépendants", None))
+        self.selectionDefenseur.setToolTip(_translate("gestionCombat", "Pion(s) defenseur(s)", None))
+        self.selectionDefenseur.setText(_translate("gestionCombat", "...", None))
+        self.label_3.setText(_translate("gestionCombat", "Sélectionner : ", None))
+        self.selectionAttaquant.setToolTip(_translate("gestionCombat", "Pion attaquant", None))
+        self.selectionAttaquant.setText(_translate("gestionCombat", "...", None))
+        self.selectionPionEnCours.setToolTip(_translate("gestionCombat", "Pion en cours", None))
+        self.selectionPionEnCours.setText(_translate("gestionCombat", "...", None))
+        self.gestionCombatAide.setText(_translate("gestionCombat", "?", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    gestionCombat = QtGui.QFrame()
+    ui = Ui_gestionCombat()
+    ui.setupUi(gestionCombat)
+    gestionCombat.show()
+    sys.exit(app.exec_())
+

lib/ui/ecran_principal.py

@@ -0,0 +1,1557 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'mainwindow.ui'
+#
+# Created: Thu Nov 27 20:43:52 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_principal(object):
+    def setupUi(self, principal):
+        principal.setObjectName(_fromUtf8("principal"))
+        principal.resize(1225, 741)
+        principal.setMinimumSize(QtCore.QSize(882, 623))
+        principal.setAcceptDrops(True)
+        self.baseWidget = QtGui.QWidget(principal)
+        self.baseWidget.setObjectName(_fromUtf8("baseWidget"))
+        self.horizontalLayout = QtGui.QHBoxLayout(self.baseWidget)
+        self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
+        self.tabWidget = QtGui.QTabWidget(self.baseWidget)
+        self.tabWidget.setMinimumSize(QtCore.QSize(641, 561))
+        self.tabWidget.setAcceptDrops(True)
+        self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
+        self.Combats_tab = QtGui.QWidget()
+        self.Combats_tab.setObjectName(_fromUtf8("Combats_tab"))
+        self.horizontalLayout_3 = QtGui.QHBoxLayout(self.Combats_tab)
+        self.horizontalLayout_3.setObjectName(_fromUtf8("horizontalLayout_3"))
+        self.layoutCombat = QtGui.QHBoxLayout()
+        self.layoutCombat.setSpacing(0)
+        self.layoutCombat.setSizeConstraint(QtGui.QLayout.SetMaximumSize)
+        self.layoutCombat.setObjectName(_fromUtf8("layoutCombat"))
+        self.panneauInfosPlateau_2 = QtGui.QFrame(self.Combats_tab)
+        self.panneauInfosPlateau_2.setObjectName(_fromUtf8("panneauInfosPlateau_2"))
+        self.panneauInfosPlateau = QtGui.QVBoxLayout(self.panneauInfosPlateau_2)
+        self.panneauInfosPlateau.setSpacing(0)
+        self.panneauInfosPlateau.setObjectName(_fromUtf8("panneauInfosPlateau"))
+        self.combatTour = QtGui.QLabel(self.panneauInfosPlateau_2)
+        self.combatTour.setMinimumSize(QtCore.QSize(80, 20))
+        self.combatTour.setMaximumSize(QtCore.QSize(110, 20))
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        font.setBold(True)
+        font.setWeight(75)
+        self.combatTour.setFont(font)
+        self.combatTour.setFrameShape(QtGui.QFrame.WinPanel)
+        self.combatTour.setFrameShadow(QtGui.QFrame.Sunken)
+        self.combatTour.setAlignment(QtCore.Qt.AlignCenter)
+        self.combatTour.setObjectName(_fromUtf8("combatTour"))
+        self.panneauInfosPlateau.addWidget(self.combatTour)
+        self.infoOrdreJeu = QtGui.QTableWidget(self.panneauInfosPlateau_2)
+        self.infoOrdreJeu.setMinimumSize(QtCore.QSize(80, 208))
+        self.infoOrdreJeu.setMaximumSize(QtCore.QSize(110, 16777215))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 120))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 120))
+        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.infoOrdreJeu.setPalette(palette)
+        self.infoOrdreJeu.setFrameShape(QtGui.QFrame.WinPanel)
+        self.infoOrdreJeu.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
+        self.infoOrdreJeu.setDragDropOverwriteMode(False)
+        self.infoOrdreJeu.setAlternatingRowColors(False)
+        self.infoOrdreJeu.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+        self.infoOrdreJeu.setSelectionBehavior(QtGui.QAbstractItemView.SelectItems)
+        self.infoOrdreJeu.setTextElideMode(QtCore.Qt.ElideMiddle)
+        self.infoOrdreJeu.setCornerButtonEnabled(False)
+        self.infoOrdreJeu.setObjectName(_fromUtf8("infoOrdreJeu"))
+        self.infoOrdreJeu.setColumnCount(3)
+        self.infoOrdreJeu.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.infoOrdreJeu.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.infoOrdreJeu.setHorizontalHeaderItem(1, item)
+        item = QtGui.QTableWidgetItem()
+        self.infoOrdreJeu.setHorizontalHeaderItem(2, item)
+        self.infoOrdreJeu.horizontalHeader().setVisible(False)
+        self.infoOrdreJeu.horizontalHeader().setDefaultSectionSize(100)
+        self.infoOrdreJeu.verticalHeader().setVisible(True)
+        self.panneauInfosPlateau.addWidget(self.infoOrdreJeu)
+        self.frame_2 = QtGui.QFrame(self.panneauInfosPlateau_2)
+        self.frame_2.setMinimumSize(QtCore.QSize(80, 330))
+        self.frame_2.setMaximumSize(QtCore.QSize(110, 415))
+        self.frame_2.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.frame_2.setFrameShadow(QtGui.QFrame.Raised)
+        self.frame_2.setObjectName(_fromUtf8("frame_2"))
+        self.infoCase = QtGui.QGroupBox(self.frame_2)
+        self.infoCase.setGeometry(QtCore.QRect(0, 240, 110, 90))
+        self.infoCase.setMinimumSize(QtCore.QSize(101, 90))
+        self.infoCase.setMaximumSize(QtCore.QSize(110, 16777215))
+        self.infoCase.setTitle(_fromUtf8(""))
+        self.infoCase.setObjectName(_fromUtf8("infoCase"))
+        self.infoPionEnCours_depRestant_2 = QtGui.QLabel(self.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        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.infoCase)
+        self.infoPionEnCours_vol_2.setGeometry(QtCore.QRect(60, 160, 21, 21))
+        self.infoPionEnCours_vol_2.setObjectName(_fromUtf8("infoPionEnCours_vol_2"))
+        self.infoCaseEnCours_terrain = QtGui.QLabel(self.infoCase)
+        self.infoCaseEnCours_terrain.setGeometry(QtCore.QRect(10, 0, 61, 21))
+        self.infoCaseEnCours_terrain.setMargin(1)
+        self.infoCaseEnCours_terrain.setIndent(-1)
+        self.infoCaseEnCours_terrain.setObjectName(_fromUtf8("infoCaseEnCours_terrain"))
+        self.infoCaseEnCours_coord = QtGui.QLabel(self.infoCase)
+        self.infoCaseEnCours_coord.setGeometry(QtCore.QRect(10, 20, 61, 21))
+        self.infoCaseEnCours_coord.setMargin(1)
+        self.infoCaseEnCours_coord.setIndent(-1)
+        self.infoCaseEnCours_coord.setObjectName(_fromUtf8("infoCaseEnCours_coord"))
+        self.infoCaseEnCours_effetNom = QtGui.QLabel(self.infoCase)
+        self.infoCaseEnCours_effetNom.setGeometry(QtCore.QRect(35, 60, 41, 21))
+        self.infoCaseEnCours_effetNom.setMargin(1)
+        self.infoCaseEnCours_effetNom.setIndent(-1)
+        self.infoCaseEnCours_effetNom.setObjectName(_fromUtf8("infoCaseEnCours_effetNom"))
+        self.infoCaseEnCours_effetImg = QtGui.QLabel(self.infoCase)
+        self.infoCaseEnCours_effetImg.setGeometry(QtCore.QRect(10, 60, 21, 21))
+        self.infoCaseEnCours_effetImg.setMargin(1)
+        self.infoCaseEnCours_effetImg.setIndent(-1)
+        self.infoCaseEnCours_effetImg.setObjectName(_fromUtf8("infoCaseEnCours_effetImg"))
+        self.infoCaseEnCours_altitude = QtGui.QLabel(self.infoCase)
+        self.infoCaseEnCours_altitude.setGeometry(QtCore.QRect(10, 40, 61, 21))
+        self.infoCaseEnCours_altitude.setMargin(1)
+        self.infoCaseEnCours_altitude.setIndent(-1)
+        self.infoCaseEnCours_altitude.setObjectName(_fromUtf8("infoCaseEnCours_altitude"))
+        self.infoDecor = QtGui.QGroupBox(self.frame_2)
+        self.infoDecor.setEnabled(True)
+        self.infoDecor.setGeometry(QtCore.QRect(0, 150, 110, 91))
+        self.infoDecor.setMinimumSize(QtCore.QSize(101, 91))
+        self.infoDecor.setMaximumSize(QtCore.QSize(110, 16777215))
+        self.infoDecor.setTitle(_fromUtf8(""))
+        self.infoDecor.setObjectName(_fromUtf8("infoDecor"))
+        self.infoDecorEnCours_nom = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_nom.setGeometry(QtCore.QRect(10, 0, 61, 21))
+        self.infoDecorEnCours_nom.setObjectName(_fromUtf8("infoDecorEnCours_nom"))
+        self.infoDecorEnCours_image = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_image.setGeometry(QtCore.QRect(10, 20, 41, 31))
+        self.infoDecorEnCours_image.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.infoDecorEnCours_image.setText(_fromUtf8(""))
+        self.infoDecorEnCours_image.setObjectName(_fromUtf8("infoDecorEnCours_image"))
+        self.infoDecorEnCours_hauteur = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_hauteur.setGeometry(QtCore.QRect(10, 50, 61, 21))
+        self.infoDecorEnCours_hauteur.setObjectName(_fromUtf8("infoDecorEnCours_hauteur"))
+        self.infoDecorEnCours_brule = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_brule.setGeometry(QtCore.QRect(0, 70, 21, 21))
+        self.infoDecorEnCours_brule.setObjectName(_fromUtf8("infoDecorEnCours_brule"))
+        self.infoDecorEnCours_detruit = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_detruit.setGeometry(QtCore.QRect(20, 70, 21, 21))
+        self.infoDecorEnCours_detruit.setObjectName(_fromUtf8("infoDecorEnCours_detruit"))
+        self.infoDecorEnCours_verrouille = QtGui.QLabel(self.infoDecor)
+        self.infoDecorEnCours_verrouille.setGeometry(QtCore.QRect(40, 70, 21, 21))
+        self.infoDecorEnCours_verrouille.setObjectName(_fromUtf8("infoDecorEnCours_verrouille"))
+        self.infoPion = QtGui.QGroupBox(self.frame_2)
+        self.infoPion.setGeometry(QtCore.QRect(0, 0, 110, 151))
+        self.infoPion.setMinimumSize(QtCore.QSize(101, 151))
+        self.infoPion.setMaximumSize(QtCore.QSize(110, 16777215))
+        self.infoPion.setTitle(_fromUtf8(""))
+        self.infoPion.setObjectName(_fromUtf8("infoPion"))
+        self.infoPionEnCours_sante = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_sante.setGeometry(QtCore.QRect(10, 70, 61, 21))
+        self.infoPionEnCours_sante.setMargin(1)
+        self.infoPionEnCours_sante.setIndent(-1)
+        self.infoPionEnCours_sante.setObjectName(_fromUtf8("infoPionEnCours_sante"))
+        self.infoPionEnCours_depRestant = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_depRestant.setGeometry(QtCore.QRect(10, 90, 61, 21))
+        self.infoPionEnCours_depRestant.setMargin(1)
+        self.infoPionEnCours_depRestant.setObjectName(_fromUtf8("infoPionEnCours_depRestant"))
+        self.infoPionEnCours_image = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_image.setGeometry(QtCore.QRect(10, 20, 61, 51))
+        self.infoPionEnCours_image.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.infoPionEnCours_image.setText(_fromUtf8(""))
+        self.infoPionEnCours_image.setObjectName(_fromUtf8("infoPionEnCours_image"))
+        self.infoPionEnCours_endormi = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_endormi.setGeometry(QtCore.QRect(0, 130, 16, 16))
+        self.infoPionEnCours_endormi.setText(_fromUtf8(""))
+        self.infoPionEnCours_endormi.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatEndormi.png")))
+        self.infoPionEnCours_endormi.setScaledContents(False)
+        self.infoPionEnCours_endormi.setObjectName(_fromUtf8("infoPionEnCours_endormi"))
+        self.infoPionEnCours_paralyse = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_paralyse.setGeometry(QtCore.QRect(20, 130, 16, 16))
+        self.infoPionEnCours_paralyse.setText(_fromUtf8(""))
+        self.infoPionEnCours_paralyse.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatParalyse.png")))
+        self.infoPionEnCours_paralyse.setScaledContents(True)
+        self.infoPionEnCours_paralyse.setObjectName(_fromUtf8("infoPionEnCours_paralyse"))
+        self.infoPionEnCours_entrave = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_entrave.setGeometry(QtCore.QRect(40, 130, 21, 21))
+        self.infoPionEnCours_entrave.setText(_fromUtf8(""))
+        self.infoPionEnCours_entrave.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatEntrave.png")))
+        self.infoPionEnCours_entrave.setScaledContents(False)
+        self.infoPionEnCours_entrave.setObjectName(_fromUtf8("infoPionEnCours_entrave"))
+        self.infoPionEnCours_mort = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_mort.setGeometry(QtCore.QRect(60, 130, 16, 16))
+        self.infoPionEnCours_mort.setText(_fromUtf8(""))
+        self.infoPionEnCours_mort.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatMort.png")))
+        self.infoPionEnCours_mort.setScaledContents(False)
+        self.infoPionEnCours_mort.setObjectName(_fromUtf8("infoPionEnCours_mort"))
+        self.infoPionEnCours_etourdi = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_etourdi.setGeometry(QtCore.QRect(0, 111, 16, 16))
+        self.infoPionEnCours_etourdi.setText(_fromUtf8(""))
+        self.infoPionEnCours_etourdi.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatEtourdi.png")))
+        self.infoPionEnCours_etourdi.setScaledContents(False)
+        self.infoPionEnCours_etourdi.setObjectName(_fromUtf8("infoPionEnCours_etourdi"))
+        self.infoPionEnCours_brule = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_brule.setGeometry(QtCore.QRect(20, 110, 16, 16))
+        self.infoPionEnCours_brule.setText(_fromUtf8(""))
+        self.infoPionEnCours_brule.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatFeu.png")))
+        self.infoPionEnCours_brule.setScaledContents(False)
+        self.infoPionEnCours_brule.setObjectName(_fromUtf8("infoPionEnCours_brule"))
+        self.infoPionEnCours_mouille = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_mouille.setGeometry(QtCore.QRect(40, 110, 21, 21))
+        self.infoPionEnCours_mouille.setText(_fromUtf8(""))
+        self.infoPionEnCours_mouille.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatEau.png")))
+        self.infoPionEnCours_mouille.setScaledContents(False)
+        self.infoPionEnCours_mouille.setObjectName(_fromUtf8("infoPionEnCours_mouille"))
+        self.infoPionEnCours_vol = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_vol.setGeometry(QtCore.QRect(60, 110, 21, 21))
+        self.infoPionEnCours_vol.setText(_fromUtf8(""))
+        self.infoPionEnCours_vol.setPixmap(QtGui.QPixmap(_fromUtf8("img/etatVol.png")))
+        self.infoPionEnCours_vol.setScaledContents(False)
+        self.infoPionEnCours_vol.setObjectName(_fromUtf8("infoPionEnCours_vol"))
+        self.infoPionEnCours_nom = QtGui.QLabel(self.infoPion)
+        self.infoPionEnCours_nom.setGeometry(QtCore.QRect(10, 0, 61, 21))
+        self.infoPionEnCours_nom.setMargin(1)
+        self.infoPionEnCours_nom.setIndent(-1)
+        self.infoPionEnCours_nom.setObjectName(_fromUtf8("infoPionEnCours_nom"))
+        self.panneauInfosPlateau.addWidget(self.frame_2)
+        self.layoutCombat.addWidget(self.panneauInfosPlateau_2)
+        self.layoutCombatCentre = QtGui.QVBoxLayout()
+        self.layoutCombatCentre.setSpacing(0)
+        self.layoutCombatCentre.setObjectName(_fromUtf8("layoutCombatCentre"))
+        self.nomPlateau = QtGui.QLabel(self.Combats_tab)
+        font = QtGui.QFont()
+        font.setFamily(_fromUtf8("Georgia"))
+        font.setPointSize(9)
+        font.setBold(True)
+        font.setWeight(75)
+        self.nomPlateau.setFont(font)
+        self.nomPlateau.setScaledContents(True)
+        self.nomPlateau.setAlignment(QtCore.Qt.AlignCenter)
+        self.nomPlateau.setWordWrap(True)
+        self.nomPlateau.setObjectName(_fromUtf8("nomPlateau"))
+        self.layoutCombatCentre.addWidget(self.nomPlateau)
+        self.vuePlateau = QtGui.QGraphicsView(self.Combats_tab)
+        self.vuePlateau.setMinimumSize(QtCore.QSize(0, 0))
+        self.vuePlateau.setAcceptDrops(True)
+        self.vuePlateau.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        self.vuePlateau.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded)
+        self.vuePlateau.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.HighQualityAntialiasing|QtGui.QPainter.TextAntialiasing)
+        self.vuePlateau.setDragMode(QtGui.QGraphicsView.NoDrag)
+        self.vuePlateau.setTransformationAnchor(QtGui.QGraphicsView.NoAnchor)
+        self.vuePlateau.setResizeAnchor(QtGui.QGraphicsView.NoAnchor)
+        self.vuePlateau.setViewportUpdateMode(QtGui.QGraphicsView.MinimalViewportUpdate)
+        self.vuePlateau.setObjectName(_fromUtf8("vuePlateau"))
+        self.layoutCombatCentre.addWidget(self.vuePlateau)
+        self.barreBasCombat = QtGui.QFrame(self.Combats_tab)
+        self.barreBasCombat.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.barreBasCombat.setFrameShadow(QtGui.QFrame.Raised)
+        self.barreBasCombat.setObjectName(_fromUtf8("barreBasCombat"))
+        self.horizontalLayout_2 = QtGui.QHBoxLayout(self.barreBasCombat)
+        self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
+        self.combatDeplacement = QtGui.QToolButton(self.barreBasCombat)
+        self.combatDeplacement.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatDeplacement.setMaximumSize(QtCore.QSize(46, 44))
+        self.combatDeplacement.setText(_fromUtf8(""))
+        icon = QtGui.QIcon()
+        icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnZonePlacement.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatDeplacement.setIcon(icon)
+        self.combatDeplacement.setObjectName(_fromUtf8("combatDeplacement"))
+        self.horizontalLayout_2.addWidget(self.combatDeplacement)
+        self.combatAttaqueCaC = QtGui.QToolButton(self.barreBasCombat)
+        self.combatAttaqueCaC.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatAttaqueCaC.setMaximumSize(QtCore.QSize(46, 44))
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8("img/curseurEpee.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatAttaqueCaC.setIcon(icon1)
+        self.combatAttaqueCaC.setObjectName(_fromUtf8("combatAttaqueCaC"))
+        self.horizontalLayout_2.addWidget(self.combatAttaqueCaC)
+        self.combatAttaqueDist = QtGui.QToolButton(self.barreBasCombat)
+        self.combatAttaqueDist.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatAttaqueDist.setMaximumSize(QtCore.QSize(46, 44))
+        icon2 = QtGui.QIcon()
+        icon2.addPixmap(QtGui.QPixmap(_fromUtf8("img/arc.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatAttaqueDist.setIcon(icon2)
+        self.combatAttaqueDist.setObjectName(_fromUtf8("combatAttaqueDist"))
+        self.horizontalLayout_2.addWidget(self.combatAttaqueDist)
+        self.combatAttaqueZone = QtGui.QToolButton(self.barreBasCombat)
+        self.combatAttaqueZone.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatAttaqueZone.setMaximumSize(QtCore.QSize(46, 44))
+        icon3 = QtGui.QIcon()
+        icon3.addPixmap(QtGui.QPixmap(_fromUtf8("img/bombe.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatAttaqueZone.setIcon(icon3)
+        self.combatAttaqueZone.setObjectName(_fromUtf8("combatAttaqueZone"))
+        self.horizontalLayout_2.addWidget(self.combatAttaqueZone)
+        self.combatVol = QtGui.QToolButton(self.barreBasCombat)
+        self.combatVol.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatVol.setMaximumSize(QtCore.QSize(46, 44))
+        icon4 = QtGui.QIcon()
+        icon4.addPixmap(QtGui.QPixmap(_fromUtf8("img/etatVol.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatVol.setIcon(icon4)
+        self.combatVol.setObjectName(_fromUtf8("combatVol"))
+        self.horizontalLayout_2.addWidget(self.combatVol)
+        self.combatVol_altitude = QtGui.QSpinBox(self.barreBasCombat)
+        self.combatVol_altitude.setMinimumSize(QtCore.QSize(40, 44))
+        self.combatVol_altitude.setMaximumSize(QtCore.QSize(60, 16777215))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(True)
+        font.setWeight(75)
+        self.combatVol_altitude.setFont(font)
+        self.combatVol_altitude.setObjectName(_fromUtf8("combatVol_altitude"))
+        self.horizontalLayout_2.addWidget(self.combatVol_altitude)
+        self.combatZone_ligne = QtGui.QToolButton(self.barreBasCombat)
+        self.combatZone_ligne.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatZone_ligne.setMaximumSize(QtCore.QSize(46, 44))
+        self.combatZone_ligne.setText(_fromUtf8(""))
+        icon5 = QtGui.QIcon()
+        icon5.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeLigne.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatZone_ligne.setIcon(icon5)
+        self.combatZone_ligne.setObjectName(_fromUtf8("combatZone_ligne"))
+        self.horizontalLayout_2.addWidget(self.combatZone_ligne)
+        self.combatZone_disque = QtGui.QToolButton(self.barreBasCombat)
+        self.combatZone_disque.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatZone_disque.setMaximumSize(QtCore.QSize(46, 44))
+        self.combatZone_disque.setText(_fromUtf8(""))
+        icon6 = QtGui.QIcon()
+        icon6.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeEllipsePlein.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatZone_disque.setIcon(icon6)
+        self.combatZone_disque.setObjectName(_fromUtf8("combatZone_disque"))
+        self.horizontalLayout_2.addWidget(self.combatZone_disque)
+        self.combatZone_disqueRayon = QtGui.QSpinBox(self.barreBasCombat)
+        self.combatZone_disqueRayon.setMinimumSize(QtCore.QSize(40, 44))
+        font = QtGui.QFont()
+        font.setPointSize(12)
+        font.setBold(True)
+        font.setItalic(False)
+        font.setWeight(75)
+        self.combatZone_disqueRayon.setFont(font)
+        self.combatZone_disqueRayon.setMinimum(1)
+        self.combatZone_disqueRayon.setMaximum(30)
+        self.combatZone_disqueRayon.setObjectName(_fromUtf8("combatZone_disqueRayon"))
+        self.horizontalLayout_2.addWidget(self.combatZone_disqueRayon)
+        self.combatZone_cone = QtGui.QToolButton(self.barreBasCombat)
+        self.combatZone_cone.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatZone_cone.setMaximumSize(QtCore.QSize(46, 44))
+        self.combatZone_cone.setText(_fromUtf8(""))
+        icon7 = QtGui.QIcon()
+        icon7.addPixmap(QtGui.QPixmap(_fromUtf8("img/cone.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatZone_cone.setIcon(icon7)
+        self.combatZone_cone.setObjectName(_fromUtf8("combatZone_cone"))
+        self.horizontalLayout_2.addWidget(self.combatZone_cone)
+        self.combatRetour = QtGui.QToolButton(self.barreBasCombat)
+        self.combatRetour.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatRetour.setMaximumSize(QtCore.QSize(46, 44))
+        self.combatRetour.setText(_fromUtf8(""))
+        icon8 = QtGui.QIcon()
+        icon8.addPixmap(QtGui.QPixmap(_fromUtf8("img/retour.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatRetour.setIcon(icon8)
+        self.combatRetour.setObjectName(_fromUtf8("combatRetour"))
+        self.horizontalLayout_2.addWidget(self.combatRetour)
+        self.combatPionSelectionne_img = QtGui.QLabel(self.barreBasCombat)
+        self.combatPionSelectionne_img.setObjectName(_fromUtf8("combatPionSelectionne_img"))
+        self.horizontalLayout_2.addWidget(self.combatPionSelectionne_img)
+        self.combatPionSelectionne = QtGui.QLabel(self.barreBasCombat)
+        self.combatPionSelectionne.setObjectName(_fromUtf8("combatPionSelectionne"))
+        self.horizontalLayout_2.addWidget(self.combatPionSelectionne)
+        self.combatPasserTour = QtGui.QPushButton(self.barreBasCombat)
+        self.combatPasserTour.setMinimumSize(QtCore.QSize(0, 44))
+        self.combatPasserTour.setMaximumSize(QtCore.QSize(16777215, 44))
+        self.combatPasserTour.setObjectName(_fromUtf8("combatPasserTour"))
+        self.horizontalLayout_2.addWidget(self.combatPasserTour)
+        self.combatInventaire = QtGui.QToolButton(self.barreBasCombat)
+        self.combatInventaire.setMinimumSize(QtCore.QSize(23, 44))
+        self.combatInventaire.setMaximumSize(QtCore.QSize(46, 44))
+        icon9 = QtGui.QIcon()
+        icon9.addPixmap(QtGui.QPixmap(_fromUtf8("img/sac.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.combatInventaire.setIcon(icon9)
+        self.combatInventaire.setObjectName(_fromUtf8("combatInventaire"))
+        self.horizontalLayout_2.addWidget(self.combatInventaire)
+        self.layoutCombatCentre.addWidget(self.barreBasCombat)
+        self.layoutCombat.addLayout(self.layoutCombatCentre)
+        self.panneauOutilsPlateau = QtGui.QVBoxLayout()
+        self.panneauOutilsPlateau.setSpacing(0)
+        self.panneauOutilsPlateau.setObjectName(_fromUtf8("panneauOutilsPlateau"))
+        self.layoutBoutonsPlateau = QtGui.QHBoxLayout()
+        self.layoutBoutonsPlateau.setSpacing(1)
+        self.layoutBoutonsPlateau.setObjectName(_fromUtf8("layoutBoutonsPlateau"))
+        self.modeCombatPlateau = QtGui.QPushButton(self.Combats_tab)
+        self.modeCombatPlateau.setMinimumSize(QtCore.QSize(34, 24))
+        self.modeCombatPlateau.setMaximumSize(QtCore.QSize(34, 24))
+        self.modeCombatPlateau.setText(_fromUtf8(""))
+        icon10 = QtGui.QIcon()
+        icon10.addPixmap(QtGui.QPixmap(_fromUtf8("img/btn_ModeCombat.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.modeCombatPlateau.setIcon(icon10)
+        self.modeCombatPlateau.setObjectName(_fromUtf8("modeCombatPlateau"))
+        self.layoutBoutonsPlateau.addWidget(self.modeCombatPlateau)
+        self.modeCreationPlateau = QtGui.QPushButton(self.Combats_tab)
+        self.modeCreationPlateau.setMinimumSize(QtCore.QSize(34, 24))
+        self.modeCreationPlateau.setMaximumSize(QtCore.QSize(34, 24))
+        self.modeCreationPlateau.setText(_fromUtf8(""))
+        icon11 = QtGui.QIcon()
+        icon11.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnCreation.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.modeCreationPlateau.setIcon(icon11)
+        self.modeCreationPlateau.setObjectName(_fromUtf8("modeCreationPlateau"))
+        self.layoutBoutonsPlateau.addWidget(self.modeCreationPlateau)
+        self.sauverPlateau = QtGui.QPushButton(self.Combats_tab)
+        self.sauverPlateau.setMinimumSize(QtCore.QSize(34, 24))
+        self.sauverPlateau.setMaximumSize(QtCore.QSize(34, 24))
+        self.sauverPlateau.setText(_fromUtf8(""))
+        icon12 = QtGui.QIcon()
+        icon12.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnEnregistrer.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.sauverPlateau.setIcon(icon12)
+        self.sauverPlateau.setObjectName(_fromUtf8("sauverPlateau"))
+        self.layoutBoutonsPlateau.addWidget(self.sauverPlateau)
+        self.fermerPlateau = QtGui.QPushButton(self.Combats_tab)
+        self.fermerPlateau.setMinimumSize(QtCore.QSize(34, 24))
+        self.fermerPlateau.setMaximumSize(QtCore.QSize(34, 24))
+        self.fermerPlateau.setText(_fromUtf8(""))
+        icon13 = QtGui.QIcon()
+        icon13.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnFermer.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.fermerPlateau.setIcon(icon13)
+        self.fermerPlateau.setObjectName(_fromUtf8("fermerPlateau"))
+        self.layoutBoutonsPlateau.addWidget(self.fermerPlateau)
+        self.panneauOutilsPlateau.addLayout(self.layoutBoutonsPlateau)
+        self.layoutPanneauPlateau = QtGui.QHBoxLayout()
+        self.layoutPanneauPlateau.setSpacing(0)
+        self.layoutPanneauPlateau.setObjectName(_fromUtf8("layoutPanneauPlateau"))
+        self.outilsEditionPlateau = QtGui.QToolBox(self.Combats_tab)
+        self.outilsEditionPlateau.setMinimumSize(QtCore.QSize(120, 0))
+        self.outilsEditionPlateau.setMaximumSize(QtCore.QSize(120, 16777215))
+        font = QtGui.QFont()
+        font.setBold(False)
+        font.setItalic(False)
+        font.setUnderline(False)
+        font.setWeight(50)
+        self.outilsEditionPlateau.setFont(font)
+        self.outilsEditionPlateau.setAutoFillBackground(True)
+        self.outilsEditionPlateau.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.outilsEditionPlateau.setFrameShadow(QtGui.QFrame.Sunken)
+        self.outilsEditionPlateau.setLineWidth(1)
+        self.outilsEditionPlateau.setMidLineWidth(0)
+        self.outilsEditionPlateau.setObjectName(_fromUtf8("outilsEditionPlateau"))
+        self.editPlateau_Terrain = QtGui.QWidget()
+        self.editPlateau_Terrain.setGeometry(QtCore.QRect(0, 0, 118, 490))
+        self.editPlateau_Terrain.setObjectName(_fromUtf8("editPlateau_Terrain"))
+        self.terrainCouleur = QtGui.QPushButton(self.editPlateau_Terrain)
+        self.terrainCouleur.setGeometry(QtCore.QRect(80, 60, 31, 21))
+        self.terrainCouleur.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu)
+        self.terrainCouleur.setText(_fromUtf8(""))
+        icon14 = QtGui.QIcon()
+        icon14.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnCouleurs.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.terrainCouleur.setIcon(icon14)
+        self.terrainCouleur.setObjectName(_fromUtf8("terrainCouleur"))
+        self.listTerrains = QtGui.QTableWidget(self.editPlateau_Terrain)
+        self.listTerrains.setGeometry(QtCore.QRect(10, 110, 101, 201))
+        self.listTerrains.setMinimumSize(QtCore.QSize(81, 0))
+        self.listTerrains.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
+        self.listTerrains.setIconSize(QtCore.QSize(2, 2))
+        self.listTerrains.setColumnCount(2)
+        self.listTerrains.setObjectName(_fromUtf8("listTerrains"))
+        self.listTerrains.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listTerrains.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        font = QtGui.QFont()
+        font.setPointSize(9)
+        item.setFont(font)
+        self.listTerrains.setHorizontalHeaderItem(1, item)
+        self.listTerrains.horizontalHeader().setVisible(False)
+        self.listTerrains.verticalHeader().setVisible(False)
+        self.terrainNouveau = QtGui.QPushButton(self.editPlateau_Terrain)
+        self.terrainNouveau.setGeometry(QtCore.QRect(60, 310, 51, 21))
+        self.terrainNouveau.setObjectName(_fromUtf8("terrainNouveau"))
+        self.terrainEdit = QtGui.QPushButton(self.editPlateau_Terrain)
+        self.terrainEdit.setGeometry(QtCore.QRect(10, 310, 51, 21))
+        self.terrainEdit.setObjectName(_fromUtf8("terrainEdit"))
+        self.effFeu = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.effFeu.setGeometry(QtCore.QRect(10, 360, 21, 19))
+        self.effFeu.setWhatsThis(_fromUtf8(""))
+        icon15 = QtGui.QIcon()
+        icon15.addPixmap(QtGui.QPixmap(_fromUtf8("img/effFeu.jpg")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.effFeu.setIcon(icon15)
+        self.effFeu.setObjectName(_fromUtf8("effFeu"))
+        self.effEau = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.effEau.setGeometry(QtCore.QRect(30, 360, 21, 19))
+        self.effEau.setWhatsThis(_fromUtf8(""))
+        icon16 = QtGui.QIcon()
+        icon16.addPixmap(QtGui.QPixmap(_fromUtf8("img/etatEau.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.effEau.setIcon(icon16)
+        self.effEau.setObjectName(_fromUtf8("effEau"))
+        self.effGlace = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.effGlace.setGeometry(QtCore.QRect(50, 360, 21, 19))
+        self.effGlace.setWhatsThis(_fromUtf8(""))
+        icon17 = QtGui.QIcon()
+        icon17.addPixmap(QtGui.QPixmap(_fromUtf8("img/effGlace.jpg")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.effGlace.setIcon(icon17)
+        self.effGlace.setObjectName(_fromUtf8("effGlace"))
+        self.effPoison = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.effPoison.setGeometry(QtCore.QRect(70, 360, 21, 19))
+        self.effPoison.setWhatsThis(_fromUtf8(""))
+        icon18 = QtGui.QIcon()
+        icon18.addPixmap(QtGui.QPixmap(_fromUtf8("img/effPoison.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.effPoison.setIcon(icon18)
+        self.effPoison.setObjectName(_fromUtf8("effPoison"))
+        self.effEffacer = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.effEffacer.setGeometry(QtCore.QRect(90, 360, 21, 19))
+        self.effEffacer.setWhatsThis(_fromUtf8(""))
+        icon19 = QtGui.QIcon()
+        icon19.addPixmap(QtGui.QPixmap(_fromUtf8("img/gomme.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.effEffacer.setIcon(icon19)
+        self.effEffacer.setObjectName(_fromUtf8("effEffacer"))
+        self.lstCategoriesTerrain = QtGui.QComboBox(self.editPlateau_Terrain)
+        self.lstCategoriesTerrain.setGeometry(QtCore.QRect(10, 90, 101, 21))
+        self.lstCategoriesTerrain.setObjectName(_fromUtf8("lstCategoriesTerrain"))
+        self.lstCategoriesTerrain.addItem(_fromUtf8(""))
+        self.lstCategoriesTerrain.addItem(_fromUtf8(""))
+        self.lstCategoriesTerrain.addItem(_fromUtf8(""))
+        self.lstCategoriesTerrain.addItem(_fromUtf8(""))
+        self.formeLigne = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeLigne.setGeometry(QtCore.QRect(10, 401, 31, 21))
+        self.formeLigne.setIcon(icon5)
+        self.formeLigne.setObjectName(_fromUtf8("formeLigne"))
+        self.formeRectVide = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeRectVide.setGeometry(QtCore.QRect(10, 441, 31, 21))
+        self.formeRectVide.setStatusTip(_fromUtf8(""))
+        icon20 = QtGui.QIcon()
+        icon20.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeRectVide.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.formeRectVide.setIcon(icon20)
+        self.formeRectVide.setObjectName(_fromUtf8("formeRectVide"))
+        self.formeRectPlein = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeRectPlein.setGeometry(QtCore.QRect(40, 441, 31, 21))
+        self.formeRectPlein.setStatusTip(_fromUtf8(""))
+        icon21 = QtGui.QIcon()
+        icon21.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeRectPlein.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.formeRectPlein.setIcon(icon21)
+        self.formeRectPlein.setObjectName(_fromUtf8("formeRectPlein"))
+        self.formeEllipseVide = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeEllipseVide.setGeometry(QtCore.QRect(10, 421, 31, 21))
+        self.formeEllipseVide.setStatusTip(_fromUtf8(""))
+        icon22 = QtGui.QIcon()
+        icon22.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeEllipseVide.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.formeEllipseVide.setIcon(icon22)
+        self.formeEllipseVide.setObjectName(_fromUtf8("formeEllipseVide"))
+        self.formeEllipsePlein = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeEllipsePlein.setGeometry(QtCore.QRect(40, 421, 31, 21))
+        self.formeEllipsePlein.setStatusTip(_fromUtf8(""))
+        self.formeEllipsePlein.setIcon(icon6)
+        self.formeEllipsePlein.setObjectName(_fromUtf8("formeEllipsePlein"))
+        self.formeLigneOrientee = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeLigneOrientee.setGeometry(QtCore.QRect(40, 401, 31, 21))
+        self.formeLigneOrientee.setStatusTip(_fromUtf8(""))
+        icon23 = QtGui.QIcon()
+        icon23.addPixmap(QtGui.QPixmap(_fromUtf8("img/formeLigneOrientee.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.formeLigneOrientee.setIcon(icon23)
+        self.formeLigneOrientee.setObjectName(_fromUtf8("formeLigneOrientee"))
+        self.valeurEpaisseurPinceau = QtGui.QLabel(self.editPlateau_Terrain)
+        self.valeurEpaisseurPinceau.setGeometry(QtCore.QRect(50, 380, 8, 19))
+        self.valeurEpaisseurPinceau.setMinimumSize(QtCore.QSize(8, 19))
+        self.valeurEpaisseurPinceau.setMaximumSize(QtCore.QSize(8, 19))
+        font = QtGui.QFont()
+        font.setPointSize(9)
+        font.setBold(True)
+        font.setWeight(75)
+        self.valeurEpaisseurPinceau.setFont(font)
+        self.valeurEpaisseurPinceau.setObjectName(_fromUtf8("valeurEpaisseurPinceau"))
+        self.epaisseurPinceau = QtGui.QSlider(self.editPlateau_Terrain)
+        self.epaisseurPinceau.setGeometry(QtCore.QRect(80, 380, 20, 81))
+        self.epaisseurPinceau.setMinimum(1)
+        self.epaisseurPinceau.setMaximum(5)
+        self.epaisseurPinceau.setProperty("value", 1)
+        self.epaisseurPinceau.setOrientation(QtCore.Qt.Vertical)
+        self.epaisseurPinceau.setObjectName(_fromUtf8("epaisseurPinceau"))
+        self.formeSimple = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.formeSimple.setGeometry(QtCore.QRect(10, 381, 31, 21))
+        icon24 = QtGui.QIcon()
+        icon24.addPixmap(QtGui.QPixmap(_fromUtf8("img/curseurPinceau.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.formeSimple.setIcon(icon24)
+        self.formeSimple.setObjectName(_fromUtf8("formeSimple"))
+        self.altitudeCase = QtGui.QDoubleSpinBox(self.editPlateau_Terrain)
+        self.altitudeCase.setGeometry(QtCore.QRect(60, 330, 51, 20))
+        self.altitudeCase.setDecimals(0)
+        self.altitudeCase.setMinimum(-200.0)
+        self.altitudeCase.setMaximum(200.0)
+        self.altitudeCase.setProperty("value", 0.0)
+        self.altitudeCase.setObjectName(_fromUtf8("altitudeCase"))
+        self.label_9 = QtGui.QLabel(self.editPlateau_Terrain)
+        self.label_9.setGeometry(QtCore.QRect(10, 329, 51, 20))
+        font = QtGui.QFont()
+        font.setUnderline(True)
+        self.label_9.setFont(font)
+        self.label_9.setObjectName(_fromUtf8("label_9"))
+        self.terrainCouleurPerso1 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso1.setGeometry(QtCore.QRect(10, 0, 16, 16))
+        self.terrainCouleurPerso1.setText(_fromUtf8(""))
+        self.terrainCouleurPerso1.setObjectName(_fromUtf8("terrainCouleurPerso1"))
+        self.terrainCouleurPerso2 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso2.setGeometry(QtCore.QRect(30, 0, 16, 16))
+        self.terrainCouleurPerso2.setText(_fromUtf8(""))
+        self.terrainCouleurPerso2.setObjectName(_fromUtf8("terrainCouleurPerso2"))
+        self.terrainCouleurPerso3 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso3.setGeometry(QtCore.QRect(50, 0, 16, 16))
+        self.terrainCouleurPerso3.setText(_fromUtf8(""))
+        self.terrainCouleurPerso3.setObjectName(_fromUtf8("terrainCouleurPerso3"))
+        self.terrainCouleurPerso4 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso4.setGeometry(QtCore.QRect(70, 0, 16, 16))
+        self.terrainCouleurPerso4.setText(_fromUtf8(""))
+        self.terrainCouleurPerso4.setObjectName(_fromUtf8("terrainCouleurPerso4"))
+        self.terrainCouleurPerso5 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso5.setGeometry(QtCore.QRect(90, 0, 16, 16))
+        self.terrainCouleurPerso5.setText(_fromUtf8(""))
+        self.terrainCouleurPerso5.setObjectName(_fromUtf8("terrainCouleurPerso5"))
+        self.terrainCouleurPerso6 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso6.setGeometry(QtCore.QRect(10, 20, 16, 16))
+        self.terrainCouleurPerso6.setText(_fromUtf8(""))
+        self.terrainCouleurPerso6.setObjectName(_fromUtf8("terrainCouleurPerso6"))
+        self.terrainCouleurPerso7 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso7.setGeometry(QtCore.QRect(30, 20, 16, 16))
+        self.terrainCouleurPerso7.setText(_fromUtf8(""))
+        self.terrainCouleurPerso7.setObjectName(_fromUtf8("terrainCouleurPerso7"))
+        self.terrainCouleurPerso8 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso8.setGeometry(QtCore.QRect(50, 20, 16, 16))
+        self.terrainCouleurPerso8.setText(_fromUtf8(""))
+        self.terrainCouleurPerso8.setObjectName(_fromUtf8("terrainCouleurPerso8"))
+        self.terrainCouleurPerso9 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso9.setGeometry(QtCore.QRect(70, 20, 16, 16))
+        self.terrainCouleurPerso9.setText(_fromUtf8(""))
+        self.terrainCouleurPerso9.setObjectName(_fromUtf8("terrainCouleurPerso9"))
+        self.terrainCouleurPerso10 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso10.setGeometry(QtCore.QRect(90, 20, 16, 16))
+        self.terrainCouleurPerso10.setText(_fromUtf8(""))
+        self.terrainCouleurPerso10.setObjectName(_fromUtf8("terrainCouleurPerso10"))
+        self.terrainCouleurPerso11 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso11.setGeometry(QtCore.QRect(10, 40, 16, 16))
+        self.terrainCouleurPerso11.setText(_fromUtf8(""))
+        self.terrainCouleurPerso11.setObjectName(_fromUtf8("terrainCouleurPerso11"))
+        self.terrainCouleurPerso12 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso12.setGeometry(QtCore.QRect(30, 40, 16, 16))
+        self.terrainCouleurPerso12.setText(_fromUtf8(""))
+        self.terrainCouleurPerso12.setObjectName(_fromUtf8("terrainCouleurPerso12"))
+        self.terrainCouleurPerso13 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso13.setGeometry(QtCore.QRect(50, 40, 16, 16))
+        self.terrainCouleurPerso13.setText(_fromUtf8(""))
+        self.terrainCouleurPerso13.setObjectName(_fromUtf8("terrainCouleurPerso13"))
+        self.terrainCouleurPerso14 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso14.setGeometry(QtCore.QRect(70, 40, 16, 16))
+        self.terrainCouleurPerso14.setText(_fromUtf8(""))
+        self.terrainCouleurPerso14.setObjectName(_fromUtf8("terrainCouleurPerso14"))
+        self.terrainCouleurPerso15 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso15.setGeometry(QtCore.QRect(90, 40, 16, 16))
+        self.terrainCouleurPerso15.setText(_fromUtf8(""))
+        self.terrainCouleurPerso15.setObjectName(_fromUtf8("terrainCouleurPerso15"))
+        self.terrainCouleurPerso16 = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCouleurPerso16.setGeometry(QtCore.QRect(10, 60, 16, 16))
+        self.terrainCouleurPerso16.setText(_fromUtf8(""))
+        self.terrainCouleurPerso16.setObjectName(_fromUtf8("terrainCouleurPerso16"))
+        self.terrainCopie = QtGui.QToolButton(self.editPlateau_Terrain)
+        self.terrainCopie.setGeometry(QtCore.QRect(40, 60, 31, 21))
+        icon25 = QtGui.QIcon()
+        icon25.addPixmap(QtGui.QPixmap(_fromUtf8("img/curseurSeringue.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.terrainCopie.setIcon(icon25)
+        self.terrainCopie.setObjectName(_fromUtf8("terrainCopie"))
+        self.outilsEditionPlateau.addItem(self.editPlateau_Terrain, _fromUtf8(""))
+        self.editPlateau_Decors = QtGui.QWidget()
+        self.editPlateau_Decors.setGeometry(QtCore.QRect(0, 0, 118, 490))
+        self.editPlateau_Decors.setObjectName(_fromUtf8("editPlateau_Decors"))
+        self.decorEdit = QtGui.QPushButton(self.editPlateau_Decors)
+        self.decorEdit.setGeometry(QtCore.QRect(10, 410, 51, 21))
+        self.decorEdit.setObjectName(_fromUtf8("decorEdit"))
+        self.listDecors = QtGui.QTableWidget(self.editPlateau_Decors)
+        self.listDecors.setGeometry(QtCore.QRect(10, 30, 101, 381))
+        self.listDecors.setMinimumSize(QtCore.QSize(81, 0))
+        self.listDecors.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
+        self.listDecors.setIconSize(QtCore.QSize(2, 2))
+        self.listDecors.setColumnCount(2)
+        self.listDecors.setObjectName(_fromUtf8("listDecors"))
+        self.listDecors.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listDecors.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        font = QtGui.QFont()
+        font.setPointSize(9)
+        item.setFont(font)
+        self.listDecors.setHorizontalHeaderItem(1, item)
+        self.listDecors.horizontalHeader().setVisible(False)
+        self.listDecors.verticalHeader().setVisible(False)
+        self.decorNouveau = QtGui.QPushButton(self.editPlateau_Decors)
+        self.decorNouveau.setGeometry(QtCore.QRect(60, 410, 51, 21))
+        self.decorNouveau.setObjectName(_fromUtf8("decorNouveau"))
+        self.comboBox_2 = QtGui.QComboBox(self.editPlateau_Decors)
+        self.comboBox_2.setGeometry(QtCore.QRect(10, 10, 101, 21))
+        self.comboBox_2.setObjectName(_fromUtf8("comboBox_2"))
+        self.comboBox_2.addItem(_fromUtf8(""))
+        self.comboBox_2.addItem(_fromUtf8(""))
+        self.comboBox_2.addItem(_fromUtf8(""))
+        self.comboBox_2.addItem(_fromUtf8(""))
+        self.decorSupprimer = QtGui.QToolButton(self.editPlateau_Decors)
+        self.decorSupprimer.setGeometry(QtCore.QRect(10, 440, 31, 21))
+        self.decorSupprimer.setIcon(icon19)
+        self.decorSupprimer.setObjectName(_fromUtf8("decorSupprimer"))
+        self.outilsEditionPlateau.addItem(self.editPlateau_Decors, _fromUtf8(""))
+        self.editPlateau_Pions = QtGui.QWidget()
+        self.editPlateau_Pions.setGeometry(QtCore.QRect(0, 0, 118, 490))
+        self.editPlateau_Pions.setObjectName(_fromUtf8("editPlateau_Pions"))
+        self.pionCouleur = QtGui.QPushButton(self.editPlateau_Pions)
+        self.pionCouleur.setGeometry(QtCore.QRect(80, 0, 31, 21))
+        self.pionCouleur.setContextMenuPolicy(QtCore.Qt.DefaultContextMenu)
+        self.pionCouleur.setText(_fromUtf8(""))
+        self.pionCouleur.setIcon(icon14)
+        self.pionCouleur.setObjectName(_fromUtf8("pionCouleur"))
+        self.pionSimpleCreer = QtGui.QPushButton(self.editPlateau_Pions)
+        self.pionSimpleCreer.setGeometry(QtCore.QRect(80, 20, 31, 21))
+        self.pionSimpleCreer.setText(_fromUtf8(""))
+        icon26 = QtGui.QIcon()
+        icon26.addPixmap(QtGui.QPixmap(_fromUtf8("img/plus.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.pionSimpleCreer.setIcon(icon26)
+        self.pionSimpleCreer.setObjectName(_fromUtf8("pionSimpleCreer"))
+        self.listCreatures = QtGui.QTableWidget(self.editPlateau_Pions)
+        self.listCreatures.setGeometry(QtCore.QRect(10, 50, 101, 351))
+        self.listCreatures.setMinimumSize(QtCore.QSize(81, 0))
+        self.listCreatures.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
+        self.listCreatures.setIconSize(QtCore.QSize(2, 2))
+        self.listCreatures.setColumnCount(2)
+        self.listCreatures.setObjectName(_fromUtf8("listCreatures"))
+        self.listCreatures.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listCreatures.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        font = QtGui.QFont()
+        font.setPointSize(9)
+        item.setFont(font)
+        self.listCreatures.setHorizontalHeaderItem(1, item)
+        self.listCreatures.horizontalHeader().setVisible(False)
+        self.listCreatures.verticalHeader().setVisible(False)
+        self.creatureEdit = QtGui.QPushButton(self.editPlateau_Pions)
+        self.creatureEdit.setGeometry(QtCore.QRect(10, 400, 51, 21))
+        self.creatureEdit.setObjectName(_fromUtf8("creatureEdit"))
+        self.creatureNouveau = QtGui.QPushButton(self.editPlateau_Pions)
+        self.creatureNouveau.setGeometry(QtCore.QRect(60, 400, 51, 21))
+        self.creatureNouveau.setObjectName(_fromUtf8("creatureNouveau"))
+        self.label_4 = QtGui.QLabel(self.editPlateau_Pions)
+        self.label_4.setGeometry(QtCore.QRect(10, 0, 61, 16))
+        font = QtGui.QFont()
+        font.setBold(False)
+        font.setUnderline(True)
+        font.setWeight(50)
+        self.label_4.setFont(font)
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.pionSimple_nom = QtGui.QLineEdit(self.editPlateau_Pions)
+        self.pionSimple_nom.setGeometry(QtCore.QRect(10, 20, 71, 20))
+        self.pionSimple_nom.setObjectName(_fromUtf8("pionSimple_nom"))
+        self.pionSupprimer = QtGui.QToolButton(self.editPlateau_Pions)
+        self.pionSupprimer.setGeometry(QtCore.QRect(80, 430, 31, 21))
+        self.pionSupprimer.setIcon(icon19)
+        self.pionSupprimer.setObjectName(_fromUtf8("pionSupprimer"))
+        self.pionSupprimer_2 = QtGui.QToolButton(self.editPlateau_Pions)
+        self.pionSupprimer_2.setGeometry(QtCore.QRect(40, 430, 21, 21))
+        self.pionSupprimer_2.setIcon(icon19)
+        self.pionSupprimer_2.setObjectName(_fromUtf8("pionSupprimer_2"))
+        self.pionSupprimer_3 = QtGui.QToolButton(self.editPlateau_Pions)
+        self.pionSupprimer_3.setGeometry(QtCore.QRect(10, 430, 21, 21))
+        self.pionSupprimer_3.setIcon(icon19)
+        self.pionSupprimer_3.setObjectName(_fromUtf8("pionSupprimer_3"))
+        self.outilsEditionPlateau.addItem(self.editPlateau_Pions, _fromUtf8(""))
+        self.editPlateau_parametres = QtGui.QWidget()
+        self.editPlateau_parametres.setGeometry(QtCore.QRect(0, 0, 118, 490))
+        self.editPlateau_parametres.setObjectName(_fromUtf8("editPlateau_parametres"))
+        self.definirEntree = QtGui.QToolButton(self.editPlateau_parametres)
+        self.definirEntree.setGeometry(QtCore.QRect(10, 100, 41, 31))
+        icon27 = QtGui.QIcon()
+        icon27.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnEntree.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.definirEntree.setIcon(icon27)
+        self.definirEntree.setObjectName(_fromUtf8("definirEntree"))
+        self.definirSortie = QtGui.QToolButton(self.editPlateau_parametres)
+        self.definirSortie.setGeometry(QtCore.QRect(70, 100, 41, 31))
+        icon28 = QtGui.QIcon()
+        icon28.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnSortie.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.definirSortie.setIcon(icon28)
+        self.definirSortie.setObjectName(_fromUtf8("definirSortie"))
+        self.definirZonePlacement = QtGui.QToolButton(self.editPlateau_parametres)
+        self.definirZonePlacement.setGeometry(QtCore.QRect(10, 140, 41, 31))
+        self.definirZonePlacement.setIcon(icon)
+        self.definirZonePlacement.setObjectName(_fromUtf8("definirZonePlacement"))
+        self.publierPlateau = QtGui.QCommandLinkButton(self.editPlateau_parametres)
+        self.publierPlateau.setGeometry(QtCore.QRect(10, 170, 101, 41))
+        self.publierPlateau.setObjectName(_fromUtf8("publierPlateau"))
+        self.notesMjPlateau = QtGui.QTextEdit(self.editPlateau_parametres)
+        self.notesMjPlateau.setGeometry(QtCore.QRect(10, 240, 101, 191))
+        self.notesMjPlateau.setObjectName(_fromUtf8("notesMjPlateau"))
+        self.label_5 = QtGui.QLabel(self.editPlateau_parametres)
+        self.label_5.setGeometry(QtCore.QRect(10, 220, 46, 13))
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.agrandirNotesMjPlateau = QtGui.QToolButton(self.editPlateau_parametres)
+        self.agrandirNotesMjPlateau.setGeometry(QtCore.QRect(90, 220, 25, 21))
+        icon29 = QtGui.QIcon()
+        icon29.addPixmap(QtGui.QPixmap(_fromUtf8("img/agrandir.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.agrandirNotesMjPlateau.setIcon(icon29)
+        self.agrandirNotesMjPlateau.setObjectName(_fromUtf8("agrandirNotesMjPlateau"))
+        self.label_6 = QtGui.QLabel(self.editPlateau_parametres)
+        self.label_6.setGeometry(QtCore.QRect(10, 0, 61, 20))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.plateauCache1 = QtGui.QToolButton(self.editPlateau_parametres)
+        self.plateauCache1.setGeometry(QtCore.QRect(10, 20, 21, 21))
+        self.plateauCache1.setObjectName(_fromUtf8("plateauCache1"))
+        self.plateauCache2 = QtGui.QToolButton(self.editPlateau_parametres)
+        self.plateauCache2.setGeometry(QtCore.QRect(30, 20, 21, 21))
+        self.plateauCache2.setObjectName(_fromUtf8("plateauCache2"))
+        self.plateauCache3 = QtGui.QToolButton(self.editPlateau_parametres)
+        self.plateauCache3.setGeometry(QtCore.QRect(50, 20, 21, 21))
+        self.plateauCache3.setObjectName(_fromUtf8("plateauCache3"))
+        self.plateauCache4 = QtGui.QToolButton(self.editPlateau_parametres)
+        self.plateauCache4.setGeometry(QtCore.QRect(70, 20, 21, 21))
+        self.plateauCache4.setObjectName(_fromUtf8("plateauCache4"))
+        self.plateauCache5 = QtGui.QToolButton(self.editPlateau_parametres)
+        self.plateauCache5.setGeometry(QtCore.QRect(90, 20, 21, 21))
+        self.plateauCache5.setObjectName(_fromUtf8("plateauCache5"))
+        self.groupBox = QtGui.QGroupBox(self.editPlateau_parametres)
+        self.groupBox.setGeometry(QtCore.QRect(10, 40, 101, 51))
+        self.groupBox.setTitle(_fromUtf8(""))
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.cacheActif = QtGui.QCheckBox(self.groupBox)
+        self.cacheActif.setGeometry(QtCore.QRect(10, 0, 70, 17))
+        self.cacheActif.setObjectName(_fromUtf8("cacheActif"))
+        self.cachePlacer = QtGui.QPushButton(self.groupBox)
+        self.cachePlacer.setGeometry(QtCore.QRect(10, 20, 81, 21))
+        self.cachePlacer.setObjectName(_fromUtf8("cachePlacer"))
+        self.cacheVoir = QtGui.QToolButton(self.groupBox)
+        self.cacheVoir.setGeometry(QtCore.QRect(70, 0, 21, 19))
+        self.cacheVoir.setText(_fromUtf8(""))
+        icon30 = QtGui.QIcon()
+        icon30.addPixmap(QtGui.QPixmap(_fromUtf8("img/oeil.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.cacheVoir.setIcon(icon30)
+        self.cacheVoir.setObjectName(_fromUtf8("cacheVoir"))
+        self.plateauRafraichir = QtGui.QPushButton(self.editPlateau_parametres)
+        self.plateauRafraichir.setGeometry(QtCore.QRect(10, 440, 101, 23))
+        self.plateauRafraichir.setObjectName(_fromUtf8("plateauRafraichir"))
+        self.outilsEditionPlateau.addItem(self.editPlateau_parametres, _fromUtf8(""))
+        self.layoutPanneauPlateau.addWidget(self.outilsEditionPlateau)
+        self.outilsCombatPlateau = QtGui.QToolBox(self.Combats_tab)
+        self.outilsCombatPlateau.setMinimumSize(QtCore.QSize(120, 0))
+        self.outilsCombatPlateau.setMaximumSize(QtCore.QSize(120, 16777215))
+        self.outilsCombatPlateau.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.outilsCombatPlateau.setFrameShadow(QtGui.QFrame.Sunken)
+        self.outilsCombatPlateau.setObjectName(_fromUtf8("outilsCombatPlateau"))
+        self.page = QtGui.QWidget()
+        self.page.setGeometry(QtCore.QRect(0, 0, 118, 528))
+        self.page.setObjectName(_fromUtf8("page"))
+        self.listeAttributs = QtGui.QTableWidget(self.page)
+        self.listeAttributs.setGeometry(QtCore.QRect(10, 0, 101, 151))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        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.listeAttributs.setPalette(palette)
+        self.listeAttributs.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listeAttributs.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeAttributs.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
+        self.listeAttributs.setAlternatingRowColors(True)
+        self.listeAttributs.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.listeAttributs.setShowGrid(True)
+        self.listeAttributs.setObjectName(_fromUtf8("listeAttributs"))
+        self.listeAttributs.setColumnCount(2)
+        self.listeAttributs.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributs.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributs.setHorizontalHeaderItem(1, item)
+        self.listeAttributs.horizontalHeader().setVisible(False)
+        self.listeAttributs.horizontalHeader().setDefaultSectionSize(50)
+        self.listeAttributs.verticalHeader().setVisible(False)
+        self.notesPion = QtGui.QTextEdit(self.page)
+        self.notesPion.setGeometry(QtCore.QRect(10, 420, 104, 51))
+        self.notesPion.setDocumentTitle(_fromUtf8(""))
+        self.notesPion.setObjectName(_fromUtf8("notesPion"))
+        self.panneauAttaqueEC = QtGui.QGroupBox(self.page)
+        self.panneauAttaqueEC.setGeometry(QtCore.QRect(2, 280, 115, 131))
+        self.panneauAttaqueEC.setTitle(_fromUtf8(""))
+        self.panneauAttaqueEC.setObjectName(_fromUtf8("panneauAttaqueEC"))
+        self.notesAttaqueEC = QtGui.QTextEdit(self.panneauAttaqueEC)
+        self.notesAttaqueEC.setGeometry(QtCore.QRect(10, 90, 100, 31))
+        self.notesAttaqueEC.setObjectName(_fromUtf8("notesAttaqueEC"))
+        self.listeAttributsAttaqueEC = QtGui.QTableWidget(self.panneauAttaqueEC)
+        self.listeAttributsAttaqueEC.setGeometry(QtCore.QRect(10, 10, 100, 81))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255, 150))
+        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.listeAttributsAttaqueEC.setPalette(palette)
+        self.listeAttributsAttaqueEC.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listeAttributsAttaqueEC.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeAttributsAttaqueEC.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
+        self.listeAttributsAttaqueEC.setAlternatingRowColors(True)
+        self.listeAttributsAttaqueEC.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.listeAttributsAttaqueEC.setShowGrid(True)
+        self.listeAttributsAttaqueEC.setObjectName(_fromUtf8("listeAttributsAttaqueEC"))
+        self.listeAttributsAttaqueEC.setColumnCount(2)
+        self.listeAttributsAttaqueEC.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributsAttaqueEC.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttributsAttaqueEC.setHorizontalHeaderItem(1, item)
+        self.listeAttributsAttaqueEC.horizontalHeader().setVisible(False)
+        self.listeAttributsAttaqueEC.horizontalHeader().setDefaultSectionSize(50)
+        self.listeAttributsAttaqueEC.verticalHeader().setVisible(False)
+        self.afficherGestionCombat = QtGui.QPushButton(self.page)
+        self.afficherGestionCombat.setGeometry(QtCore.QRect(9, 480, 105, 45))
+        self.afficherGestionCombat.setMinimumSize(QtCore.QSize(80, 45))
+        self.afficherGestionCombat.setMaximumSize(QtCore.QSize(110, 45))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.afficherGestionCombat.setFont(font)
+        self.afficherGestionCombat.setObjectName(_fromUtf8("afficherGestionCombat"))
+        self.listeAttaques = QtGui.QTableWidget(self.page)
+        self.listeAttaques.setGeometry(QtCore.QRect(10, 170, 101, 101))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(247, 247, 247))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 170, 0, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Highlight, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.HighlightedText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(247, 247, 247))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 170, 0, 150))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Highlight, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.HighlightedText, brush)
+        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(51, 153, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Highlight, brush)
+        brush = QtGui.QBrush(QtGui.QColor(255, 255, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.HighlightedText, brush)
+        self.listeAttaques.setPalette(palette)
+        self.listeAttaques.setFrameShape(QtGui.QFrame.Box)
+        self.listeAttaques.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeAttaques.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
+        self.listeAttaques.setAlternatingRowColors(True)
+        self.listeAttaques.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+        self.listeAttaques.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+        self.listeAttaques.setTextElideMode(QtCore.Qt.ElideMiddle)
+        self.listeAttaques.setShowGrid(False)
+        self.listeAttaques.setObjectName(_fromUtf8("listeAttaques"))
+        self.listeAttaques.setColumnCount(3)
+        self.listeAttaques.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttaques.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttaques.setHorizontalHeaderItem(1, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeAttaques.setHorizontalHeaderItem(2, item)
+        self.listeAttaques.horizontalHeader().setVisible(False)
+        self.listeAttaques.horizontalHeader().setDefaultSectionSize(50)
+        self.listeAttaques.verticalHeader().setVisible(False)
+        self.editerAttaques = QtGui.QToolButton(self.page)
+        self.editerAttaques.setGeometry(QtCore.QRect(90, 150, 21, 20))
+        icon31 = QtGui.QIcon()
+        icon31.addPixmap(QtGui.QPixmap(_fromUtf8("img/editer.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.editerAttaques.setIcon(icon31)
+        self.editerAttaques.setObjectName(_fromUtf8("editerAttaques"))
+        self.titreAttaques = QtGui.QLabel(self.page)
+        self.titreAttaques.setGeometry(QtCore.QRect(10, 150, 71, 21))
+        self.titreAttaques.setObjectName(_fromUtf8("titreAttaques"))
+        self.outilsCombatPlateau.addItem(self.page, _fromUtf8(""))
+        self.page_2 = QtGui.QWidget()
+        self.page_2.setGeometry(QtCore.QRect(0, 0, 118, 528))
+        self.page_2.setObjectName(_fromUtf8("page_2"))
+        self.outilsCombatPlateau.addItem(self.page_2, _fromUtf8(""))
+        self.layoutPanneauPlateau.addWidget(self.outilsCombatPlateau)
+        self.layoutPanneauPlateau.setStretch(1, 1)
+        self.panneauOutilsPlateau.addLayout(self.layoutPanneauPlateau)
+        self.layoutAffichagePlateau = QtGui.QHBoxLayout()
+        self.layoutAffichagePlateau.setSpacing(2)
+        self.layoutAffichagePlateau.setObjectName(_fromUtf8("layoutAffichagePlateau"))
+        self.etiquetteModeAffichagePlateau = QtGui.QLabel(self.Combats_tab)
+        self.etiquetteModeAffichagePlateau.setMaximumSize(QtCore.QSize(50, 16777215))
+        self.etiquetteModeAffichagePlateau.setObjectName(_fromUtf8("etiquetteModeAffichagePlateau"))
+        self.layoutAffichagePlateau.addWidget(self.etiquetteModeAffichagePlateau)
+        self.modeAffichagePlateau = QtGui.QComboBox(self.Combats_tab)
+        self.modeAffichagePlateau.setMinimumSize(QtCore.QSize(70, 20))
+        self.modeAffichagePlateau.setMaximumSize(QtCore.QSize(70, 20))
+        self.modeAffichagePlateau.setObjectName(_fromUtf8("modeAffichagePlateau"))
+        self.modeAffichagePlateau.addItem(_fromUtf8(""))
+        self.modeAffichagePlateau.addItem(_fromUtf8(""))
+        self.modeAffichagePlateau.addItem(_fromUtf8(""))
+        self.modeAffichagePlateau.addItem(_fromUtf8(""))
+        self.layoutAffichagePlateau.addWidget(self.modeAffichagePlateau)
+        self.layoutAffichagePlateau.setStretch(0, 1)
+        self.layoutAffichagePlateau.setStretch(1, 4)
+        self.panneauOutilsPlateau.addLayout(self.layoutAffichagePlateau)
+        self.layoutCombat.addLayout(self.panneauOutilsPlateau)
+        self.layoutCombat.setStretch(1, 4)
+        self.layoutCombat.setStretch(2, 1)
+        self.horizontalLayout_3.addLayout(self.layoutCombat)
+        self.tabWidget.addTab(self.Combats_tab, _fromUtf8(""))
+        self.Monde_tab = QtGui.QWidget()
+        self.Monde_tab.setObjectName(_fromUtf8("Monde_tab"))
+        self.frame = QtGui.QFrame(self.Monde_tab)
+        self.frame.setGeometry(QtCore.QRect(0, 0, 71, 531))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        self.frame.setPalette(palette)
+        self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.frame.setFrameShadow(QtGui.QFrame.Raised)
+        self.frame.setObjectName(_fromUtf8("frame"))
+        self.points = QtGui.QPushButton(self.frame)
+        self.points.setGeometry(QtCore.QRect(0, 0, 71, 31))
+        self.points.setObjectName(_fromUtf8("points"))
+        self.itineraire = QtGui.QPushButton(self.frame)
+        self.itineraire.setGeometry(QtCore.QRect(0, 30, 71, 31))
+        self.itineraire.setObjectName(_fromUtf8("itineraire"))
+        self.texte_2 = QtGui.QPushButton(self.frame)
+        self.texte_2.setGeometry(QtCore.QRect(0, 60, 71, 31))
+        self.texte_2.setObjectName(_fromUtf8("texte_2"))
+        self.dessin = QtGui.QPushButton(self.frame)
+        self.dessin.setGeometry(QtCore.QRect(0, 90, 71, 31))
+        self.dessin.setObjectName(_fromUtf8("dessin"))
+        self.supp = QtGui.QPushButton(self.frame)
+        self.supp.setGeometry(QtCore.QRect(0, 120, 71, 31))
+        self.supp.setObjectName(_fromUtf8("supp"))
+        self.tabWidget.addTab(self.Monde_tab, _fromUtf8(""))
+        self.Groupe_tab = QtGui.QWidget()
+        self.Groupe_tab.setObjectName(_fromUtf8("Groupe_tab"))
+        self.tabWidget.addTab(self.Groupe_tab, _fromUtf8(""))
+        self.horizontalLayout.addWidget(self.tabWidget)
+        self.layoutPanneauDroite = QtGui.QVBoxLayout()
+        self.layoutPanneauDroite.setSizeConstraint(QtGui.QLayout.SetFixedSize)
+        self.layoutPanneauDroite.setObjectName(_fromUtf8("layoutPanneauDroite"))
+        self.label = QtGui.QLabel(self.baseWidget)
+        self.label.setMinimumSize(QtCore.QSize(199, 13))
+        self.label.setMaximumSize(QtCore.QSize(259, 16777215))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label.setFont(font)
+        self.label.setObjectName(_fromUtf8("label"))
+        self.layoutPanneauDroite.addWidget(self.label)
+        self.listEvenement = QtGui.QListWidget(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
+        sizePolicy.setHorizontalStretch(20)
+        sizePolicy.setVerticalStretch(20)
+        sizePolicy.setHeightForWidth(self.listEvenement.sizePolicy().hasHeightForWidth())
+        self.listEvenement.setSizePolicy(sizePolicy)
+        self.listEvenement.setMinimumSize(QtCore.QSize(199, 73))
+        self.listEvenement.setMaximumSize(QtCore.QSize(259, 16777215))
+        self.listEvenement.setObjectName(_fromUtf8("listEvenement"))
+        self.layoutPanneauDroite.addWidget(self.listEvenement)
+        self.layoutDes = QtGui.QHBoxLayout()
+        self.layoutDes.setSpacing(3)
+        self.layoutDes.setSizeConstraint(QtGui.QLayout.SetDefaultConstraint)
+        self.layoutDes.setContentsMargins(0, -1, -1, -1)
+        self.layoutDes.setObjectName(_fromUtf8("layoutDes"))
+        self.d20 = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.d20.sizePolicy().hasHeightForWidth())
+        self.d20.setSizePolicy(sizePolicy)
+        self.d20.setMinimumSize(QtCore.QSize(53, 23))
+        self.d20.setMaximumSize(QtCore.QSize(53, 16777215))
+        self.d20.setAutoDefault(False)
+        self.d20.setObjectName(_fromUtf8("d20"))
+        self.layoutDes.addWidget(self.d20)
+        self.d100 = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.d100.sizePolicy().hasHeightForWidth())
+        self.d100.setSizePolicy(sizePolicy)
+        self.d100.setMinimumSize(QtCore.QSize(52, 23))
+        self.d100.setMaximumSize(QtCore.QSize(52, 16777215))
+        self.d100.setObjectName(_fromUtf8("d100"))
+        self.layoutDes.addWidget(self.d100)
+        self.inJetDes = QtGui.QLineEdit(self.baseWidget)
+        self.inJetDes.setMinimumSize(QtCore.QSize(86, 20))
+        self.inJetDes.setMaximumSize(QtCore.QSize(146, 16777215))
+        self.inJetDes.setWhatsThis(_fromUtf8(""))
+        self.inJetDes.setInputMask(_fromUtf8(""))
+        self.inJetDes.setObjectName(_fromUtf8("inJetDes"))
+        self.layoutDes.addWidget(self.inJetDes)
+        self.layoutDes.setStretch(0, 1)
+        self.layoutDes.setStretch(1, 1)
+        self.layoutDes.setStretch(2, 3)
+        self.layoutPanneauDroite.addLayout(self.layoutDes)
+        self.layoutEnTeteChat = QtGui.QHBoxLayout()
+        self.layoutEnTeteChat.setSpacing(6)
+        self.layoutEnTeteChat.setSizeConstraint(QtGui.QLayout.SetDefaultConstraint)
+        self.layoutEnTeteChat.setObjectName(_fromUtf8("layoutEnTeteChat"))
+        self.label_3 = QtGui.QLabel(self.baseWidget)
+        self.label_3.setMinimumSize(QtCore.QSize(10, 23))
+        self.label_3.setMaximumSize(QtCore.QSize(161, 16777215))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label_3.setFont(font)
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.layoutEnTeteChat.addWidget(self.label_3)
+        self.chatVoc = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.chatVoc.sizePolicy().hasHeightForWidth())
+        self.chatVoc.setSizePolicy(sizePolicy)
+        self.chatVoc.setMinimumSize(QtCore.QSize(64, 23))
+        self.chatVoc.setMaximumSize(QtCore.QSize(90, 16777215))
+        self.chatVoc.setObjectName(_fromUtf8("chatVoc"))
+        self.layoutEnTeteChat.addWidget(self.chatVoc)
+        self.layoutEnTeteChat.setStretch(0, 1)
+        self.layoutEnTeteChat.setStretch(1, 2)
+        self.layoutPanneauDroite.addLayout(self.layoutEnTeteChat)
+        self.listAffichage = QtGui.QListWidget(self.baseWidget)
+        self.listAffichage.setMinimumSize(QtCore.QSize(199, 96))
+        self.listAffichage.setMaximumSize(QtCore.QSize(259, 16777215))
+        self.listAffichage.setObjectName(_fromUtf8("listAffichage"))
+        self.layoutPanneauDroite.addWidget(self.listAffichage)
+        self.inChat = QtGui.QLineEdit(self.baseWidget)
+        self.inChat.setMinimumSize(QtCore.QSize(199, 20))
+        self.inChat.setMaximumSize(QtCore.QSize(259, 16777215))
+        self.inChat.setObjectName(_fromUtf8("inChat"))
+        self.layoutPanneauDroite.addWidget(self.inChat)
+        self.tabStatutAppli = QtGui.QTabWidget(self.baseWidget)
+        self.tabStatutAppli.setMinimumSize(QtCore.QSize(201, 151))
+        self.tabStatutAppli.setMaximumSize(QtCore.QSize(259, 16777215))
+        self.tabStatutAppli.setObjectName(_fromUtf8("tabStatutAppli"))
+        self.tabConnexion = QtGui.QWidget()
+        self.tabConnexion.setObjectName(_fromUtf8("tabConnexion"))
+        self.verticalLayout_2 = QtGui.QVBoxLayout(self.tabConnexion)
+        self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
+        self.txtStatutCoPseudo = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoPseudo.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoPseudo.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoPseudo.setObjectName(_fromUtf8("txtStatutCoPseudo"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoPseudo)
+        self.txtStatutCoServeur = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoServeur.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoServeur.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoServeur.setObjectName(_fromUtf8("txtStatutCoServeur"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoServeur)
+        self.txtStatutCoServeurVoc = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoServeurVoc.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoServeurVoc.setMaximumSize(QtCore.QSize(16777215, 17))
+        self.txtStatutCoServeurVoc.setObjectName(_fromUtf8("txtStatutCoServeurVoc"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoServeurVoc)
+        self.txtStatutCoDebits = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoDebits.setMinimumSize(QtCore.QSize(179, 0))
+        self.txtStatutCoDebits.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoDebits.setObjectName(_fromUtf8("txtStatutCoDebits"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoDebits)
+        self.txtStatutCoEcranCo = QtGui.QPushButton(self.tabConnexion)
+        self.txtStatutCoEcranCo.setMinimumSize(QtCore.QSize(179, 23))
+        self.txtStatutCoEcranCo.setMaximumSize(QtCore.QSize(345, 23))
+        self.txtStatutCoEcranCo.setObjectName(_fromUtf8("txtStatutCoEcranCo"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoEcranCo)
+        self.tabStatutAppli.addTab(self.tabConnexion, _fromUtf8(""))
+        self.tabJoueurs = QtGui.QWidget()
+        self.tabJoueurs.setObjectName(_fromUtf8("tabJoueurs"))
+        self.verticalLayout = QtGui.QVBoxLayout(self.tabJoueurs)
+        self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
+        self.lstStatutJoueurs = QtGui.QListWidget(self.tabJoueurs)
+        self.lstStatutJoueurs.setMinimumSize(QtCore.QSize(177, 0))
+        font = QtGui.QFont()
+        font.setFamily(_fromUtf8("Segoe UI Semibold"))
+        font.setPointSize(10)
+        font.setBold(False)
+        font.setWeight(50)
+        self.lstStatutJoueurs.setFont(font)
+        self.lstStatutJoueurs.setFrameShape(QtGui.QFrame.WinPanel)
+        self.lstStatutJoueurs.setObjectName(_fromUtf8("lstStatutJoueurs"))
+        self.verticalLayout.addWidget(self.lstStatutJoueurs)
+        self.label_2 = QtGui.QLabel(self.tabJoueurs)
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_2.setFont(font)
+        self.label_2.setWordWrap(False)
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.verticalLayout.addWidget(self.label_2)
+        self.tabStatutAppli.addTab(self.tabJoueurs, _fromUtf8(""))
+        self.tabFichiers = QtGui.QWidget()
+        self.tabFichiers.setObjectName(_fromUtf8("tabFichiers"))
+        self.gridLayout = QtGui.QGridLayout(self.tabFichiers)
+        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+        self.repReceptionFichiers = QtGui.QPushButton(self.tabFichiers)
+        self.repReceptionFichiers.setMinimumSize(QtCore.QSize(85, 23))
+        self.repReceptionFichiers.setMaximumSize(QtCore.QSize(114, 16777215))
+        self.repReceptionFichiers.setObjectName(_fromUtf8("repReceptionFichiers"))
+        self.gridLayout.addWidget(self.repReceptionFichiers, 1, 0, 1, 1)
+        self.envoiFichier = QtGui.QPushButton(self.tabFichiers)
+        self.envoiFichier.setMinimumSize(QtCore.QSize(86, 23))
+        self.envoiFichier.setMaximumSize(QtCore.QSize(115, 16777215))
+        self.envoiFichier.setObjectName(_fromUtf8("envoiFichier"))
+        self.gridLayout.addWidget(self.envoiFichier, 1, 1, 1, 1)
+        self.listFichiers = QtGui.QTreeWidget(self.tabFichiers)
+        self.listFichiers.setMinimumSize(QtCore.QSize(177, 78))
+        self.listFichiers.setMaximumSize(QtCore.QSize(235, 16777215))
+        self.listFichiers.setBaseSize(QtCore.QSize(0, 0))
+        self.listFichiers.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listFichiers.setIndentation(2)
+        self.listFichiers.setColumnCount(3)
+        self.listFichiers.setObjectName(_fromUtf8("listFichiers"))
+        self.listFichiers.header().setDefaultSectionSize(28)
+        self.listFichiers.header().setMinimumSectionSize(27)
+        self.gridLayout.addWidget(self.listFichiers, 0, 0, 1, 2)
+        self.tabStatutAppli.addTab(self.tabFichiers, _fromUtf8(""))
+        self.layoutPanneauDroite.addWidget(self.tabStatutAppli)
+        self.layoutPanneauDroite.setStretch(0, 1)
+        self.layoutPanneauDroite.setStretch(1, 7)
+        self.layoutPanneauDroite.setStretch(2, 1)
+        self.layoutPanneauDroite.setStretch(3, 1)
+        self.layoutPanneauDroite.setStretch(4, 10)
+        self.layoutPanneauDroite.setStretch(5, 1)
+        self.layoutPanneauDroite.setStretch(6, 1)
+        self.horizontalLayout.addLayout(self.layoutPanneauDroite)
+        principal.setCentralWidget(self.baseWidget)
+        self.menubar = QtGui.QMenuBar(principal)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 1225, 21))
+        self.menubar.setObjectName(_fromUtf8("menubar"))
+        self.menuFichier = QtGui.QMenu(self.menubar)
+        self.menuFichier.setObjectName(_fromUtf8("menuFichier"))
+        self.menuEditer = QtGui.QMenu(self.menubar)
+        self.menuEditer.setObjectName(_fromUtf8("menuEditer"))
+        self.menuAide = QtGui.QMenu(self.menubar)
+        self.menuAide.setObjectName(_fromUtf8("menuAide"))
+        principal.setMenuBar(self.menubar)
+        self.statusbar = QtGui.QStatusBar(principal)
+        self.statusbar.setObjectName(_fromUtf8("statusbar"))
+        principal.setStatusBar(self.statusbar)
+        self.actionOuvrir = QtGui.QAction(principal)
+        self.actionOuvrir.setObjectName(_fromUtf8("actionOuvrir"))
+        self.actionEnregistrer = QtGui.QAction(principal)
+        self.actionEnregistrer.setObjectName(_fromUtf8("actionEnregistrer"))
+        self.actionQuitter = QtGui.QAction(principal)
+        self.actionQuitter.setObjectName(_fromUtf8("actionQuitter"))
+        self.actionA_propos_de_D_Monde = QtGui.QAction(principal)
+        self.actionA_propos_de_D_Monde.setObjectName(_fromUtf8("actionA_propos_de_D_Monde"))
+        self.actionParam_tres = QtGui.QAction(principal)
+        self.actionParam_tres.setObjectName(_fromUtf8("actionParam_tres"))
+        self.actionLexique = QtGui.QAction(principal)
+        self.actionLexique.setObjectName(_fromUtf8("actionLexique"))
+        self.menuFichier.addAction(self.actionOuvrir)
+        self.menuFichier.addAction(self.actionEnregistrer)
+        self.menuFichier.addSeparator()
+        self.menuFichier.addAction(self.actionQuitter)
+        self.menuEditer.addAction(self.actionParam_tres)
+        self.menuAide.addAction(self.actionA_propos_de_D_Monde)
+        self.menuAide.addAction(self.actionLexique)
+        self.menubar.addAction(self.menuFichier.menuAction())
+        self.menubar.addAction(self.menuEditer.menuAction())
+        self.menubar.addAction(self.menuAide.menuAction())
+
+        self.retranslateUi(principal)
+        self.tabWidget.setCurrentIndex(0)
+        self.outilsEditionPlateau.setCurrentIndex(3)
+        self.outilsEditionPlateau.layout().setSpacing(2)
+        self.outilsCombatPlateau.setCurrentIndex(0)
+        self.tabStatutAppli.setCurrentIndex(0)
+        QtCore.QMetaObject.connectSlotsByName(principal)
+
+    def retranslateUi(self, principal):
+        principal.setWindowTitle(_translate("principal", "Bienvenue sur le Dé-Monde", None))
+        self.combatTour.setText(_translate("principal", "Tour: 1", None))
+        self.infoOrdreJeu.setSortingEnabled(True)
+        item = self.infoOrdreJeu.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "num", None))
+        item = self.infoOrdreJeu.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "nom", None))
+        item = self.infoOrdreJeu.horizontalHeaderItem(2)
+        item.setText(_translate("principal", "ordre", 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.infoCaseEnCours_terrain.setText(_translate("principal", "terrain", None))
+        self.infoCaseEnCours_coord.setText(_translate("principal", "coord", None))
+        self.infoCaseEnCours_effetNom.setText(_translate("principal", "effet", None))
+        self.infoCaseEnCours_effetImg.setText(_translate("principal", "img", None))
+        self.infoCaseEnCours_altitude.setText(_translate("principal", "alt", None))
+        self.infoDecorEnCours_nom.setText(_translate("principal", "nom", None))
+        self.infoDecorEnCours_hauteur.setText(_translate("principal", "hauteur", None))
+        self.infoDecorEnCours_brule.setText(_translate("principal", "TextLabel", None))
+        self.infoDecorEnCours_detruit.setText(_translate("principal", "TextLabel", None))
+        self.infoDecorEnCours_verrouille.setText(_translate("principal", "TextLabel", None))
+        self.infoPionEnCours_sante.setText(_translate("principal", "sante", None))
+        self.infoPionEnCours_depRestant.setText(_translate("principal", "dep", None))
+        self.infoPionEnCours_endormi.setToolTip(_translate("principal", "Endormi", None))
+        self.infoPionEnCours_paralyse.setToolTip(_translate("principal", "Paralysé", None))
+        self.infoPionEnCours_entrave.setToolTip(_translate("principal", "Entravé", None))
+        self.infoPionEnCours_mort.setToolTip(_translate("principal", "Mort", None))
+        self.infoPionEnCours_etourdi.setToolTip(_translate("principal", "Evanoui", None))
+        self.infoPionEnCours_brule.setToolTip(_translate("principal", "Brûle", None))
+        self.infoPionEnCours_mouille.setToolTip(_translate("principal", "Mouillé", None))
+        self.infoPionEnCours_vol.setToolTip(_translate("principal", "En Vol", None))
+        self.infoPionEnCours_nom.setText(_translate("principal", "nom", None))
+        self.nomPlateau.setText(_translate("principal", "nom", None))
+        self.combatAttaqueCaC.setText(_translate("principal", "...", None))
+        self.combatAttaqueDist.setText(_translate("principal", "...", None))
+        self.combatAttaqueZone.setText(_translate("principal", "...", None))
+        self.combatVol.setText(_translate("principal", "...", None))
+        self.combatPionSelectionne_img.setText(_translate("principal", "logo", None))
+        self.combatPionSelectionne.setText(_translate("principal", "Pas de pion selectionné", None))
+        self.combatPasserTour.setText(_translate("principal", "Finir le tour", None))
+        self.combatInventaire.setText(_translate("principal", "...", None))
+        self.modeCombatPlateau.setToolTip(_translate("principal", "Passer en mode Combat", None))
+        self.modeCreationPlateau.setToolTip(_translate("principal", "Passer en mode Création", None))
+        self.sauverPlateau.setToolTip(_translate("principal", "Enregistrer le plateau", None))
+        self.fermerPlateau.setToolTip(_translate("principal", "Fermer le plateau", None))
+        self.terrainCouleur.setToolTip(_translate("principal", "Autres couleurs", None))
+        item = self.listTerrains.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "code", None))
+        item = self.listTerrains.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "Terrain", None))
+        self.terrainNouveau.setText(_translate("principal", "Nouveau", None))
+        self.terrainEdit.setText(_translate("principal", "Editer", None))
+        self.effFeu.setToolTip(_translate("principal", "Feu", None))
+        self.effFeu.setText(_translate("principal", "...", None))
+        self.effEau.setToolTip(_translate("principal", "Eau", None))
+        self.effEau.setText(_translate("principal", "...", None))
+        self.effGlace.setToolTip(_translate("principal", "Glace", None))
+        self.effGlace.setText(_translate("principal", "...", None))
+        self.effPoison.setToolTip(_translate("principal", "Poison", None))
+        self.effPoison.setText(_translate("principal", "...", None))
+        self.effEffacer.setToolTip(_translate("principal", "Effacer", None))
+        self.effEffacer.setText(_translate("principal", "...", None))
+        self.lstCategoriesTerrain.setItemText(0, _translate("principal", "Tout", None))
+        self.lstCategoriesTerrain.setItemText(1, _translate("principal", "Donjon", None))
+        self.lstCategoriesTerrain.setItemText(2, _translate("principal", "Souterrain", None))
+        self.lstCategoriesTerrain.setItemText(3, _translate("principal", "Exterieur", None))
+        self.formeLigne.setToolTip(_translate("principal", "Ligne", None))
+        self.formeLigne.setText(_translate("principal", "...", None))
+        self.formeRectVide.setToolTip(_translate("principal", "Rectangle (vide)", None))
+        self.formeRectVide.setText(_translate("principal", "...", None))
+        self.formeRectPlein.setToolTip(_translate("principal", "Rectangle (plein)", None))
+        self.formeRectPlein.setText(_translate("principal", "...", None))
+        self.formeEllipseVide.setToolTip(_translate("principal", "Ellipse (vide)", None))
+        self.formeEllipseVide.setText(_translate("principal", "...", None))
+        self.formeEllipsePlein.setToolTip(_translate("principal", "Ellipse (pleine)", None))
+        self.formeEllipsePlein.setText(_translate("principal", "...", None))
+        self.formeLigneOrientee.setToolTip(_translate("principal", "Frontière", None))
+        self.formeLigneOrientee.setText(_translate("principal", "...", None))
+        self.valeurEpaisseurPinceau.setText(_translate("principal", "1", None))
+        self.formeSimple.setToolTip(_translate("principal", "Ligne", None))
+        self.formeSimple.setText(_translate("principal", "...", None))
+        self.label_9.setText(_translate("principal", "Altitude :", None))
+        self.terrainCopie.setToolTip(_translate("principal", "Ligne", None))
+        self.terrainCopie.setText(_translate("principal", "...", None))
+        self.outilsEditionPlateau.setItemText(self.outilsEditionPlateau.indexOf(self.editPlateau_Terrain), _translate("principal", "Terrains", None))
+        self.decorEdit.setText(_translate("principal", "Editer", None))
+        item = self.listDecors.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "code", None))
+        item = self.listDecors.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "Decor", None))
+        self.decorNouveau.setText(_translate("principal", "Nouveau", None))
+        self.comboBox_2.setItemText(0, _translate("principal", "Tout", None))
+        self.comboBox_2.setItemText(1, _translate("principal", "Donjon", None))
+        self.comboBox_2.setItemText(2, _translate("principal", "Souterrain", None))
+        self.comboBox_2.setItemText(3, _translate("principal", "Exterieur", None))
+        self.decorSupprimer.setText(_translate("principal", "...", None))
+        self.outilsEditionPlateau.setItemText(self.outilsEditionPlateau.indexOf(self.editPlateau_Decors), _translate("principal", "Décors", None))
+        item = self.listCreatures.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "code", None))
+        item = self.listCreatures.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "Creature", None))
+        self.creatureEdit.setText(_translate("principal", "Editer", None))
+        self.creatureNouveau.setText(_translate("principal", "Nouveau", None))
+        self.label_4.setText(_translate("principal", "Pion simple : ", None))
+        self.pionSupprimer.setText(_translate("principal", "...", None))
+        self.pionSupprimer_2.setText(_translate("principal", "...", None))
+        self.pionSupprimer_3.setText(_translate("principal", "...", None))
+        self.outilsEditionPlateau.setItemText(self.outilsEditionPlateau.indexOf(self.editPlateau_Pions), _translate("principal", "Pions", None))
+        self.definirEntree.setToolTip(_translate("principal", "Marquer l\'entrée", None))
+        self.definirEntree.setText(_translate("principal", "...", None))
+        self.definirSortie.setToolTip(_translate("principal", "Marquer la/les sortie(s)", None))
+        self.definirSortie.setText(_translate("principal", "...", None))
+        self.definirZonePlacement.setToolTip(_translate("principal", "Définir la zone de placement des joueurs", None))
+        self.definirZonePlacement.setText(_translate("principal", "...", None))
+        self.publierPlateau.setToolTip(_translate("principal", "Rendre le plateau publique", None))
+        self.publierPlateau.setText(_translate("principal", "Publier", None))
+        self.label_5.setText(_translate("principal", "Notes : ", None))
+        self.agrandirNotesMjPlateau.setText(_translate("principal", "...", None))
+        self.label_6.setText(_translate("principal", "Caches", None))
+        self.plateauCache1.setText(_translate("principal", "1", None))
+        self.plateauCache2.setText(_translate("principal", "2", None))
+        self.plateauCache3.setText(_translate("principal", "3", None))
+        self.plateauCache4.setText(_translate("principal", "4", None))
+        self.plateauCache5.setText(_translate("principal", "5", None))
+        self.cacheActif.setText(_translate("principal", "Actif", None))
+        self.cachePlacer.setText(_translate("principal", "Placer", None))
+        self.plateauRafraichir.setText(_translate("principal", "Rafraichir (debug)", None))
+        self.outilsEditionPlateau.setItemText(self.outilsEditionPlateau.indexOf(self.editPlateau_parametres), _translate("principal", "Autre", None))
+        item = self.listeAttributs.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "Nouvelle colonne", None))
+        item = self.listeAttributs.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "Valeur", None))
+        item = self.listeAttributsAttaqueEC.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "Nouvelle colonne", None))
+        item = self.listeAttributsAttaqueEC.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "Valeur", None))
+        self.afficherGestionCombat.setText(_translate("principal", "Tableau \n"
+"de combat", None))
+        item = self.listeAttaques.horizontalHeaderItem(0)
+        item.setText(_translate("principal", "numAttaque", None))
+        item = self.listeAttaques.horizontalHeaderItem(1)
+        item.setText(_translate("principal", "typeAttaque", None))
+        item = self.listeAttaques.horizontalHeaderItem(2)
+        item.setText(_translate("principal", "nomAttaque", None))
+        self.editerAttaques.setText(_translate("principal", "...", None))
+        self.titreAttaques.setText(_translate("principal", "Attaques : ", None))
+        self.outilsCombatPlateau.setItemText(self.outilsCombatPlateau.indexOf(self.page), _translate("principal", "Page 1", None))
+        self.outilsCombatPlateau.setItemText(self.outilsCombatPlateau.indexOf(self.page_2), _translate("principal", "Page 2", None))
+        self.etiquetteModeAffichagePlateau.setText(_translate("principal", "Affichage:", None))
+        self.modeAffichagePlateau.setItemText(0, _translate("principal", "Normal", None))
+        self.modeAffichagePlateau.setItemText(1, _translate("principal", "Altitude", None))
+        self.modeAffichagePlateau.setItemText(2, _translate("principal", "Terrains", None))
+        self.modeAffichagePlateau.setItemText(3, _translate("principal", "Tactique", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Combats_tab), _translate("principal", "Combats", None))
+        self.points.setText(_translate("principal", "Points", None))
+        self.itineraire.setText(_translate("principal", "Itinéraire", None))
+        self.texte_2.setText(_translate("principal", "Texte", None))
+        self.dessin.setText(_translate("principal", "Dessin", None))
+        self.supp.setText(_translate("principal", "Supprimer", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Monde_tab), _translate("principal", "Monde", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Groupe_tab), _translate("principal", "Groupe", None))
+        self.label.setText(_translate("principal", "Evenements", None))
+        self.d20.setText(_translate("principal", "D20", None))
+        self.d100.setText(_translate("principal", "D100", None))
+        self.inJetDes.setPlaceholderText(_translate("principal", "Autre lancer (ex: 1d4+6d6)", None))
+        self.label_3.setText(_translate("principal", "Chat", None))
+        self.chatVoc.setText(_translate("principal", "Chat vocal", None))
+        self.inChat.setPlaceholderText(_translate("principal", "Entrez votre message...", None))
+        self.txtStatutCoPseudo.setText(_translate("principal", "Pseudo : ", None))
+        self.txtStatutCoServeur.setText(_translate("principal", "Serveur : Aucun serveur", None))
+        self.txtStatutCoServeurVoc.setText(_translate("principal", "Serveur vocal : Aucun serveur vocal", None))
+        self.txtStatutCoDebits.setText(_translate("principal", "Débits : E 0 ko/s  -  R 0 ko/s", None))
+        self.txtStatutCoEcranCo.setText(_translate("principal", "Ecran de connexion", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabConnexion), _translate("principal", "Connexion", None))
+        self.label_2.setText(_translate("principal", "Double-cliquer pour ouvrir un chat privé", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabJoueurs), _translate("principal", "Joueurs", None))
+        self.repReceptionFichiers.setText(_translate("principal", "Rep. recept.", None))
+        self.envoiFichier.setText(_translate("principal", "Envoi fichier", None))
+        self.listFichiers.headerItem().setText(0, _translate("principal", "E/R", None))
+        self.listFichiers.headerItem().setText(1, _translate("principal", "%", None))
+        self.listFichiers.headerItem().setText(2, _translate("principal", "Fichier", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabFichiers), _translate("principal", "Fichiers", None))
+        self.menuFichier.setTitle(_translate("principal", "Fichier", None))
+        self.menuEditer.setTitle(_translate("principal", "Editer", None))
+        self.menuAide.setTitle(_translate("principal", "Aide", None))
+        self.actionOuvrir.setText(_translate("principal", "Ouvrir", None))
+        self.actionEnregistrer.setText(_translate("principal", "Enregistrer", None))
+        self.actionQuitter.setText(_translate("principal", "Quitter", None))
+        self.actionA_propos_de_D_Monde.setText(_translate("principal", "A propos de DéMonde...", None))
+        self.actionParam_tres.setText(_translate("principal", "Paramètres", None))
+        self.actionLexique.setText(_translate("principal", "Lexique", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    principal = QtGui.QMainWindow()
+    ui = Ui_principal()
+    ui.setupUi(principal)
+    principal.show()
+    sys.exit(app.exec_())
+