dmonde/lib/Modes.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""les modes d'interaction permettent l'interaction
entre l'interface (l'utilisateur) et le plateau de combat.
Un seul mode ne peut etre actif a la fois
Cette classe doit permettre de recevoir les commandes de l'utilisateur
de maniere a produire un resultat unique (cases peintes, pion deplace...)"""
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from EntreeSortie import EntreeSortie
import regles

class ModeBase(object):
    """mode de base: tous les modes heritent de cette classe"""
    def __init__(self, plateau):
        self.plateau = plateau
        #le mode est il active
        self._actif = False
        #le dragmode est il active sur la QGraphicsView
        self._activerDragMode = 0
        #curseur de la QGraphicsView
        self._sourceCurseur = ""
        #met le focus sur la QGraphicsView a l'activation
        self._focus = False 

    def nom(self):
        return self.__class__.__name__

    def activer(self, param = None):
        """active le mode"""
        self.activerCurseur()
        if self._focus:
            self.plateau.fenetre.ui.cbt_vue.setFocus()
        self._actif = True    

    def desactiver(self):
        """desactive le mode"""
        self.desactiverCurseur()
        self.plateau.fenetre.ui.cbt_vue.setDragMode(1)
        self._actif = False

    def reinit(self):
        """remet les variables a 0 et reactive le mode"""
        pass

    def activerCurseur(self):
        self.plateau.fenetre.ui.cbt_vue.setDragMode(self._activerDragMode)
        curseurPix = QPixmap(self._sourceCurseur)
        if not curseurPix.isNull():
            curseurPinceau = QCursor(curseurPix, 0, curseurPix.height())
            self.plateau.fenetre.ui.cbt_vue.setCursor(curseurPinceau)   

    def desactiverCurseur(self):
        self.plateau.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))

    ### gestion des evenements souris
    # clic gauche
    def clic_combattant(self, num):
        pass

    def clic_decor(self, num):
        pass

    def clic_case(self, coord):
        pass

    #double clic gauche
    def doubleClic_combattant(self, num):
        pass

    def doubleClic_decor(self, num):
        pass

    def doubleClic_case(self, coord):
        pass

    #survol de la souris (entree)   
    def survol_combattant(self, num):
        pass

    def survol_decor(self, num):
        pass

    def survol_case(self, coord):
        pass

    #survol de la souris (sortie)  
    def finSurvol_combattant(self, num):
        pass

    def finSurvol_decor(self, num):
        pass

    def finSurvol_case(self, coord):
        pass

    #survol de la souris avec clic gauche enfonce (entree)   
    def survolClic_combattant(self, event):
        pass

    def survolClic_decor(self, event):
        pass

    def survolClic_case(self, coord):
        pass

    #autre
    def clicGauche(self, event):
        pass

    def finClicGauche(self, event):
        pass
    
    def mouvementSouris(self, event):
        pass
    
    def toucheClavier(self, event):
        pass

    def clicDroit(self, event):
        pass


class ModeBaseCp(ModeBase):
    """mode servant de base a tous les modes lies a la creation de plateau"""
    def __init__(self, plateau):
        super(ModeBaseCp, self).__init__(plateau)
        self.type = "cp"

    def clicDroit(self, event):
        self.plateau.activerMode(Modes.StandardCp)


class ModeBasePi(ModeBase):
    """mode servant de base a tous les modes lies aux actions des combattants"""
    def __init__(self, plateau):
        super(ModeBasePi, self).__init__(plateau)
        self.type = "pi"

    def clicDroit(self, event):
        self.plateau.activerMode(Modes.StandardPi)

### --------------------------------------- ####


class StandardCp(ModeBaseCp):
    """mode standard en creation de plateau"""
    def __init__(self, plateau):
        super(StandardCp, self).__init__(plateau)
        self._sourceCurseur = ""
        self._focus = False
        self._activerDragMode = True

    def clic_pion(self, num):
        pass
        #doit selectionner le pion

class MajCases(ModeBaseCp):
    """mode de mise a jour des cases (terrain, couleur, effet special)"""
    def __init__(self, plateau):
        super(MajCases, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True
        self._param = None   #parametre avec lequel on mettra a jour la case

    def activer(self, param):
        """active le mode"""
        self.majParam(param)
        super(MajCases, self).activer()

    def desactiver(self):
        """desactive le mode"""
        self.plateau.pinceau.reinit()
        super(MajCases, self).desactiver()

    def majParam(self, param):
        self._param = param

    def param(self):
        return self._param

    def clic_case(self, coord):
        #demarre une operation de peinture des cases
        self.plateau.pinceau.demarrer(coord)

    def survolClic_case(self, coord):
        self.plateau.pinceau.maj(coord)

    def finClicGauche(self, event):
        if self.plateau.pinceau.estActif():
            for coord in self.plateau.pinceau.selection():
                if self._param.__class__.__name__ == "Terrain":
                    self.plateau.cases[coord].majTerrain(self._param)
                elif self._param.__class__.__name__ == "QColor":
                    if self._param.isValid():
                         self.plateau.cases[coord].majTerrain(None)
                         self.plateau.cases[coord].majCouleur(self._param)
                elif self._param.__class__.__name__ == "EffetCase":
                    self.plateau.cases[coord].majEffet(self._param)
                self.plateau.pinceau.reinit()
            self.reinit()

    def toucheClavier(self, event):
        if event.key() == Qt.Key_Up:
            self.plateau.fenetre.ui.epaisseurPinceau.setValue(self.plateau.fenetre.ui.epaisseurPinceau.value()+1)
        elif event.key() == Qt.Key_Down:
            self.plateau.fenetre.ui.epaisseurPinceau.setValue(self.plateau.fenetre.ui.epaisseurPinceau.value()-1)

class Pipette(ModeBaseCp):
    """mode pipette: on preleve la couleur ou le terrain d'une case"""
    def __init__(self, plateau):
        super(Pipette, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurSeringue.png"

    def activerCurseur(self):
        super(Pipette, self).activerCurseur()
        
    def clic_case(self, coord):
        if len(self.plateau.cases[coord].terrain.nom) > 0:
             param = self.plateau.cases[coord].terrain
        else:
             param = self.plateau.cases[coord].couleur
        self.plateau.activerMode(MajCases, param)     
             

class ZonePlacement(ModeBaseCp):
    """mode de definition de la/les zones de placement des joueurs"""
    def __init__(self, plateau):
        super(ZonePlacement, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True

    def activerCurseur(self):
        super(ZonePlacement, self).activerCurseur()

    def activer(self, param = None):
        self.plateau.pinceau.majForme("rectP")
        self.plateau.pinceau.verrouillerForme(True)
        super(ZonePlacement, self).activer()

    def desactiver(self):
        self.plateau.pinceau.reinit()
        super(ZonePlacement, self).desactiver()

    def clic_case(self, coord):
        #demarre une operation de peinture des cases
        self.plateau.pinceau.demarrer(coord)
        
    def survolClic_case(self, coord):
        self.plateau.pinceau.maj(coord)
    
    def finClicGauche(self, coord):
        if self.plateau.pinceau.estActif():
            if len(self.plateau.pinceau.selection()) > 0:
                self.plateau.majZonePlacement(self.plateau.pinceau.selection())
                

class EntreesSorties(ModeBaseCp):
    """mode de definition deentrees et sorties du plateau"""
    def __init__(self, plateau):
        super(EntreesSorties, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True

    def activerCurseur(self):
        super(EntreesSorties, self).activerCurseur()

    def activer(self, param):
        self.es = param
        self.es.creerForme()
        super(EntreesSorties, self).activer()

    def desactiver(self):
        if not self.es.estPositionne:
            self.es.prepareGeometryChange()
            self.es.plateau = None
            self.plateau.removeItem(self.es)
        super(EntreesSorties, self).desactiver()
        
    def mouvementSouris(self, event):
        if event.buttons() != Qt.LeftButton:
            if not self.es.estPositionne:
                self.es.majProjection(event.scenePos())

    def clicGauche(self, event):
        if not event.isAccepted():
            self.es.positionner()
            self.plateau.entreesSorties.append(self.es)
            self.desactiver()

    def toucheClavier(self, event):
        if event.key() == Qt.Key_Delete:
            #supprimer l'es
            self.desactiver()
        elif event.key() == Qt.Key_Right:
            self.es.nbRotations += 1
            self.es.majProjection()   
        elif event.key() == Qt.Key_Left:
            self.es.nbRotations -= 1
            self.es.majProjection()    


class CreationPion(ModeBaseCp):
    """mode de creation de pions (combattant ou decor)"""
    def __init__(self, plateau):
        super(CreationPion, self).__init__(plateau)
        self._focus = True
        self._pion = None

    def activer(self, pion):
        self._pion = pion
        self.plateau.proj.creer(self._pion)
        super(CreationPion, self).activer()
        
    def desactiver(self):
        self.plateau.proj.desactiver()
        self._pion = None
        super(CreationPion, self).desactiver()

    def survol_case(self, coord):
        if self._pion:
            self.plateau.proj.majCoord(coord)

    def clic_case(self, coord):
        if self._pion:
            self.plateau.creerPion(self._pion)

    def toucheClavier(self, event):
        if self._pion:
            if event.key() == Qt.Key_Right:
                self.plateau.proj.majRotation(1)
            elif event.key() == Qt.Key_Left:
                self.plateau.proj.majRotation(-1)


class SuppressionPion(ModeBaseCp):
    """mode de suppression de pions (combattant ou decor)"""
    def __init__(self, plateau):
        super(SuppressionPion, self).__init__(plateau)
        self._sourceCurseur = "img\\gomme.png"
        self._focus = True

    def clicGauche(self, event):
        """supprime le pion sous le clic. S'il y en a plusieurs,
            supprime le premier de la pile"""
        item = self.plateau.itemAt(event.scenePos())
        
        if item.parentItem().__class__.__name__ in ["Combattant", "Decor"]:
            self.plateau.pionSupprimer(item.parentItem().numero)
            

class DeplacementPion(ModeBaseCp):
    """mode de deplacement de pions (combattant ou decor) en mode creation
        attention: different des actions de type deplacement qu'effectuent les pions en mode Combat"""
    def __init__(self, plateau):
        super(DeplacementPion, self).__init__(plateau)
        self._num = 0
        
    def activer(self, num):
        self._num = num
        if self._num < 10000:
            pion = self.plateau.combattants[self._num]
        else:
            pion = self.plateau.decors[self._num]
        self.plateau.proj.creer(pion)
        self.deplace = False
        super(DeplacementPion, self).activer()

    def desactiver(self):
        self.plateau.proj.desactiver()
        self._num = 0
        super(DeplacementPion, self).desactiver()

    def survol_case(self, coord):
        if self._num > 0:
            self.plateau.proj.majCoord(coord)
            self.deplace = True

    def clic_case(self, coord):
        if self._num > 0:
            if self.deplace:
                if self._num < 10000:
                    pion = self.plateau.combattants[self._num]
                else:
                    pion = self.plateau.decors[self._num]
                pion.majPosition(self.plateau.proj.coord(), self.plateau.proj.nbRotations())

    def toucheClavier(self, event):
        if self._num > 0:
            if event.key() == Qt.Key_Right:
                self.plateau.proj.majRotation(1)
                self.deplace = True
            elif event.key() == Qt.Key_Left:
                self.plateau.proj.majRotation(-1)
                self.deplace = True


#-----------------------------------------------
#-----------------------------------------------

class StandardPi(ModeBasePi):
    """mode standard de la manipulation de pion en combat"""
    def __init__(self, plateau):
        super(StandardPi, self).__init__(plateau)
        self._focus = False
        self._activerDragMode = True

    def clic_combattant(self, num):
        self.plateau.activerMode(PionSelectionne, num)


class PionSelectionne(ModeBasePi):
    """mode active a la selection d'un pion combattant"""
    def __init__(self, plateau):
        super(PionSelectionne, self).__init__(plateau)
        self._focus = True
        self._num = None

    def pion(self):
        """retourne la ref du pion actuellement selectionne"""
        return self.plateau.combattants[self._num]

    def activer(self, num):
        self._num = num
        #intensifie l'ombre du pion
        self.pion().afficheOmbreSelection(True)
        
        ### maj la selection dans la liste d'ordre de jeu
        for i in range(0, self.plateau.fenetre.ui.inf_listeOrdreJeu.rowCount()):
            if str(self.plateau.fenetre.ui.inf_listeOrdreJeu.item(i, 0).text().toUtf8()) == str(self._num):
                self.plateau.fenetre.ui.inf_listeOrdreJeu.setCurrentCell(i,0)

        ### maj des infos dans le panneau pi
        self.plateau.fenetre.ui.pi_nom.setText(QString.fromUtf8(self.pion().txtId()))
        if len(self.pion().img.nomFichier) > 0:
            pix = QPixmap(QString.fromUtf8("img\\"+self.pion().img.nomFichier))
            pix = pix.scaled(44, 44, Qt.KeepAspectRatio, Qt.SmoothTransformation)
        else:
            pix = QPixmap()
        self.plateau.fenetre.ui.pi_img.setPixmap(QPixmap())    

        ### maj de la liste des attributs
        self.plateau.fenetre.ui.pi_listeAttributs.setColumnWidth(0, 50)
        self.plateau.disconnect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.plateau.listeAttributCelluleModifiee)
        
        #on vide la liste
        while self.plateau.fenetre.ui.pi_listeAttributs.rowCount() > 0:
            self.plateau.fenetre.ui.pi_listeAttributs.removeRow(0)

        #creation des lignes de base    
        lignesBase = ["Nom","Etat","Alt."]   #attention: modifier aussi dans listeAttributCelluleModifiee
        for i in range(0, 10):    #10 premieres colonnes reservees pour les infos de base
            self.plateau.fenetre.ui.pi_listeAttributs.insertRow(i)
            item = QTableWidgetItem()
            if i < len(lignesBase):
                item.setText(QString.fromUtf8(lignesBase[i]))
            item.setFlags(Qt.NoItemFlags)    
            self.plateau.fenetre.ui.pi_listeAttributs.setItem(i, 0, item)
            self.plateau.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase)))

        #maj des donnees de base    
        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().nom))))
        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().etat))))
        self.plateau.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().z))))
        
        #attributs issus des regles utilisees    
        ordre = regles.ordreAttributs()
        for elt in ordre:
            ligne = 10 + ordre.index(elt)
            self.plateau.fenetre.ui.pi_listeAttributs.insertRow(ligne)
            item = QTableWidgetItem(QString.fromUtf8(elt))
            item.setFlags(Qt.NoItemFlags)
            self.plateau.fenetre.ui.pi_listeAttributs.setItem(ligne, 0, item)
            self.plateau.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pion().listeAttributs[elt]))))
            
        self.plateau.connect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.plateau.listeAttributCelluleModifiee)


        ###affiche les notes du combattant
        self.plateau.fenetre.ui.pi_notes.setText(QString.fromUtf8(self.pion().notes))


        ###maj la liste des attaques du pion
        #on vide la liste
        while self.plateau.fenetre.ui.pi_listeAttaques.rowCount() > 0:
            self.plateau.fenetre.ui.pi_listeAttaques.removeRow(0)

        i = 0
        for attaque in self.pion().attaques:
            self.plateau.fenetre.ui.pi_listeAttaques.insertRow(i)
            self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pion().attaques.index(attaque)))))
            icone = None
            if attaque.typ == "cac":
                icone = QIcon("img\\curseurEpee.png")
            if attaque.typ == "dist":
                icone = QIcon("img\\arc.png")
            if attaque.typ == "zone":
                icone = QIcon("img\\baguette.png")
            if icone != None:
                self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8("")))
            self.plateau.fenetre.ui.pi_listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom)))
        self.plateau.majInfosAttaqueEC()  

        super(PionSelectionne, self).activer()


    def desactiver(self):
        self.pion().afficheOmbreSelection(False)

        #maj des infos dans le panneau pi
        self.plateau.fenetre.ui.pi_img.setPixmap(QPixmap())  
        self.plateau.fenetre.ui.pi_nom.setText(QString.fromUtf8("Pas de pion\nselectionné"))

        #vide la liste des attributs
        self.plateau.disconnect(self.plateau.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
        while self.plateau.fenetre.ui.pi_listeAttributs.rowCount() > 0:
            self.plateau.fenetre.ui.pi_listeAttributs.removeRow(0)        

        #vide la liste des attaques du pion
        while self.plateau.fenetre.ui.pi_listeAttaques.rowCount() > 0:
            self.plateau.fenetre.ui.pi_listeAttaques.removeRow(0)
        self.plateau.majInfosAttaqueEC()

        super(PionSelectionne, self).desactiver()