Creation des classes Decor et Combattant

Renommage des variables 'pion' en variables 'combattant' partout sauf dans
plateau

lib/Combattant.py

@@ -0,0 +1,85 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+import os
+
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from Pion import Pion
+from Forme import Forme
+from outilsSvg import *
+import regles
+
+class Combattant(Pion):
+    """combattant sur un plateau de combat"""
+    def __init__(self, plateau, numero, parent=None):
+        super(Combattant, self).__init__()
+        #caracs
+        self.id = "00"
+        
+        self.deplacement = 9
+        self.vol = 0
+        
+        self.attaques = []   #liste des attaques pre-parametrees du pion
+        self.listeAttributs = regles.listeAttributs()
+        self.inventaire = {}
+        self.notes = ""        
+
+        #caracs liees au combat:
+        self.numero = numero
+        self.etat = ""
+        self.deplacementRestant = 0        
+
+    def listeAttributs(self):
+        return self.listeAttributs
+
+    def listeAttaques(self):
+        return self.attaques
+    
+    def ajouterAuPlateau(self, plateau):
+        self.plateau = plateau
+        super(Combattant, self).ajouterAuPlateau(self.plateau)
+        self.majEtiquette()
+        
+    def hoverEnterEvent(self, event):
+        """evenement lors du survol de la souris (en entree)"""
+        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)"""
+        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/Decor.py

@@ -1,20 +1,39 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 from __future__ import division
-from PyQt4.QtGui import QColor
+import os
 
-class Decor():
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from Pion import Pion
+
+class Decor(Pion):
     """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"))        
+        self.escalade = False            #peut etre escalade
+        self.franchissable = False       #peut etre traverse (ex: rideau, porte)
+        self.brule = False               #peut prendre feu
+
+    def ajouterAuPlateau(self, plateau):
+        self.plateau = plateau
+        super(Decor, self).ajouterAuPlateau(self.plateau)
+        
+    def hoverEnterEvent(self, event):
+        """evenement lors du survol de la souris (en entree)""" 
+        self.plateau.caseSurvol(self.position[0], self.position[1])
+        self.plateau.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/Decor_ancien.py

@@ -0,0 +1,20 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+from __future__ import division
+from PyQt4.QtGui import QColor
+
+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/EcranEditionAttaques.py

@@ -10,12 +10,11 @@ import regles
 
         
 class EcranEditionAttaques(QFrame):
-    #*EEA
-    """interface d'edition des attaques du pion"""
-    def __init__(self, pion, parent=None):
+    """interface d'edition des attaques du combattant"""
+    def __init__(self, combattant, parent=None):
         """initialisation de la fenetre"""
         super (EcranEditionAttaques, self).__init__()
-        self.pion = pion
+        self.combattant = combattant
         self.colonnesBase = {}
         self.createWidgets()
         self.majEnCours = False
@@ -68,7 +67,7 @@ class EcranEditionAttaques(QFrame):
             self.ui.editionListeAttaques.removeRow(0)
         index = 0
 
-        for numAttaque in range(0, len(self.pion.attaques)):
+        for numAttaque in range(0, len(self.combattant.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())
@@ -95,20 +94,20 @@ class EcranEditionAttaques(QFrame):
             item.setFlags(Qt.NoItemFlags)
             item.setFlags(Qt.ItemIsSelectable)
 
-            if self.pion.attaques[numAttaque].typ in ["cac", "dist", "zone"]:
+            if self.combattant.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"))
+                    self.ui.editionListeAttaques.cellWidget(index, self.colonnesBase.index("Type")).findData(QVariant(self.combattant.attaques[numAttaque].typ)))
+                self.afficherDonneesAttaqueZone(index, (self.combattant.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)))
+            self.ui.editionListeAttaques.setItem(index, self.colonnesBase.index("Nom"), QTableWidgetItem(QString.fromUtf8(self.combattant.attaques[numAttaque].nom)))
                                     
             #Portee
-            self.ui.editionListeAttaques.setItem(index, self.colonnesBase.index("Portee"), QTableWidgetItem(QString.fromUtf8(str(self.pion.attaques[numAttaque].portee))))
+            self.ui.editionListeAttaques.setItem(index, self.colonnesBase.index("Portee"), QTableWidgetItem(QString.fromUtf8(str(self.combattant.attaques[numAttaque].portee))))
                         
             ### parametres supplementaires (issus des regles)
-            for elt in self.pion.attaques[numAttaque].attributs:
+            for elt in self.combattant.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]))))
+                self.ui.editionListeAttaques.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.combattant.attaques[numAttaque].attributs[elt]))))
         else:
             print ("Attaque {} introuvable, impossible de maj".format(numPion))
  
@@ -122,18 +121,18 @@ class EcranEditionAttaques(QFrame):
                     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
+                    self.combattant.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.combattant.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
+                    self.combattant.attaques[numAttaque].formeZone = forme
                     
                 elif colonne == self.colonnesBase.index("Portee"):
                     #doit etre de type numerique
@@ -143,9 +142,9 @@ class EcranEditionAttaques(QFrame):
                     except:
                         valide = False
                     if valide:
-                        self.pion.attaques[numAttaque].portee = portee
+                        self.combattant.attaques[numAttaque].portee = portee
                     else:    
-                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(self.pion.attaques[numAttaque].portee))
+                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(self.combattant.attaques[numAttaque].portee))
 
                 elif colonne == self.colonnesBase.index("Rayon"):
                     #doit etre de type numerique
@@ -155,9 +154,9 @@ class EcranEditionAttaques(QFrame):
                     except:
                         valide = False
                     if valide:
-                        self.pion.attaques[numAttaque].rayon = rayon
+                        self.combattant.attaques[numAttaque].rayon = rayon
                     else:    
-                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.pion.attaques[numAttaque].rayon)))
+                        self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.combattant.attaques[numAttaque].rayon)))
                         
             elif colonne >= 10:
                 self.majEnCours = True
@@ -165,9 +164,9 @@ class EcranEditionAttaques(QFrame):
                 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
+                    self.combattant.attaques[numAttaque].attributs[attribut] = valeurAttribut
                 else:
-                    self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.pion.attaques[numAttaque].attributs[attribut])))
+                    self.ui.editionListeAttaques.item(ligne, colonne).setText(QString.fromUtf8(str(self.combattant.attaques[numAttaque].attributs[attribut])))
                 self.majEnCours = False
 
     def majTypeAttaque(self):
@@ -176,7 +175,7 @@ class EcranEditionAttaques(QFrame):
         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.combattant.attaques[int(self.ui.editionListeAttaques.item(i, 0).text().toUtf8())].typ:
                 self.celluleModifiee(i, colonne)
 
     def majFormeZone(self):
@@ -186,12 +185,12 @@ class EcranEditionAttaques(QFrame):
             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.combattant.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.combattant.attaques.append(Attaque())
         self.majListe()
 
     def supprimerAttaque(self):
@@ -206,7 +205,7 @@ class EcranEditionAttaques(QFrame):
                            "Etes vous sûr de vouloir supprimer cette attaque?", QMessageBox.Yes | 
                            QMessageBox.No, QMessageBox.No)
             if reponse == QMessageBox.Yes:   
-                del self.pion.attaques[numAttaque]
+                del self.combattant.attaques[numAttaque]
                 self.majListe()
         else:
             print "pas d'attaque selectionnee"
@@ -236,10 +235,10 @@ class EcranEditionAttaques(QFrame):
             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"]:
+            if self.combattant.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)))
+                    self.ui.editionListeAttaques.cellWidget(ligne, self.colonnesBase.index("Forme")).findData(QVariant(self.combattant.attaques[numAttaque].formeZone)))
+            item = QTableWidgetItem(QString.fromUtf8(str(self.combattant.attaques[numAttaque].rayon)))
             item.setBackgroundColor(QColor("white"))
             self.ui.editionListeAttaques.setItem(ligne, self.colonnesBase.index("Rayon"), item)
         else:

lib/EcranEditionCreature.py

@@ -4,28 +4,30 @@ from __future__ import division
 
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
-from Creature import Creature
-from ui.ecran_editionCreature import Ui_editionCreature
+from Combattant import Combattant
+from ui.ecran_editionCombattant import Ui_editionCombattant
 from outilsSvg import *
 from VueEditionForme import VueEditionForme
 from EcranEditionAttaques import EcranEditionAttaques
 import regles
 
 
-class EcranEditionCreature(QDialog):
+class EcranEditionCombattant(QDialog):
     """interface de creation/edition de terrains"""
-    def __init__(self, creature=None, formeCases = "H", parent=None):
+    def __init__(self, combattant=None, formeCases = "H", parent=None):
         """initialisation de la fenetre"""
-        super (EcranEditionCreature, self).__init__()
-        self.creature = creature
+        super (EcranEditionCombattant, self).__init__()
         self.pixGraphique = None
         self.formeCases = formeCases
         self.createWidgets()
         
-        if creature == None:
+        if combattant == None:
+            self.combattant = Combattant()
             self.accesCreation()
         else:
+            self.combattant = combattant
             self.accesEdition()
+            
         self.majAffichage("")
         self.afficheListeAttaques()
         self.majListeAttributs()
@@ -34,35 +36,35 @@ class EcranEditionCreature(QDialog):
     def createWidgets(self):
         """construction de l'interface"""
         #construction de l'interface
-        self.ui = Ui_editionCreature()
+        self.ui = Ui_editionCombattant()
         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.enregistrerCombattant, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.annulerCombattant, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.supprimerCombattant, SIGNAL("clicked()"), self.supprimer)
+        self.connect(self.ui.idCombattant, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.nomCombattant, SIGNAL("textEdited(QString)"), self.majAffichage)
+        self.connect(self.ui.couleurCombattant, 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.imgTextureCombattant, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgLogoCombattant, SIGNAL("textEdited(QString)"), self.majApercuImage)
+        self.connect(self.ui.imgAfficherCombattant, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPivoteCombattant, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgMasqueCombattant, SIGNAL("stateChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleXCombattant, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgTailleYCombattant, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosXCombattant, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgPosYCombattant, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgRotationCombattant, SIGNAL("valueChanged(int)"), self.majApercuImage)
+        self.connect(self.ui.imgReinitCombattant, 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.connect(self.ui.nomCombattant, SIGNAL("textEdited(QString)"), self.majApercuTexte)
+        self.connect(self.ui.txtAfficherCombattant, SIGNAL("stateChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtTaillePoliceCombattant, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtGrasCombattant, SIGNAL("stateChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtPosXCombattant, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtPosYCombattant, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtRotationCombattant, SIGNAL("valueChanged(int)"), self.majApercuTexte)
+        self.connect(self.ui.txtReinitCombattant, SIGNAL("clicked()"), self.reinitTexte)
 
         self.vueForme = VueEditionForme(self, self.formeCases)
         self.vueForme.creer()
@@ -71,71 +73,70 @@ class EcranEditionCreature(QDialog):
         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)
+##        self.ui.listeInventaireCombattant.setColumnWidth(0, (0.2*self.ui.listeInventaireCombattant.width()))
+##        self.ui.listeInventaireCombattant.setColumnWidth(1, (0.8*self.ui.listeInventaireCombattant.width()))
+##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("clicked()"), self.listeInventaireCelluleModifiee)
+##        self.connect(self.ui.supprimerInventaireCombattant, SIGNAL("clicked()"), self.supprimerLigneListeInventaire)
+##        self.connect(self.ui.ajouterInventaireCombattant, SIGNAL("clicked()"), self.ajouterLigneListeInventaire)
    
         
     def accesEdition(self):
         """ouverture en mode edition"""
-        self.ui.idCreature.setEnabled(True)
+        self.ui.idCombattant.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)))
+        self.ui.idCombattant.setText(QString.fromUtf8(str(self.combattant.id)))
+        self.ui.nomCombattant.setText(QString.fromUtf8(str(self.combattant.nom)))
+        self.ui.notesCombattant.setText(QString.fromUtf8(str(self.combattant.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"])
+        if self.combattant.couleur.isValid():
+            self.ui.affichageCouleurCombattant.setStyleSheet("QLabel {backGround:%s}" %(self.combattant.couleur.name()))
+        self.ui.imgLogoCombattant.setText(QString.fromUtf8(str(self.combattant.logo)))
+        self.ui.imgTextureCombattant.setText(QString.fromUtf8(str(self.combattant.img.nom)))
+        self.ui.imgTailleXCombattant.setValue(self.combattant.img.kx)
+        self.ui.imgTailleYCombattant.setValue(self.combattant.img.ky)
+        self.ui.imgPosXCombattant.setValue(self.combattant.img.dx)
+        self.ui.imgPosYCombattant.setValue(self.combattant.img.dy)
+        self.ui.imgRotationCombattant.setValue(self.combattant.img.rotation)
+        self.ui.imgPivoteCombattant.setChecked(self.combattant.img.pivote)
+        self.ui.imgMasqueCombattant.setChecked(self.combattant.img.masqueAuto)
 
-        self.ui.txtTaillePoliceCreature.setValue(self.creature.txt["taille_police"])
-        self.ui.txtGrasCreature.setChecked(self.creature.txt["gras"])
+        self.ui.txtTaillePoliceCombattant.setValue(self.combattant.etiquette.taille_police)
+        self.ui.txtGrasCombattant.setChecked(self.combattant.etiquette.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.txtPosXCombattant.setValue(self.combattant.etiquette.dx)
+        self.ui.txtPosYCombattant.setValue(self.combattant.etiquette.dy)
+        self.ui.txtRotationCombattant.setValue(self.combattant.etiquette.rotation)
         
-        self.ui.deplacementCreature.setValue(self.creature.deplacement)
-        self.ui.hauteurCreature.setValue(self.creature.hauteur)
-        self.ui.volCreature.setChecked(self.creature.vol)
+        self.ui.deplacementCombattant.setValue(self.combattant.deplacement)
+        self.ui.hauteurCombattant.setValue(self.combattant.hauteur)
+        self.ui.volCombattant.setChecked(self.combattant.vol)
    
-        self.vueForme.majForme(self.creature.formeDef[self.formeCases])
-        self.ui.supprimerCreature.setEnabled(True)
-        self.ui.idCreature.setEnabled(False)
+        self.vueForme.majForme(self.combattant.formeDef[self.formeCases])
+        self.ui.supprimerCombattant.setEnabled(True)
+        self.ui.idCombattant.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.ui.idCombattant.setEnabled(True)
+        self.ui.idCombattant.setText(QString.fromUtf8(str(self.nouvelIdCombattant())))
+        self.ui.idCombattant.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)
+        self.ui.enregistrerCombattant.setEnabled(len(self.ui.idCombattant.text().toUtf8()) > 0 and len(self.ui.nomCombattant.text().toUtf8()) > 0)
 
     def afficheListeAttaques(self):
         """insere la frame d'edition des attaques"""
         tabAttaques = self.ui.ongletsCreation.widget(1)
-        editionAttaques = EcranEditionAttaques(self.creature)
+        editionAttaques = EcranEditionAttaques(self.combattant)
         editionAttaques.setParent(tabAttaques)
 
     def majListeAttributs(self):
-        """met a jour la liste des attributs de la creature"""
+        """met a jour la liste des attributs de la Combattant"""
         """met a jour la liste des attributs dans le panneau de combat"""
         self.disconnect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
         
@@ -152,7 +153,7 @@ class EcranEditionCreature(QDialog):
             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.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.lstCaracCombattant[elt]))))
             
         self.connect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
 
@@ -165,29 +166,29 @@ class EcranEditionCreature(QDialog):
             nouvelleVal = str(self.ui.listeAttributs.item(ligne, 1).text().toUtf8())
             valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal)
             if valVerifiee != None:
-                self.creature.lstCaracCreature[attribut] = valVerifiee
+                self.combattant.lstCaracCombattant[attribut] = valVerifiee
             else:    
-                self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.creature.lstCaracCreature[attribut]))))
+                self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.lstCaracCombattant[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)
+##        """met a jour la liste de l'inventaire de la Combattant"""
+##        self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
 ##        
 ##        #on vide la liste
-##        while self.ui.listeInventaireCreature.rowCount() > 0:
-##            self.ui.listeInventaireCreature.removeRow(0)
+##        while self.ui.listeInventaireCombattant.rowCount() > 0:
+##            self.ui.listeInventaireCombattant.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)))
+##        for objet in self.combattant.inventaire:
+##            self.ui.listeInventaireCombattant.insertRow(ligne)
+##            self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(self.combattant.inventaire[objet])))
+##            self.ui.listeInventaireCombattant.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
 ##            ligne += 1
-##        self.connect(self.ui.listeInventaireCreature, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##        self.connect(self.ui.listeInventaireCombattant, 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())
+##        nouvelleVal = str(self.ui.listeInventaireCombattant.item(ligne, colonne).text().toUtf8())
 ##        val = None
 ##        if colonne == 0:
 ##            try:
@@ -197,62 +198,62 @@ class EcranEditionCreature(QDialog):
 ##            if nbre >= 0: val = str(nbre)
 ##        else:
 ##            val = str(nouvelleVal)
-##            if val in self.creature.inventaire or len(val) == 0:
+##            if val in self.combattant.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
+##                self.combattant.inventaire[str(self.ui.listeInventaireCombattant.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())]))))
+##                self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(\
+##                                                        str(self.combattant.inventaire[str(self.ui.listeInventaireCombattant.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]
+##            txt = str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())
+##            if txt in self.combattant.inventaire:
+##                del self.combattant.inventaire[txt]
 ##            if val != None:
-##                self.creature.inventaire[val] = txt
+##                self.combattant.inventaire[val] = txt
 ##            else:    
-##                self.ui.listeInventaireCreature.removeRow(ligne)
+##                self.ui.listeInventaireCombattant.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:
+##        for i in range(0, self.ui.listeInventaireCombattant.rowCount()):   #si un objet de la liste a deja un nom vide, on ne cree pas de nouvelle ligne
+##            if len(str(self.ui.listeInventaireCombattant.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)
+##            self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##            ligne = self.ui.listeInventaireCombattant.rowCount()
+##            self.ui.listeInventaireCombattant.insertRow(ligne)
+##            self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8("0")))
+##            self.ui.listeInventaireCombattant.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
+##            self.connect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
 ##        else:
-##            self.ui.listeInventaireCreature.setCurrentRow(num)
+##            self.ui.listeInventaireCombattant.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)        
+##        self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
+##        ligne = self.ui.listeInventaireCombattant.currentRow()
+##        del self.combattant.inventaire[str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())]
+##        self.ui.listeInventaireCombattant.removeRow(ligne)
+##        self.connect(self.ui.listeInventaireCombattant, 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() )
+        if self.ui.imgAfficherCombattant.isChecked():
+            if len(str(self.ui.imgTextureCombattant.text().toUtf8())) > 0:
+                img = str(self.ui.imgTextureCombattant.text().toUtf8())
+                self.vueForme.majImage(img, self.ui.imgTailleXCombattant.value() \
+                                          , self.ui.imgTailleYCombattant.value() \
+                                          , self.ui.imgPosXCombattant.value() \
+                                          , self.ui.imgPosYCombattant.value() \
+                                          , self.ui.imgRotationCombattant.value() \
+                                          , self.ui.imgPivoteCombattant.isChecked() \
+                                          , self.ui.imgMasqueCombattant.isChecked() )
             else:
-                img = str(self.ui.imgLogoCreature.text().toUtf8())
+                img = str(self.ui.imgLogoCombattant.text().toUtf8())
                 self.vueForme.majImage(img)
         else:
             img = ""
@@ -260,37 +261,37 @@ class EcranEditionCreature(QDialog):
 
     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())
+        if self.ui.txtAfficherCombattant.isChecked():
+            txt = str(self.ui.nomCombattant.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())
+        self.vueForme.majTexte(txt, self.ui.txtTaillePoliceCombattant.value() \
+                                  , self.ui.txtGrasCombattant.isChecked() \
+                                  , self.ui.txtPosXCombattant.value() \
+                                  , self.ui.txtPosYCombattant.value() \
+                                  , self.ui.txtRotationCombattant.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.ui.imgTailleXCombattant.setValue(10)
+        self.ui.imgTailleYCombattant.setValue(10)
+        self.ui.imgPosXCombattant.setValue(0)
+        self.ui.imgPosYCombattant.setValue(0)
+        self.ui.imgRotationCombattant.setValue(0)
+        self.ui.imgPivoteCombattant.setChecked(False)
+        self.ui.imgMasqueCombattant.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.ui.txtTaillePoliceCombattant.setValue(21)
+        self.ui.txtGrasCombattant.setCheckState(0)
+        self.ui.txtPosXCombattant.setValue(0)
+        self.ui.txtPosYCombattant.setValue(0)
+        self.ui.txtRotationCombattant.setValue(0)
         self.majApercuTexte()        
 
-    def nouvelIdCreature(self):
+    def nouvelIdCombattant(self):
         """renvoie un identifiant pour un nouveau terrain"""
-        dicoSvg = afficheSvg("lib\\biblio\\creature")
+        dicoSvg = afficheSvg("lib\\biblio\\Combattant")
         nouvelId = 1
         while str(nouvelId) in dicoSvg.keys():
             nouvelId += 1
@@ -301,60 +302,60 @@ class EcranEditionCreature(QDialog):
         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    
+            self.ui.affichageCouleurCombattant.setStyleSheet("QLabel {backGround:%s}" %(nomCouleur))
+            self.combattant.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()
+        self.combattant.id = str(self.ui.idCombattant.text().toUtf8())
+        self.combattant.nom = str(self.ui.nomCombattant.text().toUtf8())
+        self.combattant.logo = str(self.ui.imgLogoCombattant.text().toUtf8())
+        if len(str(self.ui.imgTextureCombattant.text().toUtf8())) > 0:
+            self.combattant.img.nom = str(self.ui.imgTextureCombattant.text().toUtf8())
+            self.combattant.img.kx = self.ui.imgTailleXCombattant.value()
+            self.combattant.img.ky = self.ui.imgTailleYCombattant.value()
+            self.combattant.img.dx = self.ui.imgPosXCombattant.value()
+            self.combattant.img.dy = self.ui.imgPosYCombattant.value()
+            self.combattant.img.rotation = self.ui.imgRotationCombattant.value()
+            self.combattant.img.pivote = self.ui.imgPivoteCombattant.isChecked()
+            self.combattant.img.masqueAuto = self.ui.imgMasqueCombattant.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.combattant.img.nom = str(self.ui.imgLogoCombattant.text().toUtf8())
+            self.combattant.img.kx = 10
+            self.combattant.img.ky = 10
+            self.combattant.img.dx = 0
+            self.combattant.img.dy = 0
+            self.combattant.img.rotation = 0
+            self.combattant.img.pivote = False
+            self.combattant.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.combattant.etiquette.taille_police = self.ui.txtTaillePoliceCombattant.value()
+        self.combattant.etiquette.gras = bool(self.ui.txtGrasCombattant.checkState())
+        self.combattant.etiquette.dx = self.ui.txtPosXCombattant.value()
+        self.combattant.etiquette.dy = self.ui.txtPosYCombattant.value()
+        self.combattant.etiquette.rotation = self.ui.txtRotationCombattant.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.combattant.deplacement = int(self.ui.deplacementCombattant.value())
+        self.combattant.hauteur = int(self.ui.hauteurCombattant.value())
+        self.combattant.vol = self.ui.volCombattant.isChecked()
 
-        self.creature.formeDef[self.formeCases] = self.vueForme.formeDef()
+        self.combattant.formeDef[self.formeCases] = self.vueForme.formeDef()
 
-        self.creature.notes = str(self.ui.notesCreature.toPlainText())
+        self.combattant.notes = str(self.ui.notesCombattant.toPlainText())
         #attributs, attaques et inventaire enregistres lors de la modif des listes
         
-        enregistrer(self.creature.id, self.creature, "lib\\biblio\\creature")
-        self.creature = None
-        self.emit(SIGNAL("majListCreatures()"))
+        enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\Combattant")
+        self.combattant = None
+        self.emit(SIGNAL("majListCombattants()"))
         self.close()
 
     def supprimer(self):
         """supprimer l'enregistrement de ce terrain"""
-        supprSvg("lib\\biblio\\creature", self.creature.id)
-        self.emit(SIGNAL("majListCreatures()"))
+        supprSvg("lib\\biblio\\Combattant", self.combattant.id)
+        self.emit(SIGNAL("majListCombattants()"))
         self.close()
 
     def annuler(self):
         """annule la creation/edition"""
-        self.creature = None
+        self.combattant = None
         self.close()

lib/EcranEditionDecors.py

@@ -14,14 +14,16 @@ class EcranEditionDecors(QDialog):
     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.decor = Decor()
             self.accesCreation()
         else:
+            self.decor = decor
             self.accesEdition()
         self.majAffichage("")    
         
@@ -86,9 +88,8 @@ class EcranEditionDecors(QDialog):
 
     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.setText(QString.fromUtf8(str(self.nouvelIdDecor())))
         self.ui.idDecor.setEnabled(False)
         self.majApercuImage()
 
@@ -96,7 +97,7 @@ class EcranEditionDecors(QDialog):
         """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):
+    def nouvelIdDecor(self):
         """renvoie un identifiant pour un nouveau decor"""
         dicoSvg = afficheSvg("lib\\biblio\\decor")
         nouvelId = 1
@@ -149,23 +150,23 @@ class EcranEditionDecors(QDialog):
 
         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()
+            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.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()

lib/EcranGestionCombat.py

@@ -11,7 +11,6 @@ from lancer import jet, estJetValide
 
 
 class EcranGestionCombat(QFrame):
-    #*EGC
     """interface de gestion du combat (MJ)"""
     def __init__(self, plateau, parent=None):
         """initialisation de la fenetre"""
@@ -79,8 +78,8 @@ class EcranGestionCombat(QFrame):
         #nom, largeur, (est modifiable?)
         self.ui.gc_liste.setEditTriggers(QAbstractItemView.DoubleClicked)
         self.ui.gc_liste.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}
+        self.colonnesBase = ["num","I","Des","DetailDes","Combattant","Ordre","Etat","Alt.","Notes"]
+        largeurColonnesBase = {"num": 0, "I": 20, "Des": 40, "DetailDes": 60, "Combattant": 80,"Ordre": 40, "Etat": 60,"Alt.": 30,"Notes": 80}
 
         for i in range(0, 20):
             self.ui.gc_liste.insertColumn(i)
@@ -115,11 +114,11 @@ class EcranGestionCombat(QFrame):
             self.ui.gc_liste.removeRow(0)
         index = 0
 
-        for num in self.plateau.pions:
+        for num in self.plateau.combattants:
             self.ui.gc_liste.insertRow(int(index))
-            #num du pion (0):
+            #num du combattant (0):
             self.ui.gc_liste.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(str(num))))
-            self.majDonneesPion(num)
+            self.majDonneesCombattant(num)
             index += 1
 
         for elt in regles.ordreAttributs():    
@@ -129,21 +128,21 @@ class EcranGestionCombat(QFrame):
                      
         self.majEnCours = False
 
-    def majDonneesPion(self, numPion):
-        """met a jour les donnees du pion"""
+    def majDonneesCombattant(self, numCombattant):
+        """met a jour les donnees du combattant"""
         index = None
         for i in range(0, self.ui.gc_liste.rowCount()):
-            if int(self.ui.gc_liste.item(i, 0).text().toUtf8()) == numPion:
+            if int(self.ui.gc_liste.item(i, 0).text().toUtf8()) == numCombattant:
                 index = i
                 break
             
         if index != None:
             ### parametres de base
-            #I - Indication sur le pion (attaquant, defenseur, selectionne sur la plateau...etc)
+            #I - Indication sur le combattant (attaquant, defenseur, selectionne sur la plateau...etc)
             item = QTableWidgetItem()
             item.setFlags(Qt.NoItemFlags)
             item.setFlags(Qt.ItemIsSelectable)
-            if numPion == self.plateau.numPionEnCours:
+            if numCombattant == self.plateau.numCombattantEnCours:
                 item.setIcon(QIcon("img\\flecheDroite2.png"))
             if item != None:
                 self.ui.gc_liste.setItem(index, self.colonnesBase.index("I"), item)
@@ -153,38 +152,38 @@ class EcranGestionCombat(QFrame):
             self.ui.gc_liste.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.gc_liste.setItem(index, self.colonnesBase.index("Pion"), item)
+            item = QTableWidgetItem(QIcon("img\\"+self.plateau.combattants[numCombattant].creature.logo), \
+                                    QString.fromUtf8(self.plateau.combattants[numCombattant].txtId()))
+            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Combattant"), item)
             
             #Ordre
-            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Ordre"), QTableWidgetItem(QString.fromUtf8(str(self.plateau.ordreJeu[numPion]))))
+            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Ordre"), QTableWidgetItem(QString.fromUtf8(str(self.plateau.ordreJeu[numCombattant]))))
 
             #Etat
             #...
 
             #altitude
-            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.pions[numPion].z))))
+            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].z))))
 
             ### parametres supplementaires (issus des regles)
-            for elt in self.plateau.pions[numPion].lstCarac:
+            for elt in self.plateau.combattants[numCombattant].lstCarac:
                 col = 20 + regles.ordreAttributs().index(elt)
-                self.ui.gc_liste.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.plateau.pions[numPion].lstCarac[elt]))))
+                self.ui.gc_liste.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].lstCarac[elt]))))
         else:
-            print ("Pion {} introuvable, impossible de maj".format(numPion))
+            print ("Combattant {} introuvable, impossible de maj".format(numCombattant))
  
         
     def celluleModifiee(self, ligne, colonne):
         """une cellule de la table a ete modifiee"""
         if not self.majEnCours:
-            numPion = int(self.ui.gc_liste.item(ligne, 0).text().toUtf8())
+            numCombattant = int(self.ui.gc_liste.item(ligne, 0).text().toUtf8())
             
             if colonne < len(self.colonnesBase):
                 if colonne == self.colonnesBase.index("Ordre"):
                     #ordre de jeu
                     nouvellePosition = int(self.ui.gc_liste.item(ligne, colonne).text().toUtf8())
                     if nouvellePosition < 1: nouvellePosition = 1
-                    self.plateau.pionDeplacerDansOrdreJeu(numPion, nouvellePosition)
+                    self.plateau.combattantDeplacerDansOrdreJeu(numCombattant, nouvellePosition)
                     self.majListe()
                     
                 elif colonne == self.colonnesBase.index("Des"):
@@ -203,22 +202,21 @@ class EcranGestionCombat(QFrame):
                 attribut = regles.ordreAttributs()[index]
                 valeurAttribut = regles.listeControle()[attribut].controler(str(self.ui.gc_liste.item(ligne, colonne).text().toUtf8()))
                 if valeurAttribut != None:
-                    self.plateau.pions[numPion].lstCarac[attribut] = valeurAttribut
+                    self.plateau.combattants[numCombattant].lstCarac[attribut] = valeurAttribut
                     if attribut == regles.attributOrdreJeu():
                         self.plateau.majOrdreJeu()
                         self.majTri()
                 else:
-                    self.ui.gc_liste.item(ligne, colonne).setText(QString.fromUtf8(str(self.plateau.pions[numPion].lstCarac[attribut])))
+                    self.ui.gc_liste.item(ligne, colonne).setText(QString.fromUtf8(str(self.plateau.combattants[numCombattant].lstCarac[attribut])))
                 self.majEnCours = False
                 
-            self.emit(SIGNAL("majListesPions"), numPion)                        
+            self.emit(SIGNAL("majListesCombattants"), numCombattant)                        
 
     def majTri(self):
         """met a jour le tri en fonction de la colonne ordreJeu """
         for i in range(0,self.ui.gc_liste.rowCount()):
             self.ui.gc_liste.setItem(i, self.colonnesBase.index("Ordre"), \
                                        QTableWidgetItem(str(self.plateau.ordreJeu[int(str(self.ui.gc_liste.item(i,0).text().toUtf8()))])))
-##        trierTable(self.ui.gc_liste, 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"""
@@ -260,8 +258,8 @@ class EcranGestionCombat(QFrame):
         """selectionne les lignes demandees"""
         origine = str(self.sender().objectName())
         for i in range(0, self.ui.gc_liste.rowCount()):
-            if origine == "selectionPionEnCours":
-                self.ui.gc_liste.item(i, 0).setSelected((int(self.ui.gc_liste.item(i, 0).text().toUtf8()) == self.plateau.numPionEnCours))
+            if origine == "selectionCombattantEnCours":
+                self.ui.gc_liste.item(i, 0).setSelected((int(self.ui.gc_liste.item(i, 0).text().toUtf8()) == self.plateau.numCombattantEnCours))
             elif origine == "selectionAttaquant":
                 pass
             elif origine == "selectionDefenseur":
@@ -272,7 +270,7 @@ class EcranGestionCombat(QFrame):
     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
+        aMaj = []   #liste des numCombattants a mettre a jour
         cible = str(self.ui.gc_nomChampMaj.itemData(self.ui.gc_nomChampMaj.currentIndex()).toString())
         
         if cible == "D":

lib/Pion_ancien.py

@@ -67,7 +67,7 @@ class Pion(QGraphicsItem):
             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.attaques = self.creature.listeAttaques()
             self.lstCarac = self.creature.listeCarac()
         else:
             if couleur != None:

lib/Plateau.py

@@ -39,8 +39,6 @@ m_couleursRapides = [(255,255,255), (200,200,200), (130,130,130), (90,90,90), (1
                    (0,85,0), (170,255,0), (170,255,127), (85,85,0), (85,0,0), (170,85,0), (100,50,0), \
                    (255,255,127), (240,80,0), (85,170,255), (85,85,255), (85,0,255), (0,255,255)]
 
-
-
         
 class Plateau(QGraphicsScene):
     """plateau de jeu contenant les cases, decors et pions"""

lib/ui/convertCombattant.cmd

@@ -0,0 +1 @@
+pyuic4 -x editionCombattant.ui -o ecran_editionCombattant.py

lib/ui/convertCreature.cmd

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

lib/ui/editionCombattant.ui

@@ -0,0 +1,1021 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>editionCombattant</class>
+ <widget class="QDialog" name="editionCombattant">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>712</width>
+    <height>559</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <widget class="QLabel" name="affichageCouleurCombattant">
+   <property name="geometry">
+    <rect>
+     <x>110</x>
+     <y>50</y>
+     <width>51</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="frameShape">
+    <enum>QFrame::Box</enum>
+   </property>
+   <property name="frameShadow">
+    <enum>QFrame::Sunken</enum>
+   </property>
+   <property name="text">
+    <string/>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_11">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>120</y>
+     <width>141</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Image (.png, .jpg) : ...img\</string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="annulerCreature">
+   <property name="geometry">
+    <rect>
+     <x>490</x>
+     <y>520</y>
+     <width>81</width>
+     <height>23</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Annuler</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_3">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>20</y>
+     <width>46</width>
+     <height>16</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Id : </string>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="imgLogoCombattant">
+   <property name="geometry">
+    <rect>
+     <x>180</x>
+     <y>90</y>
+     <width>191</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QDoubleSpinBox" name="hauteurCombattant">
+   <property name="geometry">
+    <rect>
+     <x>560</x>
+     <y>50</y>
+     <width>41</width>
+     <height>22</height>
+    </rect>
+   </property>
+   <property name="prefix">
+    <string/>
+   </property>
+   <property name="decimals">
+    <number>0</number>
+   </property>
+   <property name="minimum">
+    <double>1.000000000000000</double>
+   </property>
+   <property name="maximum">
+    <double>50.000000000000000</double>
+   </property>
+   <property name="singleStep">
+    <double>1.000000000000000</double>
+   </property>
+   <property name="value">
+    <double>1.000000000000000</double>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_10">
+   <property name="geometry">
+    <rect>
+     <x>470</x>
+     <y>50</y>
+     <width>81</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Taille (en cases) : </string>
+   </property>
+  </widget>
+  <widget class="QCheckBox" name="volCombattant">
+   <property name="geometry">
+    <rect>
+     <x>560</x>
+     <y>90</y>
+     <width>61</width>
+     <height>17</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Vole</string>
+   </property>
+   <property name="checked">
+    <bool>false</bool>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="idCombattant">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="geometry">
+    <rect>
+     <x>52</x>
+     <y>20</y>
+     <width>31</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="nomCombattant">
+   <property name="geometry">
+    <rect>
+     <x>122</x>
+     <y>20</y>
+     <width>281</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QDoubleSpinBox" name="deplacementCombattant">
+   <property name="geometry">
+    <rect>
+     <x>560</x>
+     <y>20</y>
+     <width>41</width>
+     <height>22</height>
+    </rect>
+   </property>
+   <property name="prefix">
+    <string/>
+   </property>
+   <property name="decimals">
+    <number>0</number>
+   </property>
+   <property name="singleStep">
+    <double>1.000000000000000</double>
+   </property>
+   <property name="value">
+    <double>1.000000000000000</double>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_2">
+   <property name="geometry">
+    <rect>
+     <x>130</x>
+     <y>90</y>
+     <width>71</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>...img\</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>90</y>
+     <width>141</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Logo (.png, .jpg) : </string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="enregistrerCreature">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="geometry">
+    <rect>
+     <x>120</x>
+     <y>520</y>
+     <width>101</width>
+     <height>23</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <weight>75</weight>
+     <bold>true</bold>
+    </font>
+   </property>
+   <property name="text">
+    <string>Enregistrer</string>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="imgTextureCombattant">
+   <property name="geometry">
+    <rect>
+     <x>180</x>
+     <y>120</y>
+     <width>191</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_4">
+   <property name="geometry">
+    <rect>
+     <x>90</x>
+     <y>20</y>
+     <width>46</width>
+     <height>16</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Nom : </string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="couleurCombattant">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>50</y>
+     <width>75</width>
+     <height>23</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Couleur</string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="supprimerCreature">
+   <property name="enabled">
+    <bool>false</bool>
+   </property>
+   <property name="geometry">
+    <rect>
+     <x>400</x>
+     <y>520</y>
+     <width>75</width>
+     <height>23</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Supprimer</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_6">
+   <property name="geometry">
+    <rect>
+     <x>480</x>
+     <y>20</y>
+     <width>81</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Déplacement : </string>
+   </property>
+  </widget>
+  <widget class="QTabWidget" name="ongletsCreation">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>160</y>
+     <width>681</width>
+     <height>351</height>
+    </rect>
+   </property>
+   <property name="currentIndex">
+    <number>1</number>
+   </property>
+   <widget class="QWidget" name="tabForme">
+    <attribute name="title">
+     <string>Forme et apparence</string>
+    </attribute>
+    <widget class="QGroupBox" name="groupBox_2">
+     <property name="geometry">
+      <rect>
+       <x>460</x>
+       <y>20</y>
+       <width>131</width>
+       <height>291</height>
+      </rect>
+     </property>
+     <property name="title">
+      <string>Texte</string>
+     </property>
+     <widget class="QCheckBox" name="txtAfficherCombattant">
+      <property name="geometry">
+       <rect>
+        <x>100</x>
+        <y>10</y>
+        <width>21</width>
+        <height>21</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string/>
+      </property>
+      <property name="checked">
+       <bool>true</bool>
+      </property>
+     </widget>
+     <widget class="QSlider" name="txtPosYCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>210</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-1000</number>
+      </property>
+      <property name="maximum">
+       <number>1000</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_17">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>70</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Taille de la police</string>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_19">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>150</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Position (X)</string>
+      </property>
+     </widget>
+     <widget class="QSlider" name="txtTaillePoliceCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>90</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>8</number>
+      </property>
+      <property name="maximum">
+       <number>99</number>
+      </property>
+      <property name="value">
+       <number>20</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QSlider" name="txtRotationCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>50</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-180</number>
+      </property>
+      <property name="maximum">
+       <number>180</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_20">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>30</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Rotation</string>
+      </property>
+     </widget>
+     <widget class="QSlider" name="txtPosXCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>170</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-800</number>
+      </property>
+      <property name="maximum">
+       <number>800</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_21">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>190</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Position (Y)</string>
+      </property>
+     </widget>
+     <widget class="QPushButton" name="txtReinitCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>240</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Ré-initialiser</string>
+      </property>
+     </widget>
+     <widget class="QCheckBox" name="txtGrasCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>120</y>
+        <width>41</width>
+        <height>21</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Gras</string>
+      </property>
+     </widget>
+    </widget>
+    <widget class="QGroupBox" name="groupBox">
+     <property name="geometry">
+      <rect>
+       <x>310</x>
+       <y>20</y>
+       <width>131</width>
+       <height>291</height>
+      </rect>
+     </property>
+     <property name="title">
+      <string>Image</string>
+     </property>
+     <widget class="QCheckBox" name="imgAfficherCombattant">
+      <property name="geometry">
+       <rect>
+        <x>100</x>
+        <y>10</y>
+        <width>21</width>
+        <height>21</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string/>
+      </property>
+      <property name="checked">
+       <bool>true</bool>
+      </property>
+     </widget>
+     <widget class="QSlider" name="imgPosYCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>200</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-400</number>
+      </property>
+      <property name="maximum">
+       <number>400</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_12">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>60</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Taille (X)</string>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_13">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>100</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Taille (Y)</string>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_14">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>140</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Position (X)</string>
+      </property>
+     </widget>
+     <widget class="QSlider" name="imgTailleXCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>80</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>0</number>
+      </property>
+      <property name="value">
+       <number>10</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QSlider" name="imgRotationCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>40</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-180</number>
+      </property>
+      <property name="maximum">
+       <number>180</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_16">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>20</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Rotation</string>
+      </property>
+     </widget>
+     <widget class="QSlider" name="imgPosXCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>160</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>-400</number>
+      </property>
+      <property name="maximum">
+       <number>400</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QLabel" name="label_15">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>180</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Position (Y)</string>
+      </property>
+     </widget>
+     <widget class="QSlider" name="imgTailleYCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>120</y>
+        <width>111</width>
+        <height>19</height>
+       </rect>
+      </property>
+      <property name="minimum">
+       <number>0</number>
+      </property>
+      <property name="value">
+       <number>10</number>
+      </property>
+      <property name="orientation">
+       <enum>Qt::Horizontal</enum>
+      </property>
+     </widget>
+     <widget class="QPushButton" name="imgReinitCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>260</y>
+        <width>111</width>
+        <height>20</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Ré-initialiser</string>
+      </property>
+     </widget>
+     <widget class="QCheckBox" name="imgPivoteCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>220</y>
+        <width>101</width>
+        <height>17</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Image pivote</string>
+      </property>
+     </widget>
+     <widget class="QCheckBox" name="imgMasqueCombattant">
+      <property name="geometry">
+       <rect>
+        <x>10</x>
+        <y>240</y>
+        <width>101</width>
+        <height>17</height>
+       </rect>
+      </property>
+      <property name="text">
+       <string>Masque auto.</string>
+      </property>
+     </widget>
+    </widget>
+    <widget class="QLabel" name="label_9">
+     <property name="geometry">
+      <rect>
+       <x>20</x>
+       <y>0</y>
+       <width>251</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Forme du pion : </string>
+     </property>
+    </widget>
+    <widget class="QGraphicsView" name="vueForme">
+     <property name="geometry">
+      <rect>
+       <x>20</x>
+       <y>20</y>
+       <width>281</width>
+       <height>291</height>
+      </rect>
+     </property>
+     <property name="renderHints">
+      <set>QPainter::Antialiasing|QPainter::HighQualityAntialiasing|QPainter::TextAntialiasing</set>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QWidget" name="tabAttributs">
+    <attribute name="title">
+     <string>Attributs et inventaire</string>
+    </attribute>
+    <widget class="QTableWidget" name="listeAttributs">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>30</y>
+       <width>191</width>
+       <height>261</height>
+      </rect>
+     </property>
+     <property name="palette">
+      <palette>
+       <active>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="150">
+           <red>255</red>
+           <green>255</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </active>
+       <inactive>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="150">
+           <red>255</red>
+           <green>255</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </inactive>
+       <disabled>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>240</red>
+           <green>240</green>
+           <blue>240</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </disabled>
+      </palette>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::WinPanel</enum>
+     </property>
+     <property name="horizontalScrollBarPolicy">
+      <enum>Qt::ScrollBarAlwaysOff</enum>
+     </property>
+     <property name="editTriggers">
+      <set>QAbstractItemView::AllEditTriggers</set>
+     </property>
+     <property name="alternatingRowColors">
+      <bool>true</bool>
+     </property>
+     <property name="selectionMode">
+      <enum>QAbstractItemView::NoSelection</enum>
+     </property>
+     <property name="showGrid">
+      <bool>true</bool>
+     </property>
+     <attribute name="horizontalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <attribute name="horizontalHeaderDefaultSectionSize">
+      <number>50</number>
+     </attribute>
+     <attribute name="verticalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <column>
+      <property name="text">
+       <string>Nouvelle colonne</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>Valeur</string>
+      </property>
+     </column>
+    </widget>
+    <widget class="QLabel" name="label_18">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>2</y>
+       <width>221</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Attributs / caractéristiques :  </string>
+     </property>
+    </widget>
+    <widget class="QTableWidget" name="listeInventaireCombattant">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>30</y>
+       <width>291</width>
+       <height>131</height>
+      </rect>
+     </property>
+     <property name="palette">
+      <palette>
+       <active>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="150">
+           <red>255</red>
+           <green>255</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </active>
+       <inactive>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="150">
+           <red>255</red>
+           <green>255</green>
+           <blue>255</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </inactive>
+       <disabled>
+        <colorrole role="Base">
+         <brush brushstyle="SolidPattern">
+          <color alpha="255">
+           <red>240</red>
+           <green>240</green>
+           <blue>240</blue>
+          </color>
+         </brush>
+        </colorrole>
+       </disabled>
+      </palette>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::WinPanel</enum>
+     </property>
+     <property name="horizontalScrollBarPolicy">
+      <enum>Qt::ScrollBarAlwaysOff</enum>
+     </property>
+     <property name="editTriggers">
+      <set>QAbstractItemView::AllEditTriggers</set>
+     </property>
+     <property name="alternatingRowColors">
+      <bool>true</bool>
+     </property>
+     <property name="selectionMode">
+      <enum>QAbstractItemView::NoSelection</enum>
+     </property>
+     <property name="showGrid">
+      <bool>true</bool>
+     </property>
+     <attribute name="horizontalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <attribute name="horizontalHeaderDefaultSectionSize">
+      <number>50</number>
+     </attribute>
+     <attribute name="verticalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <column>
+      <property name="text">
+       <string>nombre</string>
+      </property>
+     </column>
+     <column>
+      <property name="text">
+       <string>objet</string>
+      </property>
+     </column>
+    </widget>
+    <widget class="QLabel" name="label_22">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>10</y>
+       <width>221</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Inventaire de base :</string>
+     </property>
+    </widget>
+    <widget class="QTextEdit" name="notesCombattant">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>200</y>
+       <width>291</width>
+       <height>91</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_23">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>180</y>
+       <width>46</width>
+       <height>13</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Notes :</string>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="ajouterInventaireCombattant">
+     <property name="geometry">
+      <rect>
+       <x>470</x>
+       <y>10</y>
+       <width>21</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normaloff>img/plus.png</normaloff>img/plus.png</iconset>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="supprimerInventaireCombattant">
+     <property name="geometry">
+      <rect>
+       <x>500</x>
+       <y>10</y>
+       <width>21</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normaloff>img/gomme.png</normaloff>img/gomme.png</iconset>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QWidget" name="tabAttaques">
+    <attribute name="title">
+     <string>Attaques</string>
+    </attribute>
+   </widget>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

lib/ui/editionCreature.ui

@@ -13,7 +13,7 @@
   <property name="windowTitle">
    <string>Dialog</string>
   </property>
-  <widget class="QLabel" name="affichageCouleurCreature">
+  <widget class="QLabel" name="affichageCouleurCombattant">
    <property name="geometry">
     <rect>
      <x>110</x>
@@ -71,7 +71,7 @@
     <string>Id : </string>
    </property>
   </widget>
-  <widget class="QLineEdit" name="imgLogoCreature">
+  <widget class="QLineEdit" name="imgLogoCombattant">
    <property name="geometry">
     <rect>
      <x>180</x>
@@ -81,7 +81,7 @@
     </rect>
    </property>
   </widget>
-  <widget class="QDoubleSpinBox" name="hauteurCreature">
+  <widget class="QDoubleSpinBox" name="hauteurCombattant">
    <property name="geometry">
     <rect>
      <x>560</x>
@@ -122,7 +122,7 @@
     <string>Taille (en cases) : </string>
    </property>
   </widget>
-  <widget class="QCheckBox" name="volCreature">
+  <widget class="QCheckBox" name="volCombattant">
    <property name="geometry">
     <rect>
      <x>560</x>
@@ -138,7 +138,7 @@
     <bool>false</bool>
    </property>
   </widget>
-  <widget class="QLineEdit" name="idCreature">
+  <widget class="QLineEdit" name="idCombattant">
    <property name="enabled">
     <bool>false</bool>
    </property>
@@ -151,7 +151,7 @@
     </rect>
    </property>
   </widget>
-  <widget class="QLineEdit" name="nomCreature">
+  <widget class="QLineEdit" name="nomCombattant">
    <property name="geometry">
     <rect>
      <x>122</x>
@@ -161,7 +161,7 @@
     </rect>
    </property>
   </widget>
-  <widget class="QDoubleSpinBox" name="deplacementCreature">
+  <widget class="QDoubleSpinBox" name="deplacementCombattant">
    <property name="geometry">
     <rect>
      <x>560</x>
@@ -231,7 +231,7 @@
     <string>Enregistrer</string>
    </property>
   </widget>
-  <widget class="QLineEdit" name="imgTextureCreature">
+  <widget class="QLineEdit" name="imgTextureCombattant">
    <property name="geometry">
     <rect>
      <x>180</x>
@@ -254,7 +254,7 @@
     <string>Nom : </string>
    </property>
   </widget>
-  <widget class="QPushButton" name="couleurCreature">
+  <widget class="QPushButton" name="couleurCombattant">
    <property name="geometry">
     <rect>
      <x>20</x>
@@ -324,7 +324,7 @@
      <property name="title">
       <string>Texte</string>
      </property>
-     <widget class="QCheckBox" name="txtAfficherCreature">
+     <widget class="QCheckBox" name="txtAfficherCombattant">
       <property name="geometry">
        <rect>
         <x>100</x>
@@ -340,7 +340,7 @@
        <bool>true</bool>
       </property>
      </widget>
-     <widget class="QSlider" name="txtPosYCreature">
+     <widget class="QSlider" name="txtPosYCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -385,7 +385,7 @@
        <string>Position (X)</string>
       </property>
      </widget>
-     <widget class="QSlider" name="txtTaillePoliceCreature">
+     <widget class="QSlider" name="txtTaillePoliceCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -407,7 +407,7 @@
        <enum>Qt::Horizontal</enum>
       </property>
      </widget>
-     <widget class="QSlider" name="txtRotationCreature">
+     <widget class="QSlider" name="txtRotationCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -439,7 +439,7 @@
        <string>Rotation</string>
       </property>
      </widget>
-     <widget class="QSlider" name="txtPosXCreature">
+     <widget class="QSlider" name="txtPosXCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -471,7 +471,7 @@
        <string>Position (Y)</string>
       </property>
      </widget>
-     <widget class="QPushButton" name="txtReinitCreature">
+     <widget class="QPushButton" name="txtReinitCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -484,7 +484,7 @@
        <string>Ré-initialiser</string>
       </property>
      </widget>
-     <widget class="QCheckBox" name="txtGrasCreature">
+     <widget class="QCheckBox" name="txtGrasCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -510,7 +510,7 @@
      <property name="title">
       <string>Image</string>
      </property>
-     <widget class="QCheckBox" name="imgAfficherCreature">
+     <widget class="QCheckBox" name="imgAfficherCombattant">
       <property name="geometry">
        <rect>
         <x>100</x>
@@ -526,7 +526,7 @@
        <bool>true</bool>
       </property>
      </widget>
-     <widget class="QSlider" name="imgPosYCreature">
+     <widget class="QSlider" name="imgPosYCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -584,7 +584,7 @@
        <string>Position (X)</string>
       </property>
      </widget>
-     <widget class="QSlider" name="imgTailleXCreature">
+     <widget class="QSlider" name="imgTailleXCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -603,7 +603,7 @@
        <enum>Qt::Horizontal</enum>
       </property>
      </widget>
-     <widget class="QSlider" name="imgRotationCreature">
+     <widget class="QSlider" name="imgRotationCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -635,7 +635,7 @@
        <string>Rotation</string>
       </property>
      </widget>
-     <widget class="QSlider" name="imgPosXCreature">
+     <widget class="QSlider" name="imgPosXCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -667,7 +667,7 @@
        <string>Position (Y)</string>
       </property>
      </widget>
-     <widget class="QSlider" name="imgTailleYCreature">
+     <widget class="QSlider" name="imgTailleYCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -686,7 +686,7 @@
        <enum>Qt::Horizontal</enum>
       </property>
      </widget>
-     <widget class="QPushButton" name="imgReinitCreature">
+     <widget class="QPushButton" name="imgReinitCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -699,7 +699,7 @@
        <string>Ré-initialiser</string>
       </property>
      </widget>
-     <widget class="QCheckBox" name="imgPivoteCreature">
+     <widget class="QCheckBox" name="imgPivoteCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -712,7 +712,7 @@
        <string>Image pivote</string>
       </property>
      </widget>
-     <widget class="QCheckBox" name="imgMasqueCreature">
+     <widget class="QCheckBox" name="imgMasqueCombattant">
       <property name="geometry">
        <rect>
         <x>10</x>
@@ -854,7 +854,7 @@
       <string>Attributs / caractéristiques :  </string>
      </property>
     </widget>
-    <widget class="QTableWidget" name="listeInventaireCreature">
+    <widget class="QTableWidget" name="listeInventaireCombattant">
      <property name="geometry">
       <rect>
        <x>230</x>
@@ -951,7 +951,7 @@
       <string>Inventaire de base :</string>
      </property>
     </widget>
-    <widget class="QTextEdit" name="notesCreature">
+    <widget class="QTextEdit" name="notesCombattant">
      <property name="geometry">
       <rect>
        <x>230</x>
@@ -974,7 +974,7 @@
       <string>Notes :</string>
      </property>
     </widget>
-    <widget class="QToolButton" name="ajouterInventaireCreature">
+    <widget class="QToolButton" name="ajouterInventaireCombattant">
      <property name="geometry">
       <rect>
        <x>470</x>
@@ -991,7 +991,7 @@
        <normaloff>img/plus.png</normaloff>img/plus.png</iconset>
      </property>
     </widget>
-    <widget class="QToolButton" name="supprimerInventaireCreature">
+    <widget class="QToolButton" name="supprimerInventaireCombattant">
      <property name="geometry">
       <rect>
        <x>500</x>