dmonde/lib/Partie.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""partie de DMonde, caracterisee par un groupe de joueurs, des personnages, 
un MJ (interchangeable), une carte du monde, un journal de quêtes
une liste de plateaux, et un ensemble de règles"""
import os
from time import time

from PyQt4.QtCore import SIGNAL, Qt, QString
from PyQt4.QtGui import QGraphicsView, QWidget, QFrame

from lib.Combattant import PJ
from lib.EcranChargerPlateau import EcranChargerPlateau
from lib.EcranCreerPlateau import EcranCreerPlateau
from lib.EcranEditionMateriel import EcranEditionMateriel
from lib.Plateau import Plateau
from lib.commun import uid, rep, sessionEnCours
from lib.framePj import FramePj
from lib.mat import chargerMat, supprimerMat, Materiel
from lib.outilsSvg import afficheSvg, enregistrer, chargerUnique, supprSvg


class Partie(Materiel):
    def __init__(self):
        super(Partie, self).__init__()
        self._type = "pt"
        self._repCible = "parties"
        self._nom = "Partie"
        self.dateMaj = ""  #date de la derniere mise a jour
        
        self.prog = None
#         self.nom = "Partie"
        self.j = []  #liste des joueurs
        self.mj = ""  #idPr du profil associe (utile?)

        self.idRg = None    #id des regles utilisees

        self.pjs = []          #liste de Combattant()
        self._plEc = None   #plateau en cours
        
        self._ch = {1: Chapitre(1)}   #liste des chapitres (num: Chapitre)
        self._chEC = 1                  #chapitre en cours

#         self.carteMonde = CarteMonde()
#         self.journal = Journal()

    def __getstate__(self):
        self.dateMaj = time()
        state = {key:value for key, value in self.__dict__.items() if not key in ["prog"]}
        return (state)

    def __setstate__(self, state):
        self.__dict__ = state
        super(Partie, self).__init__()

    def nom(self):
        return self._nom
    
    def majNom(self, nom):
        if len(nom) > 0: self._nom = nom

    def afficher(self, prog):
        """on affiche la partie"""
        self.prog = prog
        self.prog.connect(self.prog.ui.pt_enregistrer, SIGNAL("clicked()"), self.enregistrer) 

        self.prog.connect(self.prog.ui.cbt_enCours, SIGNAL("clicked()"), self.chargerDernierPlateau)   
        self.prog.connect(self.prog.ui.cbt_charger, SIGNAL("clicked()"), self.afficherEcranChargerPlateau)   
        self.prog.connect(self.prog.ui.cbt_creer, SIGNAL("clicked()"), self.nouveauPlateau)   
        self.prog.connect(self.prog.ui.cbt_sauver, SIGNAL("clicked()"), self.enregistrerPlateau)   
        self.prog.connect(self.prog.ui.cbt_fermer, SIGNAL("clicked()"), self.fermerPlateau)
        if len(afficheSvg(os.path.join(rep("cbt"), "infos_sauvegarde"))) == 0:
            self.prog.ui.cbt_enCours.setEnabled(False)
        
        self.afficherPlateau(False)
        self.prog.ui.cbt_vue.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
        self.prog.ui.cp_ongletsListes.setStyleSheet("QTabBar::tab { width: 41px; }")
        self.prog.ui.pi_ongletsListes.setStyleSheet("QTabBar::tab { width: 38px; }")
        
        self.prog.connect(self.prog.ui.grp_nouveauPj, SIGNAL("clicked()"), self.nouveauPj)
        self.chargerListePj() 
        
        self.majAffichage()

    def creer(self):
        self.idP = uid("pr")

    def fermer(self):
        pass
    
    def enregistrer(self):
        super(Partie, self).enregistrer()

    def majAffichage(self):
        """met a jour l'interface avec les informations de la partie"""
        self.prog.ui.pt_nom.majTexte("Partie: {}".format(self._nom) )
        self.prog.ui.pt_chap.majTexte("{}".format(self._ch[self._chEC].nomLong()) )
        self.prog.ui.pt_presentation.majTexte("{}".format(self._ch[self._chEC].presentation) )
        self.enregistrer()

    ##### chapitres

    def chapitres(self):
        return self._ch

    def majChapitres(self, dico):
        self._ch = dico

    def chapitreEnCours(self):
        return self._chEC 
    
    def majChapitreEnCours(self, num):
        if num in self._ch: self._chEC = num

    ##### groupe ########"
    
    def chargerListePj(self):
        for attributsFichier in os.walk(rep("grp")):
            for f in attributsFichier[2]:
                pj = chargerMat(os.path.join(attributsFichier[0], f))
                self.pjAjouterAListe(pj)
        self.prog.ui.grp_deroulement_layout.setAlignment(Qt.AlignTop)

    def pjAjouterAListe(self, pj = None):
        compteur = len(self.pjs)
        colonne = (compteur % 3) * 2
        ligne = int(compteur / 3)
        self.pjs.append(pj.idM())
        panneau = FramePj(compteur)
        if pj:
            panneau.chargerPj(pj)
        panneau.setObjectName(QString("pj_panneau_{}".format(compteur)))
        self.prog.connect(panneau, SIGNAL("pjModifie(int)"), self.pjEnregistrer)
        self.prog.ui.grp_deroulement_layout.addWidget(panneau, ligne, colonne)

        ## pour l'espacement entre les panneaux
        w = QWidget()
        self.prog.ui.grp_deroulement_layout.addWidget(w, ligne, colonne + 1)

    def pjSupprimer(self, index):
        panneau = self.prog.findChild(QFrame, "pj_panneau_{}".format(index))
        pj = panneau.pj()
        supprimerMat(pj.idM(), "grp")
        self.ui.grp_deroulement_layout.removeWidget(panneau)

    def nouveauPj(self):
        fen = EcranEditionMateriel(PJ())
        fen.afficher()
        fen.exec_()
        pj = fen.mat()
        del fen
        pj.enregistrer("grp")
        self.pjAjouterAListe(pj)

    def pjEnregistrer(self, idPj):
        panneau = self.prog.findChild(QFrame, "pj_panneau_{}".format(idPj))
        pj = panneau.pj()
        pj.enregistrer("grp")

    ####### plateaux ##########
    def nouveauPlateau(self):
        """ouvre la fenetre de creation de plateau"""
        if self._plEc != None: return
        fenCP = EcranCreerPlateau()
        fenCP.afficher( Plateau(self.prog) )
        r = fenCP.exec_()
        if r == 1:
            self._plEc = fenCP.resultat()
            self._plEc.creer()
            self.afficherPlateau(True)
        del fenCP
        
        
    def afficherEcranChargerPlateau(self):
        """ouvre la fenetre de chargement de plateau"""
        if self._plEc != None: return
        fen = EcranChargerPlateau(self)
        fen.show()
        r = fen.exec_()
        if r == 1:
            idM = fen.resultat()
            self.chargerPlateau(idM)
        del fen
     
    def chargerDernierPlateau(self):
        """charge le dernier plateau sauvegarde"""
        infosSvg = afficheSvg(os.path.join(rep("cbt"), "infos_sauvegarde"))
        dates = {val["dateSvg"]:key for key, val in infosSvg.items()}
        if len(dates) == 0: return
        dernier = dates[max( dates.keys() )]
        if dernier:
            self.chargerPlateau(dernier)
        
    def chargerPlateau(self, idM):
        if self._plEc: return
        self._plEc = chargerMat(idM, "cbt")
        self._plEc.recreer(self.prog)  
        self.afficherPlateau(True) 

    def enregistrerPlateau(self):
        self._plEc.enregistrer("cbt")
        infos = {"nom": self._plEc.nom(), "chapitre": self._plEc.chapitre, "dateCreation":self._plEc.dateCreation, "dateSvg":self._plEc.dateSvg, \
                 "public": self._plEc.public, "enCours": self._plEc.enCours}
        enregistrer(self._plEc.idM(), infos, os.path.join(rep("cbt"), "infos_sauvegarde"))
    
    def fermerPlateau(self):
        self._plEc.fermer()
        self._plEc = None
        self.afficherPlateau(False) 

    def majFichierInfosSvg(self):
        """construit/maj le fichier contenant la liste des
           plateaux sauvegardes et leurs informations"""
        #on parcourt les fichiers de sauvegarde
        f = []
        lstFichiersSvg = []
        for (dirpath, dirnames, filenames) in os.walk(rep("cbt")):
            f.extend(filenames)
            break
        for fichier in f:
            fileName, fileExtension = os.path.splitext(fichier)
            if fileExtension == ".dm":
                lstFichiersSvg.append(fileName)

        #on verifie leur presence dans le fichier 'infos_sauvegarde'
        infosSvg = afficheSvg(os.path.join(rep("cbt"), "infos_sauvegarde"))
        index = len(infosSvg)

        #on ajoute les sauvegardes manquantes si besoin
        for fichier in lstFichiersSvg:
            if not fichier in infosSvg:
                plateau = chargerUnique(os.path.join(rep("cbt"), "{}.dm".format(fichier)))
                enregistrer(fichier, {"nom": plateau.nom(), "chapitre": plateau.chapitre, "dateCreation":plateau.dateCreation, "dateSvg":plateau.dateSvg, \
                                      "public": plateau.public, "enCours": plateau.enCours}, "svg\\infos_sauvegarde")
                index += 1     
                  
        #on supprime ceux qui ne sont plus trouves
        for fichier in infosSvg:
            if not fichier in lstFichiersSvg:
                supprSvg(os.path.join(rep("cbt"), "infos_sauvegarde"), fichier)            


    def afficherPlateau(self, actif):
        index = int(actif)   # 0 si faux, 1 si vrai
        self.prog.ui.combatPanneau.setCurrentIndex(index)
#         self.prog.ui.cbt_panneauBas.setCurrentIndex(index)
#         self.prog.ui.cbt_panneauHaut.setCurrentIndex(index)
#         self.prog.ui.cbt_panneauDroite.setCurrentIndex(index)
#         self.prog.ui.cbt_panneauGauche.setCurrentIndex(index)
#         self.prog.ui.cbt_etapeSuivante.setVisible(actif)


class Chapitre():
    def __init__(self, numero, nom = "", presentation = "", public = False):
        self.num = numero
        self.nom = nom
        self.presentation = ""
        self.public = public
        
    def nomLong(self):
        if len(self.nom) > 0:
            return "Ch. {} - {}".format(self.num, self.nom) 
        else:
            return "Chapitre {}".format(self.num)