poursuite de l'adaptation du code à la nouvelle structure

Signed-off-by: unknown <olivier.massot@DSI5301067.cg67.fr>

DMonde.py

@@ -20,11 +20,9 @@ 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.Combattant import Combattant
 from lib.Decor import Decor
 from lib.Terrain import Terrain
-from lib.Creature import Creature
 from lib.Attaque import Attaque
 
 from lib.Cache import Cache

lib/Plateau.py

@@ -13,14 +13,14 @@ from PyQt4 import QtOpenGL
 ##from ui.ecran_editionAttaques import Ui_editionAttaques
 
 from Case import Case
-from Pion import Pion
-from PionDecor import PionDecor
+from Combattant import Combattant
+from Decor import Decor
 from Forme import Forme
 
 from Cache import Cache
 from EntreeSortie import EntreeSortie
 
-from EcranEditionCreature import EcranEditionCreature
+from EcranEditionCombattant import EcranEditionCombattant
 from EcranEditionDecors import EcranEditionDecors
 from EcranEditionTerrain import EcranEditionTerrain
 from EcranAffichageTexte import EcranAffichageTexte
@@ -74,7 +74,7 @@ class Plateau(QGraphicsScene):
 
         #objets
         self.cases = {}   #dict des cases du plateau   (coordonnées: case)
-        self.pions = {}   #liste de pions positionnes sur le plateau
+        self.combattants = {}   #liste de combattants positionnes sur le plateau
         self.decors = {}  #liste des decors places sur le plateau
         self.cacheEnCours = 1
         self.caches = {}
@@ -87,7 +87,7 @@ class Plateau(QGraphicsScene):
         self.entreesSorties = []    
             
         #infos combat
-        self.numPionEnCours = 0
+        self.numCombattantEnCours = 0
         self.ordreJeu = {}  #numero du pion: ordre de jeu
             
         #note: la hauteur Z (qui gere l'empilement des objets graphiques est distribuee de cette maniere:
@@ -143,13 +143,13 @@ class Plateau(QGraphicsScene):
             self.cases[coord].recreer(self)
 
         #recreation des pions
-        for numPion in self.pions:
-            self.pions[numPion].recreer(self)
+        for numCombattant in self.combattants:
+            self.combattants[numCombattant].ajouterAuPlateau(self)
         self.majOrdreJeu()    
 
         #recreation des decors
         for num in self.decors:
-            self.decors[num].recreer(self)
+            self.decors[num].ajouterAuPlateau(self)
 
         #recreation des marqueurs entree/sortie
         for entreeSortie in self.entreesSorties:
@@ -206,7 +206,7 @@ class Plateau(QGraphicsScene):
         self.fenetre.connect(self.fenetre.ui.inf_listeOrdreJeu, SIGNAL("cellClicked(int,int)"), self.clicListOrdreJeu, Qt.UniqueConnection)
         
         self.fenetre.connect(self.fenetre.ui.cp_listeTerrains, SIGNAL("cellClicked(int,int)"), self.modeMajTerrainCase, Qt.UniqueConnection)
-        self.fenetre.connect(self.fenetre.ui.cp_listeCreatures, SIGNAL("cellClicked(int,int)"), self.modeCreationCreaturePion, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.cp_listeCombattants, SIGNAL("cellClicked(int,int)"), self.modeCreationCombattant, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.cp_listeDecors, SIGNAL("cellClicked(int,int)"), self.modeCreationDecor, Qt.UniqueConnection)
         
 ##        self.fenetre.connect(self.fenetre.ui.terrainEdit, SIGNAL("clicked()"), self.terrainEdit, Qt.UniqueConnection)
@@ -232,7 +232,7 @@ class Plateau(QGraphicsScene):
 ##        self.fenetre.connect(self.fenetre.ui.cachePlacer, SIGNAL("clicked()"), self.placerCacheEnCours, Qt.UniqueConnection)
 
 ##        self.fenetre.connect(self.fenetre.ui.notesMjPlateau, SIGNAL("textChanged()"), self.majNotesPlateau, Qt.UniqueConnection)
-        self.fenetre.connect(self.fenetre.ui.pi_notesPion, SIGNAL("textChanged()"), self.majNotesPion, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.pi_notesCombattant, SIGNAL("textChanged()"), self.majNotesCombattant, Qt.UniqueConnection)
 
         #formes (dessin)
         self.fenetre.connect(self.fenetre.ui.cp_formeSimple, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection)
@@ -349,11 +349,11 @@ class Plateau(QGraphicsScene):
 ##            bouton = self.fenetre.ui.outilsEditionPlateau.findChild(QToolButton, "plateauCache{}".format(i))
 ##            self.fenetre.connect(bouton, SIGNAL("clicked()"), self.majAffichageMenuCache)
 
-    def majListesPions(self, numPion = None):
+    def majListesPions(self, numCombattant = None):
         """met a jour les listes contenant des donnees liees aux pions"""
 ##        self.majListeOrdreJeu()
 ##        
-##        if numPion == None or numPion == self.pionSelectionne().numero:
+##        if numCombattant == None or numCombattant == self.pionSelectionne().numero:
 ##            self.majListeAttributs()
 ##        QApplication.processEvents()
         pass
@@ -955,8 +955,8 @@ class Plateau(QGraphicsScene):
         for num in self.ordreJeu:
             self.fenetre.ui.inf_listeOrdreJeu.insertRow(int(index))
             self.fenetre.ui.inf_listeOrdreJeu.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()))
+            icon = QIcon("img\\"+self.combattants[num].creature.logo)
+            item = QTableWidgetItem(icon,QString.fromUtf8(self.combattants[num].txtId()))
             self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 1, item)
             self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 2, QTableWidgetItem(QString.fromUtf8(str(self.ordreJeu[num]))))
             index += 1
@@ -966,13 +966,13 @@ class Plateau(QGraphicsScene):
 
     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.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8())  
-        self.fenetre.ui.cbt_vue.centerOn(self.cases[self.pions[numPion].position].centreGraphique)
-        self.pionSaisir(numPion)
+        numCombattant = int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8())  
+        self.fenetre.ui.cbt_vue.centerOn(self.cases[self.combattants[numCombattant].position].centreGraphique)
+        self.pionSaisir(numCombattant)
 
     def pionSuivant(self):
         """selection du pion suivant dans la liste d'ordre de jeu"""
-        if self.numPionEnCours in self.pions:
+        if self.numPionEnCours in self.combattants:
             suivant = self.ordreJeu[self.numPionEnCours] + 1
         else:
             suivant = 1
@@ -982,17 +982,17 @@ class Plateau(QGraphicsScene):
             suivant = 1
         for num in self.ordreJeu:
             if self.ordreJeu[num] == suivant:
-                numPion = num
+                numCombattant = num
                 break
 
         for ligne in range(0, self.fenetre.ui.inf_listeOrdreJeu.rowCount()):
             item = self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0)
-            item.setSelected(int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8()) == numPion)
-            if int(item.text().toUtf8()) == numPion:
+            item.setSelected(int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8()) == numCombattant)
+            if int(item.text().toUtf8()) == numCombattant:
                 self.fenetre.ui.inf_listeOrdreJeu.scrollToItem(item)
 
-        self.fenetre.ui.cbt_vue.centerOn(self.cases[self.pions[numPion].position].centreGraphique)
-        self.pionSaisir(numPion)        
+        self.fenetre.ui.cbt_vue.centerOn(self.cases[self.combattants[numCombattant].position].centreGraphique)
+        self.pionSaisir(numCombattant)        
  
     def afficheEcranGestionCombat(self):
         #*egc
@@ -1010,35 +1010,35 @@ class Plateau(QGraphicsScene):
         attribut = regles.attributOrdreJeu()
         if attribut != None:
             dico = {}
-            for numPion in self.pions:
-                dico[numPion] = int(self.pions[numPion].lstCarac[attribut])
+            for numCombattant in self.combattants:
+                dico[numCombattant] = int(self.combattants[numCombattant].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
+            for numCombattant in self.combattants:
+                self.ordreJeu[numCombattant] = ordre.index(numCombattant) + 1
         self.majListeOrdreJeu()  
 
-    def pionDeplacerDansOrdreJeu(self, numPion, nouvellePosition):
+    def pionDeplacerDansOrdreJeu(self, numCombattant, 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 numCombattant in self.ordreJeu:
             if nouvellePosition == 0:
-                del self.ordreJeu[numPion]
+                del self.ordreJeu[numCombattant]
         if len(self.ordreJeu) > 0:        
             i = 0    
             tmp = sorted(self.ordreJeu, key=self.ordreJeu.get)
-            if numPion in tmp:
-                tmp.remove(numPion)
+            if numCombattant in tmp:
+                tmp.remove(numCombattant)
             for num in tmp:
                 i += 1
                 if i == nouvellePosition:
-                    self.ordreJeu[numPion] = i
+                    self.ordreJeu[numCombattant] = i
                     i += 1
                 self.ordreJeu[num] = i
             if i < nouvellePosition:
-                self.ordreJeu[numPion] = i + 1 
+                self.ordreJeu[numCombattant] = i + 1 
         elif nouvellePosition > 0:
-            self.ordreJeu[numPion] = 1
+            self.ordreJeu[numCombattant] = 1
         self.majOrdreJeu()
         
     def majListeAttributs(self):
@@ -1698,8 +1698,8 @@ class Plateau(QGraphicsScene):
         """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)
+        for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+             self.combattants[numCombattant].estCibleAttaque(False)
         
         if self.modeCombat == "combatAttaqueZone" and self.pionSelectionne() != None:
             if self.modeParam["typeAttaqueZone"] == "ligne":
@@ -1776,16 +1776,16 @@ class Plateau(QGraphicsScene):
 
             for coord in self.modeParam["listeCasesAttaqueZone"]:
                 self.cases[coord].majEstCibleAttaque(True)
-            for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
-                self.pions[numPion].estCibleAttaque(True)
+            for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+                self.combattants[numCombattant].estCibleAttaque(True)
 
 
     def validerAttaqueZone(self):
         """l'attaque de zone est validee"""
         if self.modeActif == "pionSelectionne" and self.modeCombat == "combatAttaqueZone":
-            for numPion in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+            for numCombattant 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.combattants[numCombattant].nom, self.combattants[numCombattant].numero))
         self.majModeCombat("aucun")        
 
     def reinitAttaqueZone(self):
@@ -1801,14 +1801,14 @@ class Plateau(QGraphicsScene):
             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)
+        for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]):
+            self.combattants[numCombattant].estCibleAttaque(False)
                       
     def pionSurCase(self, coord):
         """renvoie le pion present sur la case, none sinon"""
         retour = None
-        for num in self.pions:
-            if self.pions[num].position == coord:
+        for num in self.combattants:
+            if self.combattants[num].position == coord:
                 retour = num
         return retour        
 
@@ -1845,21 +1845,21 @@ class Plateau(QGraphicsScene):
 
     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)
+        for numCombattant in self.combattants:
+            if numCombattant != self.modeParam["numPionSelectionne"]:
+                self.combattants[numCombattant].setAcceptsHoverEvents(actif)
+                self.combattants[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif)
+        for numCombattant in self.decors:
+            self.decors[numCombattant].setAcceptsHoverEvents(actif)
+            self.decors[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif)
                 
     #######################
 
     ######## 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"]]
+        if self.modeParam["numPionSelectionne"] in self.combattants:
+            retour = self.combattants[self.modeParam["numPionSelectionne"]]
         else:
             retour = None
         return retour    
@@ -2010,7 +2010,7 @@ class Plateau(QGraphicsScene):
         else:
             self.fenetre.ui.inf_boiteCase.setVisible(False)
 
-    def pionClique(self, numPion):
+    def pionClique(self, numCombattant):
         """on a clique sur ce pion"""
         accepte = False
         if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist":    
@@ -2018,29 +2018,29 @@ class Plateau(QGraphicsScene):
             accepte = True
             
         elif self.modeActif == "standard" and self.pionSelectionne() == None:
-            self.pionSaisir(numPion)
+            self.pionSaisir(numCombattant)
             accepte = True
         return accepte    
 
-    def pionSurvol(self, numPion):
+    def pionSurvol(self, numCombattant):
         """le pion est survole par le curseur, on affiche ses informations dans la zone prevue"""
-        if numPion in self.pions:
-            pion = self.pions[numPion]
+        if numCombattant in self.combattants:
+            pion = self.combattants[numCombattant]
         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(self.pions[numPion].position[0], self.pions[numPion].position[1])
+        if numCombattant in self.combattants:
+##            case = self.cases[self.combattants[numCombattant].position]
+            self.caseSurvol(self.combattants[numCombattant].position[0], self.combattants[numCombattant].position[1])
 
-    def pionDoubleClic(self, numPion):
+    def pionDoubleClic(self, numCombattant):
         """on a double-clique sur le pion"""
         accepte = False
-        if self.pionSelectionne() == self.pions[numPion] and self.modeCombat == "aucun":
-##            self.pionSaisir(numPion)
+        if self.pionSelectionne() == self.combattants[numCombattant] and self.modeCombat == "aucun":
+##            self.pionSaisir(numCombattant)
             self.majModeCombat("combatDeplacement")
             accepte = True
         return accepte          
@@ -2056,21 +2056,21 @@ class Plateau(QGraphicsScene):
                       valide = False
         if valide:
             numero = 1
-            if len(self.pions) > 0:
-                numero = max(self.pions) + 1   
+            if len(self.combattants) > 0:
+                numero = max(self.combattants) + 1   
             pion = Pion(self, numero)
             if self.modeParam["creature"] != None:
                 nom = self.modeParam["creature"].nom     
             numTxt = self.numeroterNom(nom)
-            self.pions[numero] = pion
+            self.combattants[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:
+        for numCombattant in self.combattants:
+            if self.combattants[numCombattant].nom == nom:
                 i += 1     
         if i == 1:
             retour = ""
@@ -2078,10 +2078,10 @@ class Plateau(QGraphicsScene):
             retour = str(i)
         return retour
     
-    def pionSaisir(self, numPion):
+    def pionSaisir(self, numCombattant):
         """on saisit un pion"""
-        if numPion != self.modeParam["numPionSelectionne"]:
-            self.majMode("pionSelectionne", numPion)
+        if numCombattant != self.modeParam["numPionSelectionne"]:
+            self.majMode("pionSelectionne", numCombattant)
         
     def pionDeposer(self, coordCase):
         """on depose le pion sur la case voulue"""
@@ -2238,12 +2238,12 @@ class Plateau(QGraphicsScene):
     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])
+        if num in self.combattants:    
+            for coord in self.combattants[num].forme.listeCases(self.combattants[num].position, self.combattants[num].nbRotations):
+                 self.cases[coord].majOccupation(self.combattants[num])
             self.pionSurvol(None)     
             self.pionDeplacerDansOrdreJeu(num, 0)
-            pionSuppr = self.pions.pop(num)
+            pionSuppr = self.combattants.pop(num)
             pionSuppr.supprimer()
         else:
             print("erreur: ce pion n'est pas dans la liste des pions")

lib/ui/ecran_editionCombattant.py

@@ -0,0 +1,384 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'editionCombattant.ui'
+#
+# Created: Mon May 18 17:28:15 2015
+#      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_editionCombattant(object):
+    def setupUi(self, editionCombattant):
+        editionCombattant.setObjectName(_fromUtf8("editionCombattant"))
+        editionCombattant.resize(712, 559)
+        self.affichageCouleurCombattant = QtGui.QLabel(editionCombattant)
+        self.affichageCouleurCombattant.setGeometry(QtCore.QRect(110, 50, 51, 21))
+        self.affichageCouleurCombattant.setFrameShape(QtGui.QFrame.Box)
+        self.affichageCouleurCombattant.setFrameShadow(QtGui.QFrame.Sunken)
+        self.affichageCouleurCombattant.setText(_fromUtf8(""))
+        self.affichageCouleurCombattant.setObjectName(_fromUtf8("affichageCouleurCombattant"))
+        self.label_11 = QtGui.QLabel(editionCombattant)
+        self.label_11.setGeometry(QtCore.QRect(30, 120, 141, 20))
+        self.label_11.setObjectName(_fromUtf8("label_11"))
+        self.annulerCreature = QtGui.QPushButton(editionCombattant)
+        self.annulerCreature.setGeometry(QtCore.QRect(490, 520, 81, 23))
+        self.annulerCreature.setObjectName(_fromUtf8("annulerCreature"))
+        self.label_3 = QtGui.QLabel(editionCombattant)
+        self.label_3.setGeometry(QtCore.QRect(30, 20, 46, 16))
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.imgLogoCombattant = QtGui.QLineEdit(editionCombattant)
+        self.imgLogoCombattant.setGeometry(QtCore.QRect(180, 90, 191, 20))
+        self.imgLogoCombattant.setObjectName(_fromUtf8("imgLogoCombattant"))
+        self.hauteurCombattant = QtGui.QDoubleSpinBox(editionCombattant)
+        self.hauteurCombattant.setGeometry(QtCore.QRect(560, 50, 41, 22))
+        self.hauteurCombattant.setPrefix(_fromUtf8(""))
+        self.hauteurCombattant.setDecimals(0)
+        self.hauteurCombattant.setMinimum(1.0)
+        self.hauteurCombattant.setMaximum(50.0)
+        self.hauteurCombattant.setSingleStep(1.0)
+        self.hauteurCombattant.setProperty("value", 1.0)
+        self.hauteurCombattant.setObjectName(_fromUtf8("hauteurCombattant"))
+        self.label_10 = QtGui.QLabel(editionCombattant)
+        self.label_10.setGeometry(QtCore.QRect(470, 50, 81, 21))
+        self.label_10.setObjectName(_fromUtf8("label_10"))
+        self.volCombattant = QtGui.QCheckBox(editionCombattant)
+        self.volCombattant.setGeometry(QtCore.QRect(560, 90, 61, 17))
+        self.volCombattant.setChecked(False)
+        self.volCombattant.setObjectName(_fromUtf8("volCombattant"))
+        self.idCombattant = QtGui.QLineEdit(editionCombattant)
+        self.idCombattant.setEnabled(False)
+        self.idCombattant.setGeometry(QtCore.QRect(52, 20, 31, 20))
+        self.idCombattant.setObjectName(_fromUtf8("idCombattant"))
+        self.nomCombattant = QtGui.QLineEdit(editionCombattant)
+        self.nomCombattant.setGeometry(QtCore.QRect(122, 20, 281, 20))
+        self.nomCombattant.setObjectName(_fromUtf8("nomCombattant"))
+        self.deplacementCombattant = QtGui.QDoubleSpinBox(editionCombattant)
+        self.deplacementCombattant.setGeometry(QtCore.QRect(560, 20, 41, 22))
+        self.deplacementCombattant.setPrefix(_fromUtf8(""))
+        self.deplacementCombattant.setDecimals(0)
+        self.deplacementCombattant.setSingleStep(1.0)
+        self.deplacementCombattant.setProperty("value", 1.0)
+        self.deplacementCombattant.setObjectName(_fromUtf8("deplacementCombattant"))
+        self.label_2 = QtGui.QLabel(editionCombattant)
+        self.label_2.setGeometry(QtCore.QRect(130, 90, 71, 21))
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.label = QtGui.QLabel(editionCombattant)
+        self.label.setGeometry(QtCore.QRect(30, 90, 141, 20))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.enregistrerCreature = QtGui.QPushButton(editionCombattant)
+        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.imgTextureCombattant = QtGui.QLineEdit(editionCombattant)
+        self.imgTextureCombattant.setGeometry(QtCore.QRect(180, 120, 191, 20))
+        self.imgTextureCombattant.setObjectName(_fromUtf8("imgTextureCombattant"))
+        self.label_4 = QtGui.QLabel(editionCombattant)
+        self.label_4.setGeometry(QtCore.QRect(90, 20, 46, 16))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.couleurCombattant = QtGui.QPushButton(editionCombattant)
+        self.couleurCombattant.setGeometry(QtCore.QRect(20, 50, 75, 23))
+        self.couleurCombattant.setObjectName(_fromUtf8("couleurCombattant"))
+        self.supprimerCreature = QtGui.QPushButton(editionCombattant)
+        self.supprimerCreature.setEnabled(False)
+        self.supprimerCreature.setGeometry(QtCore.QRect(400, 520, 75, 23))
+        self.supprimerCreature.setObjectName(_fromUtf8("supprimerCreature"))
+        self.label_6 = QtGui.QLabel(editionCombattant)
+        self.label_6.setGeometry(QtCore.QRect(480, 20, 81, 21))
+        self.label_6.setObjectName(_fromUtf8("label_6"))
+        self.ongletsCreation = QtGui.QTabWidget(editionCombattant)
+        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.txtAfficherCombattant = QtGui.QCheckBox(self.groupBox_2)
+        self.txtAfficherCombattant.setGeometry(QtCore.QRect(100, 10, 21, 21))
+        self.txtAfficherCombattant.setText(_fromUtf8(""))
+        self.txtAfficherCombattant.setChecked(True)
+        self.txtAfficherCombattant.setObjectName(_fromUtf8("txtAfficherCombattant"))
+        self.txtPosYCombattant = QtGui.QSlider(self.groupBox_2)
+        self.txtPosYCombattant.setGeometry(QtCore.QRect(10, 210, 111, 19))
+        self.txtPosYCombattant.setMinimum(-1000)
+        self.txtPosYCombattant.setMaximum(1000)
+        self.txtPosYCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.txtPosYCombattant.setObjectName(_fromUtf8("txtPosYCombattant"))
+        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.txtTaillePoliceCombattant = QtGui.QSlider(self.groupBox_2)
+        self.txtTaillePoliceCombattant.setGeometry(QtCore.QRect(10, 90, 111, 19))
+        self.txtTaillePoliceCombattant.setMinimum(8)
+        self.txtTaillePoliceCombattant.setMaximum(99)
+        self.txtTaillePoliceCombattant.setProperty("value", 20)
+        self.txtTaillePoliceCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.txtTaillePoliceCombattant.setObjectName(_fromUtf8("txtTaillePoliceCombattant"))
+        self.txtRotationCombattant = QtGui.QSlider(self.groupBox_2)
+        self.txtRotationCombattant.setGeometry(QtCore.QRect(10, 50, 111, 19))
+        self.txtRotationCombattant.setMinimum(-180)
+        self.txtRotationCombattant.setMaximum(180)
+        self.txtRotationCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.txtRotationCombattant.setObjectName(_fromUtf8("txtRotationCombattant"))
+        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.txtPosXCombattant = QtGui.QSlider(self.groupBox_2)
+        self.txtPosXCombattant.setGeometry(QtCore.QRect(10, 170, 111, 19))
+        self.txtPosXCombattant.setMinimum(-800)
+        self.txtPosXCombattant.setMaximum(800)
+        self.txtPosXCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.txtPosXCombattant.setObjectName(_fromUtf8("txtPosXCombattant"))
+        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.txtReinitCombattant = QtGui.QPushButton(self.groupBox_2)
+        self.txtReinitCombattant.setGeometry(QtCore.QRect(10, 240, 111, 20))
+        self.txtReinitCombattant.setObjectName(_fromUtf8("txtReinitCombattant"))
+        self.txtGrasCombattant = QtGui.QCheckBox(self.groupBox_2)
+        self.txtGrasCombattant.setGeometry(QtCore.QRect(10, 120, 41, 21))
+        self.txtGrasCombattant.setObjectName(_fromUtf8("txtGrasCombattant"))
+        self.groupBox = QtGui.QGroupBox(self.tabForme)
+        self.groupBox.setGeometry(QtCore.QRect(310, 20, 131, 291))
+        self.groupBox.setObjectName(_fromUtf8("groupBox"))
+        self.imgAfficherCombattant = QtGui.QCheckBox(self.groupBox)
+        self.imgAfficherCombattant.setGeometry(QtCore.QRect(100, 10, 21, 21))
+        self.imgAfficherCombattant.setText(_fromUtf8(""))
+        self.imgAfficherCombattant.setChecked(True)
+        self.imgAfficherCombattant.setObjectName(_fromUtf8("imgAfficherCombattant"))
+        self.imgPosYCombattant = QtGui.QSlider(self.groupBox)
+        self.imgPosYCombattant.setGeometry(QtCore.QRect(10, 200, 111, 19))
+        self.imgPosYCombattant.setMinimum(-400)
+        self.imgPosYCombattant.setMaximum(400)
+        self.imgPosYCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosYCombattant.setObjectName(_fromUtf8("imgPosYCombattant"))
+        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.imgTailleXCombattant = QtGui.QSlider(self.groupBox)
+        self.imgTailleXCombattant.setGeometry(QtCore.QRect(10, 80, 111, 19))
+        self.imgTailleXCombattant.setMinimum(0)
+        self.imgTailleXCombattant.setProperty("value", 10)
+        self.imgTailleXCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleXCombattant.setObjectName(_fromUtf8("imgTailleXCombattant"))
+        self.imgRotationCombattant = QtGui.QSlider(self.groupBox)
+        self.imgRotationCombattant.setGeometry(QtCore.QRect(10, 40, 111, 19))
+        self.imgRotationCombattant.setMinimum(-180)
+        self.imgRotationCombattant.setMaximum(180)
+        self.imgRotationCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.imgRotationCombattant.setObjectName(_fromUtf8("imgRotationCombattant"))
+        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.imgPosXCombattant = QtGui.QSlider(self.groupBox)
+        self.imgPosXCombattant.setGeometry(QtCore.QRect(10, 160, 111, 19))
+        self.imgPosXCombattant.setMinimum(-400)
+        self.imgPosXCombattant.setMaximum(400)
+        self.imgPosXCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.imgPosXCombattant.setObjectName(_fromUtf8("imgPosXCombattant"))
+        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.imgTailleYCombattant = QtGui.QSlider(self.groupBox)
+        self.imgTailleYCombattant.setGeometry(QtCore.QRect(10, 120, 111, 19))
+        self.imgTailleYCombattant.setMinimum(0)
+        self.imgTailleYCombattant.setProperty("value", 10)
+        self.imgTailleYCombattant.setOrientation(QtCore.Qt.Horizontal)
+        self.imgTailleYCombattant.setObjectName(_fromUtf8("imgTailleYCombattant"))
+        self.imgReinitCombattant = QtGui.QPushButton(self.groupBox)
+        self.imgReinitCombattant.setGeometry(QtCore.QRect(10, 260, 111, 20))
+        self.imgReinitCombattant.setObjectName(_fromUtf8("imgReinitCombattant"))
+        self.imgPivoteCombattant = QtGui.QCheckBox(self.groupBox)
+        self.imgPivoteCombattant.setGeometry(QtCore.QRect(10, 220, 101, 17))
+        self.imgPivoteCombattant.setObjectName(_fromUtf8("imgPivoteCombattant"))
+        self.imgMasqueCombattant = QtGui.QCheckBox(self.groupBox)
+        self.imgMasqueCombattant.setGeometry(QtCore.QRect(10, 240, 101, 17))
+        self.imgMasqueCombattant.setObjectName(_fromUtf8("imgMasqueCombattant"))
+        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.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.listeInventaireCombattant = QtGui.QTableWidget(self.tabAttributs)
+        self.listeInventaireCombattant.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.listeInventaireCombattant.setPalette(palette)
+        self.listeInventaireCombattant.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listeInventaireCombattant.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+        self.listeInventaireCombattant.setEditTriggers(QtGui.QAbstractItemView.AllEditTriggers)
+        self.listeInventaireCombattant.setAlternatingRowColors(True)
+        self.listeInventaireCombattant.setSelectionMode(QtGui.QAbstractItemView.NoSelection)
+        self.listeInventaireCombattant.setShowGrid(True)
+        self.listeInventaireCombattant.setObjectName(_fromUtf8("listeInventaireCombattant"))
+        self.listeInventaireCombattant.setColumnCount(2)
+        self.listeInventaireCombattant.setRowCount(0)
+        item = QtGui.QTableWidgetItem()
+        self.listeInventaireCombattant.setHorizontalHeaderItem(0, item)
+        item = QtGui.QTableWidgetItem()
+        self.listeInventaireCombattant.setHorizontalHeaderItem(1, item)
+        self.listeInventaireCombattant.horizontalHeader().setVisible(False)
+        self.listeInventaireCombattant.horizontalHeader().setDefaultSectionSize(50)
+        self.listeInventaireCombattant.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.notesCombattant = QtGui.QTextEdit(self.tabAttributs)
+        self.notesCombattant.setGeometry(QtCore.QRect(230, 200, 291, 91))
+        self.notesCombattant.setObjectName(_fromUtf8("notesCombattant"))
+        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.ajouterInventaireCombattant = QtGui.QToolButton(self.tabAttributs)
+        self.ajouterInventaireCombattant.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.ajouterInventaireCombattant.setIcon(icon)
+        self.ajouterInventaireCombattant.setObjectName(_fromUtf8("ajouterInventaireCombattant"))
+        self.supprimerInventaireCombattant = QtGui.QToolButton(self.tabAttributs)
+        self.supprimerInventaireCombattant.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.supprimerInventaireCombattant.setIcon(icon1)
+        self.supprimerInventaireCombattant.setObjectName(_fromUtf8("supprimerInventaireCombattant"))
+        self.ongletsCreation.addTab(self.tabAttributs, _fromUtf8(""))
+        self.tabAttaques = QtGui.QWidget()
+        self.tabAttaques.setObjectName(_fromUtf8("tabAttaques"))
+        self.ongletsCreation.addTab(self.tabAttaques, _fromUtf8(""))
+
+        self.retranslateUi(editionCombattant)
+        self.ongletsCreation.setCurrentIndex(1)
+        QtCore.QMetaObject.connectSlotsByName(editionCombattant)
+
+    def retranslateUi(self, editionCombattant):
+        editionCombattant.setWindowTitle(_translate("editionCombattant", "Dialog", None))
+        self.label_11.setText(_translate("editionCombattant", "Image (.png, .jpg) : ...img\\", None))
+        self.annulerCreature.setText(_translate("editionCombattant", "Annuler", None))
+        self.label_3.setText(_translate("editionCombattant", "Id : ", None))
+        self.label_10.setText(_translate("editionCombattant", "Taille (en cases) : ", None))
+        self.volCombattant.setText(_translate("editionCombattant", "Vole", None))
+        self.label_2.setText(_translate("editionCombattant", "...img\\", None))
+        self.label.setText(_translate("editionCombattant", "Logo (.png, .jpg) : ", None))
+        self.enregistrerCreature.setText(_translate("editionCombattant", "Enregistrer", None))
+        self.label_4.setText(_translate("editionCombattant", "Nom : ", None))
+        self.couleurCombattant.setText(_translate("editionCombattant", "Couleur", None))
+        self.supprimerCreature.setText(_translate("editionCombattant", "Supprimer", None))
+        self.label_6.setText(_translate("editionCombattant", "Déplacement : ", None))
+        self.groupBox_2.setTitle(_translate("editionCombattant", "Texte", None))
+        self.label_17.setText(_translate("editionCombattant", "Taille de la police", None))
+        self.label_19.setText(_translate("editionCombattant", "Position (X)", None))
+        self.label_20.setText(_translate("editionCombattant", "Rotation", None))
+        self.label_21.setText(_translate("editionCombattant", "Position (Y)", None))
+        self.txtReinitCombattant.setText(_translate("editionCombattant", "Ré-initialiser", None))
+        self.txtGrasCombattant.setText(_translate("editionCombattant", "Gras", None))
+        self.groupBox.setTitle(_translate("editionCombattant", "Image", None))
+        self.label_12.setText(_translate("editionCombattant", "Taille (X)", None))
+        self.label_13.setText(_translate("editionCombattant", "Taille (Y)", None))
+        self.label_14.setText(_translate("editionCombattant", "Position (X)", None))
+        self.label_16.setText(_translate("editionCombattant", "Rotation", None))
+        self.label_15.setText(_translate("editionCombattant", "Position (Y)", None))
+        self.imgReinitCombattant.setText(_translate("editionCombattant", "Ré-initialiser", None))
+        self.imgPivoteCombattant.setText(_translate("editionCombattant", "Image pivote", None))
+        self.imgMasqueCombattant.setText(_translate("editionCombattant", "Masque auto.", None))
+        self.label_9.setText(_translate("editionCombattant", "Forme du pion : ", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabForme), _translate("editionCombattant", "Forme et apparence", None))
+        item = self.listeAttributs.horizontalHeaderItem(0)
+        item.setText(_translate("editionCombattant", "Nouvelle colonne", None))
+        item = self.listeAttributs.horizontalHeaderItem(1)
+        item.setText(_translate("editionCombattant", "Valeur", None))
+        self.label_18.setText(_translate("editionCombattant", "Attributs / caractéristiques :  ", None))
+        item = self.listeInventaireCombattant.horizontalHeaderItem(0)
+        item.setText(_translate("editionCombattant", "nombre", None))
+        item = self.listeInventaireCombattant.horizontalHeaderItem(1)
+        item.setText(_translate("editionCombattant", "objet", None))
+        self.label_22.setText(_translate("editionCombattant", "Inventaire de base :", None))
+        self.label_23.setText(_translate("editionCombattant", "Notes :", None))
+        self.ajouterInventaireCombattant.setText(_translate("editionCombattant", "...", None))
+        self.supprimerInventaireCombattant.setText(_translate("editionCombattant", "...", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabAttributs), _translate("editionCombattant", "Attributs et inventaire", None))
+        self.ongletsCreation.setTabText(self.ongletsCreation.indexOf(self.tabAttaques), _translate("editionCombattant", "Attaques", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    editionCombattant = QtGui.QDialog()
+    ui = Ui_editionCombattant()
+    ui.setupUi(editionCombattant)
+    editionCombattant.show()
+    sys.exit(app.exec_())
+