dmonde/lib/EcranGestionCombat.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from __future__ import division

from PyQt4.QtCore import *
from PyQt4.QtGui import *

from ui.ecran_gestionCombat import Ui_gc_fenetre
import regles
from lancer import jet, estJetValide


class EcranGestionCombat(QFrame):
    """interface de gestion du combat (MJ)"""
    def __init__(self, plateau, parent=None):
        """initialisation de la fenetre"""
        super (EcranGestionCombat, self).__init__()
        self.plateau = plateau
        self.colonnesBase = {}
        self.createWidgets()
        self.positionDansHistoJets = 0
        self.histoJets = [QString.fromUtf8("")]
        self.majEnCours = False
        
    def createWidgets(self):
        """construction de l'interface"""
        #construction de l'interface
        self.ui = Ui_gc_fenetre()
        self.ui.setupUi(self)

        self.majListesDeroulantes()
        self.ui.gc_jetDes.installEventFilter(self)
        #selection
        self.connect(self.ui.gc_selectionEnCours, SIGNAL("clicked()"), self.selection)
        self.connect(self.ui.gc_selectionAttaquant, SIGNAL("clicked()"), self.selection)
        self.connect(self.ui.gc_selectionDefenseur, SIGNAL("clicked()"), self.selection)
        #jet de des
        self.connect(self.ui.gc_jetDes, SIGNAL("returnPressed()"), self.jetDes)
##        self.connect(self.ui.jetDes, SIGNAL("keyPressEvent()"), self.jetDesToucheEnfoncee)
        self.connect(self.ui.gc_validerJetDes, SIGNAL("clicked()"), self.jetDes)
        self.connect(self.ui.gc_majChamp, SIGNAL("clicked()"), self.majChamp)
        self.connect(self.ui.gc_afficherDetailDes, SIGNAL("stateChanged(int)"), self.majAffichageDetailDes)
        
        #autre
        self.connect(self.ui.gc_liste.horizontalHeader(), SIGNAL("sectionClicked(int)"), self.enTeteCliquee)
        self.connect(self.ui.gc_aide, SIGNAL("clicked()"), self.afficherAide)
        self.connect(self.ui.gc_masquerHorsCombat, SIGNAL("stateChanged(int)"), self.majFiltreHorsCombat)
        
        self.initListe()
        self.majListe()
        
        self.connect(self.ui.gc_liste, SIGNAL("cellChanged(int, int)"), self.celluleModifiee)

    def majListesDeroulantes(self):
        """remplit les listes deroulantes des champs a mettre a jour"""
        self.ui.gc_nomChampMaj.addItem(QString.fromUtf8("Jet(s) de des"), "D")
        self.ui.gc_nomChampSourceMaj.addItem(QString.fromUtf8("Jet(s) de des"), "D")
        for elt in regles.ordreAttributs():
            if regles.listeControle()[elt].typ == "entier":
                self.ui.gc_nomChampMaj.addItem(QString.fromUtf8(regles.listeControle()[elt].nom), regles.ordreAttributs().index(elt))
                self.ui.gc_nomChampSourceMaj.addItem(QString.fromUtf8(regles.listeControle()[elt].nom), regles.ordreAttributs().index(elt))
        self.ui.gc_nomChampMaj.setCurrentIndex(1)

    def enTeteCliquee(self, colonne):
        """clic sur l'en-tete de la colonne"""
        if colonne >= 20:    #ne s'applique pas aux colonnes de base (a part Des)
            attribut = regles.ordreAttributs()[(colonne-20)]
            index = self.ui.gc_nomChampMaj.findData((colonne-20))
            if index >= 0:
                self.ui.gc_nomChampMaj.setCurrentIndex(index)
        elif colonne == self.colonnesBase.index("Des"):
            self.ui.gc_nomChampMaj.setCurrentIndex(0)      

    def initListe(self):
        """formate la table des donnees"""
        #mise en forme des colonnes
        #le dico des colonnes de base (celles qui ne dependent pas des regles utilisees) contient:
        #nom, largeur, (est modifiable?)
        self.ui.gc_liste.setEditTriggers(QAbstractItemView.DoubleClicked)
        self.ui.gc_liste.setIconSize(QSize(20,20))
        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)
            self.ui.gc_liste.setColumnHidden(i, (i >= len(self.colonnesBase)))
            if i < len(self.colonnesBase):
                self.ui.gc_liste.setHorizontalHeaderItem(i, QTableWidgetItem(self.colonnesBase[i]))
                if self.colonnesBase[i] in largeurColonnesBase:
                    largeur = largeurColonnesBase[self.colonnesBase[i]]
                else:
                    largeur = 60
                if largeur > 0:    
                    self.ui.gc_liste.setColumnWidth(i, largeur)
                else:    
                    self.ui.gc_liste.setColumnHidden(i, True)
        self.majAffichageDetailDes()            

        ordre = regles.ordreAttributs()
        for elt in ordre:
            numCol = 20 + ordre.index(elt)
            self.ui.gc_liste.insertColumn(numCol)
            self.ui.gc_liste.setHorizontalHeaderItem(numCol, QTableWidgetItem(QString.fromUtf8(elt)))
            self.ui.gc_liste.setColumnWidth(numCol, 45)
            self.ui.gc_liste.setColumnHidden(numCol, False)
            if elt == regles.attributOrdreJeu():
                self.ui.gc_liste.setColumnHidden(self.colonnesBase.index("Ordre"), True)   #si un attribut sert a definir l'ordre, on cache la colonne ordre de jeu

            
    def majListe(self):
        """met a jour le contenu de la table des donnees"""
        self.majEnCours = True
        while self.ui.gc_liste.rowCount() > 0:
            self.ui.gc_liste.removeRow(0)
        index = 0

        for num in self.plateau.combattants:
            self.ui.gc_liste.insertRow(int(index))
            #num du combattant (0):
            self.ui.gc_liste.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(str(num))))
            self.majDonneesCombattant(num)
            index += 1

        for elt in regles.ordreAttributs():    
            if elt == regles.attributOrdreJeu():
                self.plateau.majOrdreJeu()
                self.majTri()
                     
        self.majEnCours = False

    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()) == numCombattant:
                index = i
                break
            
        if index != None:
            ### parametres de base
            #I - Indication sur le combattant (attaquant, defenseur, selectionne sur la plateau...etc)
            item = QTableWidgetItem()
            item.setFlags(Qt.NoItemFlags)
            item.setFlags(Qt.ItemIsSelectable)
            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)
            
            #Des et DetailDes - jets de des, on laisse tel quel
            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Des"), QTableWidgetItem(QString.fromUtf8("")))
            self.ui.gc_liste.setItem(index, self.colonnesBase.index("DetailDes"), QTableWidgetItem(QString.fromUtf8("")))
                                    
            #Icone et nom
            item = QTableWidgetItem(QIcon("img\\"+self.plateau.combattants[numCombattant].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[numCombattant]))))

            #Etat
            #...

            #altitude
            self.ui.gc_liste.setItem(index, self.colonnesBase.index("Alt."), QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].zR))))

            ### parametres supplementaires (issus des regles)
            for elt in self.plateau.combattants[numCombattant].listeAttributs:
                col = 20 + regles.ordreAttributs().index(elt)
                self.ui.gc_liste.setItem(index, col , QTableWidgetItem(QString.fromUtf8(str(self.plateau.combattants[numCombattant].listeAttributs[elt]))))
        else:
            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:
            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.combattantDeplacerDansOrdreJeu(numCombattant, nouvellePosition)
                    self.majListe()
                    
                elif colonne == self.colonnesBase.index("Des"):
                    #jet de de
                    self.majEnCours = True
                    if len(str(self.ui.gc_liste.item(ligne, colonne).text().toUtf8())) > 0:
                        resultat = jet(str(self.ui.gc_liste.item(ligne, colonne).text().toUtf8()))[0]
                        self.ui.gc_liste.item(ligne, colonne).setText(QString.fromUtf8(str(resultat)))
                    else:
                        self.ui.gc_liste.item(ligne, colonne).setText(QString.fromUtf8(""))   
                    self.majEnCours = False

            elif colonne >= 20:
                self.majEnCours = True
                index = colonne - 20
                attribut = regles.ordreAttributs()[index]
                valeurAttribut = regles.listeControle()[attribut].controler(str(self.ui.gc_liste.item(ligne, colonne).text().toUtf8()))
                if valeurAttribut != None:
                    self.plateau.combattants[numCombattant].listeAttributs[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.combattants[numCombattant].listeAttributs[attribut])))
                self.majEnCours = False
                
            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()))])))

    def jetDes(self):
        """jette les des en fonction de ce qui est tape dans jetDes, et affecte les resultats a la colonne D des lignes selectionnees"""
        jetCommun = None
        
        for i in range(0, self.ui.gc_liste.rowCount()):
            self.ui.gc_liste.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(""))
        if estJetValide(str(self.ui.gc_jetDes.text().toUtf8())):    
            if not self.ui.gc_jetDesIndependants.isChecked() and len(str(self.ui.gc_jetDes.text().toUtf8())) > 0:
                jetCommun = jet(str(self.ui.gc_jetDes.text().toUtf8()))
                
            for i in range(0, self.ui.gc_liste.rowCount()):
                self.ui.gc_liste.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(""))
                if len(str(self.ui.gc_jetDes.text().toUtf8())) > 0:
                    if self.ui.gc_liste.isItemSelected(self.ui.gc_liste.item(i, 0)):
                        if not jetCommun == None:
                            resultat = jetCommun
                        else:    
                            resultat = jet(str(self.ui.gc_jetDes.text().toUtf8()))
                        if resultat[0] != None:    
                            self.ui.gc_liste.item(i, self.colonnesBase.index("Des")).setText(QString.fromUtf8(str(resultat[0])))
                            self.ui.gc_liste.item(i, self.colonnesBase.index("DetailDes")).setText(QString.fromUtf8(str(resultat[1])))
            self.histoJets.insert(1, self.ui.gc_jetDes.text().toUtf8())
        else:
            print "Jet de des invalide"
        self.positionDansHistoJets = 0    
        self.ui.gc_jetDes.setText(QString.fromUtf8(""))

    def afficherJetHisto(self):
        """affiche le jet depuis l'historique dans la qlineedit dediee"""
        if len(self.histoJets) > 0:
            if self.positionDansHistoJets < 0:
                self.positionDansHistoJets = 0
            elif self.positionDansHistoJets >= len(self.histoJets):
                self.positionDansHistoJets = len(self.histoJets) - 1 
            self.ui.gc_jetDes.setText(QString.fromUtf8(self.histoJets[self.positionDansHistoJets]))
            
    def selection(self):
        """selectionne les lignes demandees"""
        origine = str(self.sender().objectName())
        for i in range(0, self.ui.gc_liste.rowCount()):
            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":
                pass
            if self.ui.gc_liste.item(i, 0).isSelected():
                self.ui.gc_liste.setCurrentCell(i, 0)
                
    def majChamp(self):
        """met a jour le champ demande avec les resultats de des ou avec les valeurs du champ specifie"""
        self.majEnCours = True
        aMaj = []   #liste des numCombattants a mettre a jour
        cible = str(self.ui.gc_nomChampMaj.itemData(self.ui.gc_nomChampMaj.currentIndex()).toString())
        
        if cible == "D":
            colonne = self.colonnesBase.index("Des")
        else:
            colonne = 20 + int(cible)

        source = str(self.ui.gc_nomChampSourceMaj.itemData(self.ui.gc_nomChampSourceMaj.currentIndex()).toString())
        if source != "D" and not len(self.ui.gc_liste.selectedItems()) > 0:
            msgBox = QMessageBox()
            msgBox.setWindowTitle(QString.fromUtf8("Avertissement"))
            msgBox.setText(QString.fromUtf8("Aucune ligne n'est sélectionnée"))
            msgBox.exec_()
        else:
            for i in range(0, self.ui.gc_liste.rowCount()):
                if len(str(self.ui.gc_liste.item(i, self.colonnesBase.index("Des")).text().toUtf8())) > 0:
                    valeur = int(self.ui.gc_liste.item(i, colonne).text().toUtf8())
                    jet = None
                    try:
                        if source == "D" and cible != "D":
                            jet = int(str(self.ui.gc_liste.item(i, self.colonnesBase.index("Des")).text().toUtf8()))
                        elif source != cible:
                            if self.ui.gc_liste.item(i, 0).isSelected():
                                jet = int(str(self.ui.gc_liste.item(i, (20 + int(source))).text().toUtf8()))
                    except:
                        print("jet invalide")
                        
                    if jet != None:    
                        if self.ui.gc_majValeurAjouter.isChecked():
                            valeur += jet
                        elif self.ui.gc_majValeurRetirer.isChecked():
                            valeur -= jet      
                        elif self.ui.gc_majValeurRemplacer.isChecked():
                            valeur = jet
                        aMaj.append(i)
                        self.ui.gc_liste.item(i, colonne).setText(QString.fromUtf8(str(valeur)))    
            self.majEnCours = False
            
            for ligne in aMaj:
                self.celluleModifiee(ligne, colonne)
            self.ui.gc_nomChampSourceMaj.setCurrentIndex(0)
        
    def afficherAide(self):
        pass

    def majFiltreHorsCombat(self):
        pass

    def majAffichageDetailDes(self):
        """affiche ou cache la colonne de detail des jets de des en fonction de l'etat de la case correspondante"""
        self.ui.gc_liste.setColumnHidden(self.colonnesBase.index("DetailDes"), (not self.ui.gc_afficherDetailDes.isChecked()))

    def eventFilter(self, item, event):
        """filtre les evenements sur les widgets"""
        retour = False
        if item == self.ui.gc_jetDes:
            if event.type() == QEvent.KeyPress:
                if event.key() == Qt.Key_Up:
                    self.positionDansHistoJets += 1
                    self.afficherJetHisto()
                    retour = True
                elif event.key() == Qt.Key_Down:
                    self.positionDansHistoJets -= 1
                    self.afficherJetHisto()
                    retour = True
        return retour