#from __future__ import unicode_literals # -*- coding: utf-8 -*- from __future__ import division import os from sys import exit, argv, getsizeof, settrace from time import time, sleep, strftime, localtime from threading import Thread from PyQt4.QtCore import * from PyQt4.QtGui import * from PyQt4 import QtOpenGL ##from ui.ecran_editionAttaques import Ui_editionAttaques import Modes import Actions from Case import Case from Combattant import Combattant from Decor import Decor from Forme import Forme from Pinceau import Pinceau from ProjectionDep import ProjectionDep from Cache import Cache from EntreeSortie import EntreeSortie from EcranEditionCombattant import EcranEditionCombattant from EcranEditionDecors import EcranEditionDecors from EcranEditionTerrain import EcranEditionTerrain from EcranAffichageTexte import EcranAffichageTexte from EcranGestionCombat import EcranGestionCombat from EcranEditionAttaques import EcranEditionAttaques import regles as regles from outilsSvg import * from lancer import jet, estJetValide from operator import itemgetter, attrgetter from math import * m_couleursRapides = [(255,255,255), (200,200,200), (130,130,130), (90,90,90), (15,15,15), \ (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""" def __init__(self, fenetre, parent=None): super(Plateau, self).__init__() #parametres et variables self.fenetre = fenetre ##partie et infos plateau self.id = "" self.nom = "" self.chapitre = 0 self.tour = 1 self.enCours = False self.public = False self.dateCreation = "" self.dateSvg = "" self.notes = "" #carac self.nbCasesX = 0 self.nbCasesY = 0 self.hCase = 0 self.modePrincipal = "creation" self.modeCombat = "" #interface self.nbZoomActuel = 0 self.epaisseurpinceau = 0 #objets self.pinceau = Pinceau(self) self.cases = {} #dict des cases du plateau (coordonnées: case) self.combattants = {} #liste de combattants positionnes sur le plateau self.decors = {} #liste des decors places sur le plateau self.cacheEnCours = 1 self.caches = {} self.polygonesCaches = {} for i in range(1,5): self.caches[i] = {"actif":False,"listeCases":[]} self.polygonesCaches[i] = None self.listeCasesZonePlacement = [] self.polygoneZonePlacement = None self.entreesSorties = [] #infos combat self.numCombattantEnCours = 0 self.ordreJeu = {} #numero du pion: ordre de jeu #note: la hauteur Z (qui gere l'empilement des objets graphiques est distribuee de cette maniere: #cases : 0 a 9 #pions : 10 et + def __getstate__(self): self.dateSvg = time() state = {key:value for key, value in self.__dict__.items() if not key in ["fenetre", "modeActif", "listMode", "cacheEnCours", \ "modeParam", "nbZoomActuel", "epaisseurPinceau", \ "editionTerrain", "editionCreature", "editionDecor", \ "polygoneZonePlacement", "gestionCombat", "polygonesCaches", \ "editionAttaques", "pinceau"]} return (state) def __setstate__(self, state): self.__dict__ = state def creer(self, idPlateau, nom, chapitre, formeCases, nbCasesX, nbCasesY, couleur = QColor(0, 255, 0, 80)): """cree le plateau""" self.id = idPlateau self.nom = nom self.chapitre = chapitre self.dateCreation = time() self.hCase = 120 #hauteur d'une case self.nbCasesX = nbCasesX #nb cases en x self.nbCasesY = nbCasesY #nb cases en y self.formeCases = formeCases self.gestionCombat = None self.initialisationGraphique() self.connexions() #cree les cases hexagonales for x in range(nbCasesX): for y in range(nbCasesY): ## if formeCases == "H": ## if 1 == (x % 2): ## y += 0.5 c = Case(self) c.creer(x, y, couleur) self.cases[(x,y)] = c def recreer(self, fenetre): self.fenetre = fenetre self.gestionCombat = None super(Plateau, self).__init__() self.connexions() self.initialisationGraphique() #recreation des cases for coord in self.cases: self.cases[coord].recreer(self) #recreation des pions for numCombattant in self.combattants: self.combattants[numCombattant].ajouterAuPlateau(self) self.majOrdreJeu() #recreation des decors for num in self.decors: self.decors[num].ajouterAuPlateau(self) #recreation des marqueurs entree/sortie for entreeSortie in self.entreesSorties: entreeSortie.recreer(self) #recreation de la zone de placement: if len(self.listeCasesZonePlacement) > 0: self.polygoneZonePlacement = None self.majZonePlacement(self.listeCasesZonePlacement) #recreation des caches self.polygonesCaches = {} for i in range(1,5): self.polygonesCaches[i] = None def fermer(self): """ferme le plateau 'proprement'""" self.miniature() self.pinceau = None for item in self.items(): item.prepareGeometryChange() self.removeItem(item) if self.gestionCombat != None: del self.gestionCombat self.fenetre.reinitialiserPanneauxPlateau() def miniature(self): """renvoie une miniature du plateau (QPixMap compresse) qui sera enregistree avec les infos de la sauvegarde""" ## img = QImage(128, 128, QImage.Format_ARGB32_Premultiplied) img = QPixmap(1024, 768) img.fill(QColor("white")) peintre = QPainter(img) rendu = self.render(peintre) peintre.end() img.scaledToHeight(128, Qt.FastTransformation) def connexions(self): """connecte le plateau aux differents widgets de la fenetre principale""" #modes d'interaction self.fenetre.connect(self.fenetre.ui.cbt_modeCreation, SIGNAL("clicked()"), self.plateauModeCreation, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cbt_modeCombat, SIGNAL("clicked()"), self.plateauModeCombat, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.modeAffichagePlateau, SIGNAL("currentIndexChanged(int)"), self.majModeAffichage, Qt.UniqueConnection) #affichage de fenetres self.fenetre.connect(self.fenetre.ui.cbt_afficherGestion, SIGNAL("clicked()"), self.afficheEcranGestionCombat, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_dialogueCouleurs, SIGNAL("clicked()"), self.modePeintureCase, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_pipetteCouleur, SIGNAL("clicked()"), self.modeCopieTerrain, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_afficherNotes, SIGNAL("clicked()"), self.agrandirNotesMjPlateau, Qt.UniqueConnection) #listes self.fenetre.connect(self.fenetre.ui.inf_listeOrdreJeu, SIGNAL("cellClicked(int,int)"), self.clicListOrdreJeu, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_listeTerrains, SIGNAL("cellClicked(int,int)"), self.modeMajTerrainCase, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_listeCreatures, SIGNAL("cellClicked(int,int)"), self.modeCreationCombattant, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_listeDecors, SIGNAL("cellClicked(int,int)"), self.modeCreationDecor, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_editerTerrain, SIGNAL("clicked()"), self.terrainEdit, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_nouveauTerrain, SIGNAL("clicked()"), self.terrainNouveau, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_editerCombattant, SIGNAL("clicked()"), self.creatureEdit, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_nouveauCombattant, SIGNAL("clicked()"), self.creatureNouveau, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_editerDecor, SIGNAL("clicked()"), self.decorEdit, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_nouveauDecor, SIGNAL("clicked()"), self.decorNouveau, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.editerAttaques, SIGNAL("clicked()"), self.afficheEcranEditionAttaques, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_supprimerPion, SIGNAL("clicked()"), self.majModePionSupprimer, Qt.UniqueConnection) #creation self.fenetre.connect(self.fenetre.ui.cp_epaisseurPinceau, SIGNAL("valueChanged(int)"), self.majEpaisseurPinceau, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.altitudeCase, SIGNAL("valueChanged(double)"), self.modeMajAltitudeCase, Qt.UniqueConnection) #autres: #ajouter effet self.fenetre.connect(self.fenetre.ui.cp_placerEntree, SIGNAL("clicked()"), self.majModeDefinirEntree, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_placerSortie, SIGNAL("clicked()"), self.majModeDefinirSortie, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_defPlacement, SIGNAL("clicked()"), self.majModeZonePlacement, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.cacheActif, SIGNAL("clicked()"), self.majEtatCacheEnCours, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.cacheVoir, SIGNAL("clicked()"), self.voirCacheEnCours, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.cachePlacer, SIGNAL("clicked()"), self.placerCacheEnCours, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.notesMjPlateau, SIGNAL("textChanged()"), self.majNotesPlateau, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_notes, SIGNAL("textChanged()"), self.majNotesCombattant, Qt.UniqueConnection) #formes (dessin) self.fenetre.connect(self.fenetre.ui.cp_formeSimple, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeLigne, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeLigneOrientee, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeEllipseVide, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeEllipsePlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeRectVide, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.cp_formeRectPlein, SIGNAL("clicked()"), self.majModeForme, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.effFeu, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.effEau, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.effGlace, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.effPoison, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.effEffacer, SIGNAL("clicked()"), self.modeCaseEffet, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_deplacement, SIGNAL("clicked()"), self.majModeCombatDeplacement, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_attaqueCac, SIGNAL("clicked()"), self.majModeCombatAttaqueCaC, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_attaqueDist, SIGNAL("clicked()"), self.majModeCombatAttaqueDist, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.combatAttaqueZone, SIGNAL("clicked()"), self.fenetre.barreCombatZone, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_attaqueZone, SIGNAL("clicked()"), self.majModeCombatZone, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.pi_vol, SIGNAL("clicked()"), self.fenetre.barreCombatVol, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("valueChanged(int)"), self.majZPion, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.combatZone_ligne, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.combatZone_disque, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection) ## self.fenetre.connect(self.fenetre.ui.combatZone_cone, SIGNAL("clicked()"), self.majModeCombatZoneForme, Qt.UniqueConnection) self.fenetre.connect(self.fenetre.ui.pi_finTour, SIGNAL("clicked()"), self.pionSuivant, Qt.UniqueConnection) #self.fenetre.connect(self.fenetre.ui.combatVol_altitude, SIGNAL("editingFinished()"), self.majVisibiliteBarreCombat) def initialisationGraphique(self): """cree la scene graphique et les parametres necessaires a son fonctionnement, et met a jour l'interface""" #on cree la scene graphique kx = 1 if self.formeCases == "H": kx = 0.866 marge = 240 self.setSceneRect(0 - marge, 0 - marge, (kx*self.hCase*(self.nbCasesX+2)) + marge, (self.hCase*(self.nbCasesY+2)) + marge) self.fenetre.ui.cbt_vue.setScene(self) self.fenetre.ui.cbt_vue.scale(0.25, 0.25) self.fenetre.ui.cbt_vue.centerOn(QPointF(0,0)) self.fenetre.ui.cbt_vue.setDragMode(1) self.setItemIndexMethod(QGraphicsScene.BspTreeIndex) #self.setItemIndexMethod(QGraphicsScene.NoIndex) self.nbZoomActuel = 0 self.epaisseurPinceau = 1 self.polygoneZonePlacement = None self.polygonesCaches = {} for i in range(1,5): self.polygonesCaches[i] = None #gestion du mode d'interaction avec le plateau self.modeActif = Modes.StandardCp(self) self.modeActif_old = "" self.pinceau = Pinceau(self) self.proj = ProjectionDep(self) self.modeParam = {"numPionSelectionne": 0, "creature": None, "decor": None, \ "formeCoordEnCours": (0,0), \ "zoneAttaqueCaC": [], "cibleAttaqueCaC": None, "cibleAttaqueDist": None, "pionCibleAttaqueDist": None, "ligneAttaqueDist": None, \ "typeAttaqueZone": "", "formeAttaqueZone": None, "origineAttaqueZone": None, "point2AttaqueZone": None, \ "listeCasesAttaqueZone": [], "ligneMireAttaqueZone": None} #mise a jour de l'interface de creation self.fenetre.majVisibilitePanneauxPlateau("creation") ## self.fenetre.ui.cbt_nomPlateau.setText(QString.fromUtf8(self.nom)) self.majBoutonsCouleursPerso() ## self.majBoutonsCaches() self.fenetre.ui.cp_listeTerrains.defFichier("lib\\biblio\\terrain") self.fenetre.ui.cp_listeTerrains.initAffichage() self.fenetre.ui.cp_listeCreatures.defFichier("lib\\biblio\\combattant") self.fenetre.ui.cp_listeCreatures.initAffichage() self.fenetre.ui.cp_listeDecors.defFichier("lib\\biblio\\decor") self.fenetre.ui.cp_listeDecors.initAffichage() self.majListeTerrains() self.majListeCreatures() self.majListeDecors() self.initListeOrdreJeu() self.initListeAttaques() ## self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(self.notes)) self.fenetre.ui.pi_deplacement.setCheckable(True) self.fenetre.ui.pi_attaqueCac.setCheckable(True) self.fenetre.ui.pi_attaqueDist.setCheckable(True) self.fenetre.ui.pi_attaqueZone.setCheckable(True) #mise a jour de l'interface d'informations self.majInfosPion(None) self.majInfosDecor(None) def estCree(self): """renvoie vrai si des cases ont ete creees""" return (len(self.cases) > 0) def majBoutonsCouleursPerso(self): """met a jour l'affichage des couleurs customisees dans la boite de dialogue de selection de couleur""" for i in range(0,18): couleur = QColor() r, g, b = m_couleursRapides[i] couleur.setRgb(r, g, b) bouton = self.fenetre.ui.cp_boiteCouleurs.findChild(QToolButton, "cp_couleur{}".format(i+1)) if couleur.isValid(): bouton.setStyleSheet("QToolButton {backGround:%s}"%(couleur.name())) self.fenetre.connect(bouton, SIGNAL("clicked()"), self.modePeintureCase_perso) def chercherCouleur(self): """ouvre la boite de dialogue de selection de couleur""" couleur = QColorDialog(self.fenetre.ui.cbt_vue).getColor(QColor("white"), self.fenetre.ui.cbt_vue) return couleur ## def majBoutonsCaches(self): ## """met a jour l'affichage et connecte les boutons de caches""" ## for i in range(1,5): ## bouton = self.fenetre.ui.outilsEditionPlateau.findChild(QToolButton, "plateauCache{}".format(i)) ## self.fenetre.connect(bouton, SIGNAL("clicked()"), self.majAffichageMenuCache) def majListesPions(self, numCombattant = None): """met a jour les listes contenant des donnees liees aux pions""" ## self.majListeOrdreJeu() ## ## if numCombattant == None or numCombattant == self.pionSelectionne().numero: ## self.majListeAttributs() ## QApplication.processEvents() pass ## def majNotesPlateau(self): ## """les notes du plateau ont ete maj a l'ecran""" ## self.notes = str(self.fenetre.ui.notesMjPlateau.toPlainText().toUtf8()) def agrandirNotesMjPlateau(self): """affiche les notes du plateau dans une QDialog, puis recupere les donnees qui y sont saisies""" affichageTexte = EcranAffichageTexte(self.notes) affichageTexte.setAttribute(Qt.WA_DeleteOnClose) r = affichageTexte.exec_() self.notes = affichageTexte.recupererTexte() ## self.fenetre.ui.notesMjPlateau.setText(QString.fromUtf8(affichageTexte.recupererTexte())) ##### affichage de la liste des terrains enregistres, et fonctions d'acces aux donnees"""" def afficheEcranEditionTerrains(self, terrain = None): """affiche l'ecran d'edition/creation de terrains""" self.editionTerrain = EcranEditionTerrain(terrain) self.editionTerrain.setAttribute(Qt.WA_DeleteOnClose) r = self.editionTerrain.exec_() if r == 1: self.majListeTerrains() def majListeTerrains(self): """mise a jour de la liste des terrains depuis la sauvegarde""" self.fenetre.ui.cp_listeTerrains.maj() self.activerMode(Modes.StandardCp) def terrainEdit(self): """ouvre la fenetre 'terrains' en mode edition""" index = self.fenetre.ui.cp_listeTerrains.item(self.fenetre.ui.cp_listeTerrains.currentRow(), 0) if index > 0: terrain = charger("lib\\biblio\\terrain", str(index.text().toUtf8())) self.afficheEcranEditionTerrains(terrain) def terrainNouveau(self): """ouvre la fenetre 'terrains' en mode edition""" self.afficheEcranEditionTerrains() ############### ##### affichage de la liste des creatures enregistrees, et fonctions d'acces aux donnees"""" def afficheEcranEditionCombattants(self, creature = None): """affiche l'ecran d'edition/creation de creatures""" self.editionCreature = EcranEditionCombattant(creature, self.formeCases) self.editionCreature.setAttribute(Qt.WA_DeleteOnClose) r = self.editionCreature.exec_() if r == 1: self.majListeCreatures() def majListeCreatures(self): """mise a jour de la liste des creatures depuis la sauvegarde""" self.fenetre.ui.cp_listeCreatures.maj() self.activerMode(Modes.StandardCp) def creatureEdit(self): """ouvre la fenetre 'creatures' en mode edition""" index = self.fenetre.ui.cp_listeCreatures.item(self.fenetre.ui.cp_listeCreatures.currentRow(), 0) if index > 0: creature = charger("lib\\biblio\\combattant", str(index.text().toUtf8())) self.afficheEcranEditionCombattants(creature) def creatureNouveau(self): """ouvre la fenetre 'creatures' en mode edition""" self.afficheEcranEditionCombattants() ############### ##### affichage de la liste des decors enregistrees, et fonctions d'acces aux donnees"""" def afficheEcranEditionDecors(self, decor = None): """affiche l'ecran d'edition/creation de decors""" self.editionDecor = EcranEditionDecors(decor, self.formeCases) self.editionDecor.setAttribute(Qt.WA_DeleteOnClose) r = self.editionDecor.exec_() if r == 1: self.majListeDecors() def majListeDecors(self): """mise a jour de la liste des decors depuis la sauvegarde""" self.fenetre.ui.cp_listeDecors.maj() self.activerMode(Modes.StandardCp) def decorEdit(self): """ouvre la fenetre 'decors' en mode edition""" self.afficheEcranEditionDecors(self.fenetre.ui.cp_listeDecors.actuel()) def decorNouveau(self): """ouvre la fenetre 'decors' en mode edition""" self.afficheEcranEditionDecors() ############### ############### maj des infos du panneau Pi a la selection/deselection d'un pion #voir a balancer tout ca dans une classe a part def majPanneauPi(self): if self.pionSelectionne(): ### maj la selection dans la liste d'ordre de jeu for i in range(0, self.fenetre.ui.inf_listeOrdreJeu.rowCount()): if str(self.fenetre.ui.inf_listeOrdreJeu.item(i, 0).text().toUtf8()) == str(self.pionSelectionne().numero): self.fenetre.ui.inf_listeOrdreJeu.setCurrentCell(i,0) ### maj des infos dans le panneau pi self.fenetre.ui.pi_nom.majTexte(self.pionSelectionne().txtId()) self.fenetre.ui.pi_img.chargerImage("img\\"+self.pionSelectionne().img.nomFichier) ### maj de la liste des attributs self.fenetre.ui.pi_listeAttributs.setColumnWidth(0, 50) self.disconnect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee) #on vide la liste while self.fenetre.ui.pi_listeAttributs.rowCount() > 0: self.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.fenetre.ui.pi_listeAttributs.insertRow(i) item = QTableWidgetItem() if i < len(lignesBase): item.setText(QString.fromUtf8(lignesBase[i])) item.setFlags(Qt.NoItemFlags) self.fenetre.ui.pi_listeAttributs.setItem(i, 0, item) self.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase))) #maj des donnees de base self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom)))) self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat)))) self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z)))) #attributs issus des regles utilisees ordre = regles.ordreAttributs() for elt in ordre: ligne = 10 + ordre.index(elt) self.fenetre.ui.pi_listeAttributs.insertRow(ligne) item = QTableWidgetItem(QString.fromUtf8(elt)) item.setFlags(Qt.NoItemFlags) self.fenetre.ui.pi_listeAttributs.setItem(ligne, 0, item) self.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().listeAttributs[elt])))) self.connect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee) ###affiche les notes du combattant self.fenetre.ui.pi_notes.majTexte(self.pionSelectionne().notes) ###maj la liste des attaques du pion #on vide la liste while self.fenetre.ui.pi_listeAttaques.rowCount() > 0: self.fenetre.ui.pi_listeAttaques.removeRow(0) i = 0 for attaque in self.pionSelectionne().attaques: self.fenetre.ui.pi_listeAttaques.insertRow(i) self.fenetre.ui.pi_listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().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.fenetre.ui.pi_listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8(""))) self.fenetre.ui.pi_listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom))) else: #maj des infos dans le panneau pi self.fenetre.ui.pi_img.clear() self.fenetre.ui.pi_nom.majTexte("Pas de pion\nselectionné") #vide la liste des attributs self.disconnect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee) while self.fenetre.ui.pi_listeAttributs.rowCount() > 0: self.fenetre.ui.pi_listeAttributs.removeRow(0) #vide la liste des attaques du pion while self.fenetre.ui.pi_listeAttaques.rowCount() > 0: self.fenetre.ui.pi_listeAttaques.removeRow(0) self.majInfosAttaqueEC() ########### affichage des curseurs personnalises ######## def curseurGomme(self): self.fenetre.ui.cbt_vue.setDragMode(0) curseurPix = QPixmap("img\\gomme.png")#.scaledToHeight(55, Qt.FastTransformation) curseurGomme = QCursor(curseurPix, 0, 0) self.fenetre.ui.cbt_vue.setCursor(curseurGomme) def curseurEpee(self, valide = True): self.fenetre.ui.cbt_vue.setDragMode(0) if valide: curseurPix = QPixmap("img\\curseurEpee.png") curseurSeringue = QCursor(curseurPix, 0, 0) self.fenetre.ui.cbt_vue.setCursor(curseurSeringue) def curseurArc(self): self.fenetre.ui.cbt_vue.setDragMode(0) curseurPix = QPixmap("img\\arc.png") curseurSeringue = QCursor(curseurPix, curseurPix.width(), 0) self.fenetre.ui.cbt_vue.setCursor(curseurSeringue) def curseurBaguette(self): self.fenetre.ui.cbt_vue.setDragMode(0) curseurPix = QPixmap("img\\baguette.png") curseurBaguette = QCursor(curseurPix, curseurPix.width(), 0) self.fenetre.ui.cbt_vue.setCursor(curseurBaguette) ############ ##### activation des differents modes d'interaction avec le plateau et mises a jour des principaux parametres ####### def plateauModeCreation(self): self.fenetre.majVisibilitePanneauxPlateau("creation") self.modePrincipal = "creation" self.activerMode(Modes.StandardCp) def plateauModeCombat(self): self.fenetre.majVisibilitePanneauxPlateau("combat") self.modePrincipal = "combat" self.activerMode(Modes.StandardPi) def activerMode(self, mode, param = None): """desactive le mode actif et active le nouveau a la place""" self.modeActif.desactiver() self.modeActif = mode(self) self.modeActif.activer(param) ## def majModeAffichage(self, index): ## """met a jour le mode d'affichage""" ## nouveauMode = "" ## if index == 0: ## #passe a l'affichage standard ## pass ## elif index == 1: ## #passe en mode affichage de l'altitude ## nouveauMode = "altitude" ## elif index == 2: ## #affichage des terrains slt ## nouveauMode = "terrain" ## elif index == 3: ## #affichage tactique ## nouveauMode = "tactique" ## ## for coord in self.cases: ## self.cases[coord].majAffichageSpecial(nouveauMode) def modePeintureCase(self): """enclenche le mode peinture de case a partir de la couleur selectionnee""" couleur = self.chercherCouleur() if couleur.isValid(): self.activerMode(Modes.MajCases, couleur) else: self.activerMode(Modes.StandardCp) def modePeintureCase_perso(self): origine = self.sender().objectName() index = int(origine.replace("cp_couleur",""))-1 couleur = QColor() r, g, b = m_couleursRapides[index] couleur.setRgb(r, g, b) if couleur.isValid(): self.activerMode(Modes.MajCases, couleur) else: self.activerMode(Modes.StandardCp) def modeCopieTerrain(self): """enclenche le mode copie de case""" self.activerMode(Modes.Pipette) def modeCaseEffet(self): """enclenche le mode de mise a jour de l'ffet actif des cases""" origine = self.sender().objectName() if origine == "effFeu": effet = "brule" elif origine == "effEau": effet = "eau" elif origine == "effGlace": effet = "glace" elif origine == "effPoison": effet = "poison" elif origine == "effEffacer": effet = "aucun" self.activerMode(ModesCaseMaj, effet) def modeCreationPion(self): """enclenche le mode de creation de pions simples""" self.majMode("pionCreation") def majModePionSupprimer(self): """enclenche le mode suppression de pions sur clic gauche (creatures ou decors)""" self.activerMode(Modes.SuppressionPion) def modeCreationDecor(self, ligne, col): """enclenche le mode de creation de decors depuis la liste des decors""" index = self.fenetre.ui.cp_listeDecors.item(ligne, 0) decor = charger("lib\\biblio\\decor", str(index.text().toUtf8())) self.activerMode(Modes.CreationPion, decor) self.fenetre.ui.cbt_vue.setFocus() def modeCreationCombattant(self, ligne, col): """enclenche le mode de creation de pions depuis la liste des creatures""" index = self.fenetre.ui.cp_listeCreatures.item(ligne, 0) creature = charger("lib\\biblio\\combattant", str(index.text().toUtf8())) self.activerMode(Modes.CreationPion, creature) self.fenetre.ui.cbt_vue.setFocus() def modeMajTerrainCase(self, ligne, col): """enclenche le mode permettant la mise a jour du terrain des cases""" index = self.fenetre.ui.cp_listeTerrains.item(ligne, 0) terrain = charger("lib\\biblio\\terrain", str(index.text().toUtf8())) if terrain: self.activerMode(Modes.MajCases, terrain) else: print "terrain invalide" def majEpaisseurPinceau(self, epaisseur): """met a jour l'epaisseur du pinceau (en cases)""" self.fenetre.ui.cp_valeurEpaisseurPinceau.majTexte(str(epaisseur)) self.pinceau.majEpaisseur(int(epaisseur)) def modeMajAltitudeCase(self): self.majMode("caseMajAltitude") def majModeForme(self): """met a jour la forme utilisee pour la peinture""" formes = {"cp_formeSimple": "simple", \ "cp_formeLigne": "ligne", \ "cp_formeLigneOrientee": "frontiere", \ "cp_formeEllipseVide": "ellipseV", \ "cp_formeEllipsePlein": "ellipseP", \ "cp_formeRectVide": "rectV", \ "cp_formeRectPlein": "rectP"} self.pinceau.majForme(formes[str(self.sender().objectName())]) def majModeCombatDeplacement(self): """active le mode de combat 'deplacement' (mode standard)""" self.modeActif.nouvelleAction(Actions.Deplacement) ## self.majModeCombat("combatDeplacement") def majModeCombatAttaqueCaC(self): """active le mode de combat 'corps-a-corps'""" self.modeActif.nouvelleAction(Actions.Cac) ## self.majModeCombat("combatAttaqueCaC") def majModeCombatAttaqueDist(self): """active le mode de combat 'attaque a distance'""" self.modeActif.nouvelleAction(Actions.Distance) ## self.majModeCombat("combatAttaqueDist") def majModeCombatZone(self): if not len(self.modeParam["typeAttaqueZone"]) > 0: self.modeParam["typeAttaqueZone"] = "ligne" self.modeActif.nouvelleAction(Actions.Ligne) ## self.majModeCombat("combatAttaqueZone") def majModeCombatZoneForme(self): pass ## if self.modeCombat == "combatAttaqueZone": ## origine = self.sender().objectName() ## self.modeParam["typeAttaqueZone"] = str(origine).split("_")[1] ## self.majModeCombat("combatAttaqueZone") def majModeDefinirEntree(self): entree = EntreeSortie(self, "E") self.activerMode(Modes.EntreesSorties, entree) def majModeDefinirSortie(self): sortie = EntreeSortie(self, "S") self.activerMode(Modes.EntreesSorties, sortie) def majModeZonePlacement(self): self.activerMode(Modes.ZonePlacement) def majMode(self, mode = "standard", param = None): """modifie ou reinitialise le type d'interaction avec le plateau""" reinit = True #doit-on reinitialiser a la fin de l'operation ##on desactive le mode precedent if self.pionSelectionne() != None: self.pionSelectionne().afficheOmbreSelection(False) if self.modeActif_old == "pionSelectionne": self.majModeCombat("") self.modeParam["numPionSelectionne"] = 0 elif self.pionDecorSelectionne() != None: self.pionDecorSelectionne().afficheOmbreSelection(False) self.modeParam["numPionSelectionne"] = 0 if self.modeActif_old == "pionSelectionne" or self.modeActif_old == "pionDecorSelectionne": self.proj.desactiver() if self.modeActif_old == "cachePlacer": self.pinceau.reinit() ### definition du nouveau mode if mode != "standard": self.modeActif_old = mode reinit = False if mode == "caseMajEffet": #on met a jour l'effet actif sur les cases if param != None: self.curseurPinceau() self.fenetre.ui.cbt_vue.setDragMode(0) self.modeParam["effet"] = param elif mode == "caseMajAltitude": self.curseurPinceau() self.fenetre.ui.cbt_vue.setDragMode(0) elif mode == "cachePlacer": self.curseurPinceau() self.fenetre.ui.cbt_vue.setDragMode(0) self.pinceau.majForme("rectP") self.pinceau.verrouillerForme(True) ##on reinitialise si necessaire if reinit: #mode standard : pas d'interaction avec les cases, on deplace le plateau en le saisissant ou les pions en cliquant dessus self.modeActif_old = "standard" self.majInfosPion() self.majInfosDecor() ## self.fenetre.majVisibiliteBarreCombat("menu") QApplication.processEvents() self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor)) self.fenetre.ui.cbt_vue.setDragMode(1) else: self.fenetre.ui.cbt_vue.setFocus() def majModeCombat(self, mode = ""): """met a jour le mode de combat actif pour le pion selectionne""" ## on desactive le mode precedent si besoin #la projection de position if self.modeCombat == "combatDeplacement": #le champ de deplacement if self.modePrincipal == "combat": self.afficherChampDeplacement(False) self.proj.desactiver() elif self.modeCombat == "combatAttaqueCaC": #la zone d'attaque au cac self.materialiserPions(True) self.majZoneAttaqueCaC(False) self.modeParam["zoneAttaqueCaC"] = [] if self.modeParam["cibleAttaqueCaC"] != None: self.modeParam["cibleAttaqueCaC"].estCibleAttaque(False) self.modeParam["cibleAttaqueCaC"] = None elif self.modeCombat == "combatAttaqueDist": self.materialiserPions(True) self.majLigneMireAttaqueDist() elif self.modeCombat == "combatAttaqueZone": #l'attaque de zone self.materialiserPions(True) QApplication.processEvents() self.reinitAttaqueZone() ## if mode != "combatAttaqueZone": self.fenetre.majVisibiliteBarreCombat("menu") self.modeParam["listeCasesAttaqueZone"] = [] ## definition du nouveau mode de combat if self.pionSelectionne() != None: self.modeCombat = mode self.fenetre.ui.cbt_vue.setDragMode(0) if mode == "aucun": self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor)) if mode == "combatDeplacement": self.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor)) self.proj.creer(self.pionSelectionne()) if self.modePrincipal == "combat": #si mode combat, affichage de la zone de deplacement self.afficherChampDeplacement(True) elif mode == "combatAttaqueCaC": self.curseurEpee() self.materialiserPions(False) ## self.modeParam["zoneAttaqueCaC"] = self.zone(self.pionSelectionne().position, self.pionSelectionne().allonge, True, True) self.modeParam["zoneAttaqueCaC"] = self.zone(self.pionSelectionne().position, 1, True, True) self.majZoneAttaqueCaC(True) elif mode == "combatAttaqueDist": self.curseurArc() self.materialiserPions(False) elif mode == "combatAttaqueZone": self.curseurBaguette() self.materialiserPions(False) self.majFormeAttaqueZone() ############### ########## Gestion du combat ############## def majAffichageTour(self): """met a jour l'affichage du tour en cours""" self.fenetre.ui.cbt_tour.majTexte("Tour: {}".format(self.tour)) def majAffichagePionSelectionne(self): """affiche le nom et le logo du pion actuellement selectionne""" if self.pionSelectionne() != None: self.fenetre.ui.pi_nom.majTexte(self.pionSelectionne().txtId()) if len(self.pionSelectionne().img.nomFichier) > 0: pix = QPixmap(QString.fromUtf8("img\\"+self.pionSelectionne().img.nomFichier)) pix = pix.scaled(44, 44, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.fenetre.ui.pi_img.setPixmap(pix) else: self.fenetre.ui.pi_img.setPixmap(QPixmap()) else: self.fenetre.ui.pi_img.setPixmap(QPixmap()) self.fenetre.ui.pi_nom.majTexte("Pas de pion\nselectionné") def initListeOrdreJeu(self): """cree les colonnes et met en forme la table ordre jeu""" ## self.fenetre.ui.infoOrdreJeu.setColumnWidth(0, 20) self.fenetre.ui.inf_listeOrdreJeu.setColumnWidth(2, 30) self.fenetre.ui.inf_listeOrdreJeu.hideColumn(0) self.fenetre.ui.inf_listeOrdreJeu.hideColumn(2) self.fenetre.ui.inf_listeOrdreJeu.setIconSize(QSize(30,20)) def majListeOrdreJeu(self): """met a jour la liste des pions infoOrdreJeu""" while self.fenetre.ui.inf_listeOrdreJeu.rowCount() > 0: self.fenetre.ui.inf_listeOrdreJeu.removeRow(0) index = 0 for num in self.ordreJeu: self.fenetre.ui.inf_listeOrdreJeu.insertRow(int(index)) self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 0, QTableWidgetItem(QString.fromUtf8(str(num)))) icon = QIcon("img\\"+self.combattants[num].logo) item = QTableWidgetItem(icon,QString.fromUtf8(self.combattants[num].txtId())) self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 1, item) self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 2, QTableWidgetItem(QString.fromUtf8(str(self.ordreJeu[num])))) index += 1 self.fenetre.ui.inf_listeOrdreJeu.sizeHintForColumn(1) ## trierTable(self.fenetre.ui.infoOrdreJeu, 2, 0) def clicListOrdreJeu(self, ligne, col): """on a clique dans la liste d'ordre de jeu, le pion correspondant est selectionne et centre sur la carte""" numCombattant = int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8()) self.fenetre.ui.cbt_vue.centerOn(self.cases[self.combattants[numCombattant].position].centreGraphique) self.pionSaisir(numCombattant) def pionSuivant(self): """selection du pion suivant dans la liste d'ordre de jeu""" if self.numPionEnCours in self.combattants: suivant = self.ordreJeu[self.numPionEnCours] + 1 else: suivant = 1 if suivant > len(self.ordreJeu): self.tour += 1 self.majAffichageTour() suivant = 1 for num in self.ordreJeu: if self.ordreJeu[num] == suivant: numCombattant = num break for ligne in range(0, self.fenetre.ui.inf_listeOrdreJeu.rowCount()): item = self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0) item.setSelected(int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8()) == numCombattant) if int(item.text().toUtf8()) == numCombattant: self.fenetre.ui.inf_listeOrdreJeu.scrollToItem(item) self.fenetre.ui.cbt_vue.centerOn(self.cases[self.combattants[numCombattant].position].centreGraphique) self.pionSaisir(numCombattant) def afficheEcranGestionCombat(self): #*egc """affiche l'ecran de gestion du combat""" self.gestionCombat = EcranGestionCombat(self) self.gestionCombat.show() self.connect(self.fenetre, SIGNAL("majListesPions"), self.majListesPions) self.connect(self.gestionCombat, SIGNAL("majListesPions"), self.majListesPions) QApplication.processEvents() ## r = self.gestionCombat.exec_() def majOrdreJeu(self): """met a jour l'ordre de jeu des pions en fonction de l'attribut prevu par les regles s'il existe, ou en fonction de l'ordre de jeu parametre sinon""" attribut = regles.attributOrdreJeu() if attribut != None: dico = {} for numCombattant in self.combattants: dico[numCombattant] = int(self.combattants[numCombattant].listeAttributs[attribut]) ordre = sorted(dico, key = dico.get, reverse=(regles.sensTriOrdreJeu() == 1)) self.ordreJeu = {} for numCombattant in self.combattants: self.ordreJeu[numCombattant] = ordre.index(numCombattant) + 1 self.majListeOrdreJeu() def pionDeplacerDansOrdreJeu(self, numCombattant, nouvellePosition): """deplace un pion dans le dictionnaire gerant l'ordre de jeu de maniere a assurer sa coherence nouvellePosition = 0 supprime le pion de la liste""" if numCombattant in self.ordreJeu: if nouvellePosition == 0: del self.ordreJeu[numCombattant] if len(self.ordreJeu) > 0: i = 0 tmp = sorted(self.ordreJeu, key=self.ordreJeu.get) if numCombattant in tmp: tmp.remove(numCombattant) for num in tmp: i += 1 if i == nouvellePosition: self.ordreJeu[numCombattant] = i i += 1 self.ordreJeu[num] = i if i < nouvellePosition: self.ordreJeu[numCombattant] = i + 1 elif nouvellePosition > 0: self.ordreJeu[numCombattant] = 1 self.majOrdreJeu() ## def majListeAttributs(self): ## """met a jour la liste des attributs dans le panneau de combat""" ## self.fenetre.ui.pi_listeAttributs.setColumnWidth(0, 50) ## self.disconnect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee) ## ## #on vide la liste ## while self.fenetre.ui.pi_listeAttributs.rowCount() > 0: ## self.fenetre.ui.pi_listeAttributs.removeRow(0) ## self.fenetre.ui.pi_listeAttributs.setVisible((self.pionSelectionne() != None)) ## if self.pionSelectionne() != None: ## #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.fenetre.ui.pi_listeAttributs.insertRow(i) ## item = QTableWidgetItem() ## if i < len(lignesBase): ## item.setText(QString.fromUtf8(lignesBase[i])) ## item.setFlags(Qt.NoItemFlags) ## self.fenetre.ui.pi_listeAttributs.setItem(i, 0, item) ## self.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase))) ## ## #maj des donnees de base ## self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom)))) ## self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat)))) ## self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z)))) ## ## #attributs issus des regles utilisees ## ordre = regles.ordreAttributs() ## for elt in ordre: ## ligne = 10 + ordre.index(elt) ## self.fenetre.ui.pi_listeAttributs.insertRow(ligne) ## item = QTableWidgetItem(QString.fromUtf8(elt)) ## item.setFlags(Qt.NoItemFlags) ## self.fenetre.ui.pi_listeAttributs.setItem(ligne, 0, item) ## self.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().listeAttributs[elt])))) ## ## self.connect(self.fenetre.ui.pi_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee) ## def listeAttributCelluleModifiee(self, ligne, colonne): """une cellule de la liste des attributs a ete modifiee""" if colonne != 1: print("valeur non modifiable") else: #on verifie la validite de la donnee entree lignesBase = ["Nom","Etat","Alt."] #attention: modifier aussi dans majListeAttribut if ligne < len(lignesBase): pass elif ligne >= 10: attribut = regles.ordreAttributs()[(ligne - 10)] nouvelleVal = str(self.fenetre.ui.pi_listeAttributs.item(ligne, 1).text().toUtf8()) valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal) if valVerifiee != None: self.pionSelectionne().listeAttributs[attribut] = valVerifiee if attribut == regles.attributOrdreJeu(): print("maj ordre (a implementer)") else: self.fenetre.ui.pi_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().listeAttributs[attribut])))) def initListeAttaques(self): """met en forme et connecte la liste des attaques du pion""" self.fenetre.ui.pi_listeAttaques.setColumnWidth(0, 0) self.fenetre.ui.pi_listeAttaques.setColumnWidth(1, (0.3*self.fenetre.ui.pi_listeAttaques.width())) self.fenetre.ui.pi_listeAttaques.setColumnWidth(2, (0.7*self.fenetre.ui.pi_listeAttaques.width())) self.connect(self.fenetre.ui.pi_listeAttaques, SIGNAL("itemSelectionChanged()"), self.majInfosAttaqueEC) self.connect(self.fenetre.ui.pi_listeAttaques, SIGNAL("cellClicked(int, int)"), self.listeAttaquesCelluleCliquee) self.connect(self.fenetre.ui.pi_notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC) self.fenetre.ui.pi_listeAttributsAttaqueEC.setColumnWidth(0, (0.49*self.fenetre.ui.pi_listeAttributsAttaqueEC.width())) self.fenetre.ui.pi_listeAttributsAttaqueEC.setColumnWidth(1, (0.5*self.fenetre.ui.pi_listeAttributsAttaqueEC.width())) def majListeAttaques(self): """met a jour la liste des attaques du pion dans le panneau de combat""" #on vide la liste while self.fenetre.ui.pi_listeAttaques.rowCount() > 0: self.fenetre.ui.pi_listeAttaques.removeRow(0) self.fenetre.ui.pi_listeAttaques.setVisible((self.pionSelectionne() != None)) ## self.fenetre.ui.editerAttaques.setVisible((self.pionSelectionne() != None)) self.fenetre.ui.pi_panneauAttaqueEC.setVisible((self.pionSelectionne() != None)) i = 0 if self.pionSelectionne() != None: for attaque in self.pionSelectionne().attaques: self.fenetre.ui.pi_listeAttaques.insertRow(i) self.fenetre.ui.pi_listeAttaques.setItem(i, 0, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().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.fenetre.ui.pi_listeAttaques.setItem(i, 1, QTableWidgetItem(icone, QString.fromUtf8(""))) self.fenetre.ui.pi_listeAttaques.setItem(i, 2, QTableWidgetItem(QString.fromUtf8(attaque.nom))) self.majInfosAttaqueEC() def listeAttaquesCelluleCliquee(self, ligne, colonne): """on a clique sur une cellule de la liste des attaques""" numAttaque = int(str(self.fenetre.ui.pi_listeAttaques.item(ligne, 0).text().toUtf8())) if numAttaque >= 0: self.utiliserAttaque(numAttaque) def utiliserAttaque(self, numAttaque): """le pion selectionne utilise son attaque n""" if self.pionSelectionne() != None: if numAttaque < len(self.pionSelectionne().attaques): attaque = self.pionSelectionne().attaques[numAttaque] if attaque.typ == "cac": self.majModeCombat("combatAttaqueCaC") if attaque.typ == "dist": self.majModeCombat("combatAttaqueDist") if attaque.typ == "zone": self.modeParam["typeAttaqueZone"] = attaque.formeZone self.fenetre.ui.pi_rayonAttaqueZone.setValue(attaque.rayon) self.majModeCombat("combatAttaqueZone") def majInfosAttaqueEC(self): """met a jour les infos de l'attaque en cours (selectionnee)""" selection = self.fenetre.ui.pi_listeAttaques.selectedItems() self.fenetre.ui.pi_panneauAttaqueEC.setVisible(self.pionSelectionne() != None and len(selection) > 0) if self.pionSelectionne() != None and len(selection) > 0: ligne = selection[0].row() numAttaque = int(str(self.fenetre.ui.pi_listeAttaques.item(ligne, 0).text().toUtf8())) self.disconnect(self.fenetre.ui.pi_panneauAttaqueEC, SIGNAL("cellChanged(int,int)"), self.attaqueECCelluleModifiee) #on vide la liste while self.fenetre.ui.pi_listeAttributsAttaqueEC.rowCount() > 0: self.fenetre.ui.pi_listeAttributsAttaqueEC.removeRow(0) self.fenetre.ui.pi_listeAttributsAttaqueEC.insertRow(0) self.fenetre.ui.pi_listeAttributsAttaqueEC.setItem(0, 0, QTableWidgetItem(QString.fromUtf8("numAtt"))) self.fenetre.ui.pi_listeAttributsAttaqueEC.setItem(0, 1, QTableWidgetItem(QString.fromUtf8(str(numAttaque)))) self.fenetre.ui.pi_listeAttributsAttaqueEC.setRowHidden(0, True) #attributs issus des regles utilisees ordre = regles.ordreAttributsAttaques() for elt in ordre: ligne = 1 + ordre.index(elt) self.fenetre.ui.pi_listeAttributsAttaqueEC.insertRow(ligne) item = QTableWidgetItem(QString.fromUtf8(elt)) item.setFlags(Qt.NoItemFlags) self.fenetre.ui.pi_listeAttributsAttaqueEC.setItem(ligne, 0, item) self.fenetre.ui.pi_listeAttributsAttaqueEC.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().attaques[numAttaque].attributs[elt])))) self.connect(self.fenetre.ui.pi_listeAttributsAttaqueEC, SIGNAL("cellChanged(int,int)"), self.attaqueECCelluleModifiee) #maj des notes self.disconnect(self.fenetre.ui.pi_notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC) self.fenetre.ui.pi_notesAttaqueEC.majTexte(self.pionSelectionne().attaques[numAttaque].notes) self.connect(self.fenetre.ui.pi_notesAttaqueEC, SIGNAL("textChanged()"), self.majNotesAttaqueEC) def attaqueECCelluleModifiee(self, ligne, colonne): """une cellule de la liste d'attributs de l'attaque en cours a ete modifiee""" pass def majNotesAttaqueEC(self): """met a jour les notes de l'attaque en cours (selectionnee)""" selection = self.fenetre.ui.pi_listeAttaques.selectedItems() self.fenetre.ui.pi_panneauAttaqueEC.setVisible(self.pionSelectionne() != None and len(selection) > 0) if self.pionSelectionne() != None and len(selection) > 0: ligne = selection[0].row() numAttaque = int(str(self.fenetre.ui.pi_listeAttaques.item(ligne, 0).text().toUtf8())) self.pionSelectionne().attaques[numAttaque].notes = str(self.fenetre.ui.pi_notesAttaqueEC.toPlainText().toUtf8()) def afficheEcranEditionAttaques(self): """affiche l'ecran d'edition/creation d'attaques""" if self.pionSelectionne() != None: self.editionAttaques = QDialog() frame = EcranEditionAttaques(self.pionSelectionne()) frame.setParent(self.editionAttaques) self.editionAttaques.setAttribute(Qt.WA_DeleteOnClose) r = self.editionAttaques.exec_() del self.editionAttaques self.majListeAttaques() def majNotesCombattant(self): """les notes du pion ont ete mises a jour""" if self.pionSelectionne() != None: self.pionSelectionne().notes = str(self.fenetre.ui.pi_notes.toPlainText().toUtf8()) else: pass ## def afficherNotesCombattant(self): ## """affiche les notes du pion selectionne dans le QTextEdit dedie""" ## self.fenetre.ui.pi_notes.setVisible((self.pionSelectionne() != None)) ## if self.pionSelectionne() != None: ## self.fenetre.ui.pi_notes.setText(QString.fromUtf8(self.pionSelectionne().notes)) ############### ############### fonctions de calcul ################ def zone(self, origine, distance, z=0, conditionFranchissable = False, conditionVisible = False): """renvoie un dictionnaire representant la liste des coordonnees des cases comprises dans la zone la zone en question est la liste des cases situees a une distance d des coordonnees d'origine z = 0 -> hauteur z de l'origine par rapport a l'altitude de la case conditionFranchissable = Vrai -> les cases infranchissables ne sont pas prises en compte conditionVisible = Vrai -> les cases bloquant la visibilite ne sont pas prises en compte [cf methode A* (A-star)]""" aVerifier = [] aVerifier2 = [] resultat = {} k = 0 #on part de la premiere case, puis on itere a partir de chaque nouveau depart if origine in self.cases: aVerifier.append(origine) while k <= distance: for depart in aVerifier: for coord in self.cases[depart].voisins: if not coord in aVerifier and not coord in aVerifier2 and not coord in resultat: if conditionFranchissable and not conditionVisible: if self.cases[coord].estFranchissable(z): aVerifier2.append(coord) elif not conditionFranchissable and conditionVisible: if self.cases[coord].terrain.visibilite: aVerifier2.append(coord) elif conditionFranchissable and conditionVisible: if self.cases[coord].estFranchissable(z) and self.cases[coord].terrain.visibilite: aVerifier2.append(coord) else: aVerifier2.append(coord) for elt in aVerifier: resultat[elt] = k aVerifier = aVerifier2 aVerifier2 = [] k += 1 return resultat def coordonneesValides(self, coord): """les coordonnees entrees en parametre sont elles celles d'une case du plateau""" return (coord[0] >= 0 and coord[1] >= 0 and coord[0] < self.nbCasesX and coord[1] < self.nbCasesY) def polygoneAgglo(self, listeCases): """renvoie un polygone contruit par agglomeration des polygones des cases de la liste les cases doivent etre adjacentes (cases hexagonales ou carrees)""" pointsPolygone = [] segments = [] case = Case(self) #on verifie que toutes les cases sont adjacentes les unes aux autres valide = True if len(listeCases) > 1: for coord in listeCases: if not len(set(listeCases).intersection(self.lstCoordAdjacentes(coord[0], coord[1]))) > 0: valide = False if not len(listeCases) > 0: valide = False if valide: #on parcourt les faces des polygones des cases, et on ne garde que ceux qui n'ont pas de case 'en face' for coord in listeCases: polygone = case.polygone(coord[0], coord[1]) voisins = self.lstCoordAdjacentes(coord[0], coord[1]) for i in range(0, len(voisins)): if not voisins[i] in listeCases: j = i+1 if j > len(voisins) - 1: j = 0 segments.append(QLineF(polygone[i], polygone[j])) #on 'accroche' les segments les uns aux autres, dans l'ordre segments2 = [segments[0]] for segment2 in segments2: for segment in segments: if not QLineF(segment.p1(), segment.p2()) in segments2 and not QLineF(segment.p2(), segment.p1()) in segments2: if sqrt((segment.p1().x()-segment2.p2().x())**2+(segment.p1().y()-segment2.p2().y())**2) < 1: segments2.append(QLineF(segment.p1(), segment.p2())) elif sqrt((segment.p2().x()-segment2.p2().x())**2+(segment.p2().y()-segment2.p2().y())**2) < 1: segments2.append(QLineF(segment.p2(), segment.p1())) pointsPolygone = [] premierPoint = segments2[0].p1() pointsPolygone.append(premierPoint) for segment in segments2: pointSuivant = segment.p2() if pointSuivant != premierPoint: pointsPolygone.append(pointSuivant) #creation du polygone polygone = QPolygonF() for point in pointsPolygone: polygone.append(point) else: polygone = None return polygone def lstCoordAdjacentes(self, x, y): """renvoie la liste des coordonnees adjacentes, !!!! sans condition d'existence sur le plateau !!!! attention: l'ordre est important""" if self.formeCases == "H": if 1 == (x % 2): voisins = [(x, y-1), (x+1, y), (x+1, y+1), (x, y+1), (x-1, y+1), (x-1, y)] else: voisins = [(x, y-1), (x+1, y-1), (x+1, y), (x, y+1), (x-1, y), (x-1, y-1)] else: voisins = [(x, y-1), (x+1, y-1), (x+1, y), (x+1, y+1), (x, y+1), (x-1, y+1), (x-1, y), (x-1, y-1)] return voisins def coordCentreListeCases(self, listeCases): """renvoie les coordonnees centrales d'une liste de cases""" retour = None if len(listeCases) > 0: listeTriee = sorted(listeCases) posMilieu = int(len(listeCases)/2) retour = listeTriee[posMilieu] return retour def coordonneesAuPoint(self, point): """renvoie les coordonnees de la case situee au QPointF entre en parametre""" coord = None if point != None: lstObjets = self.fenetre.ui.cbt_vue.scene().items(point) for objet in lstObjets: if objet: if objet.__class__.__name__ == "Case": coord = (objet.x, objet.y) break return coord def casesSousForme(self, forme, plein = True, epaisseur = 0): """renvoie la liste des cases en collision avec un QGraphicsItem en parametre plein = False: pas le contenu de la forme epaisseur = renvoie aussi les cases voisines jusqu'a la distance demandee""" tmp = [] listeCases = [] point1 = None point2 = None #point 1 et 2 if forme.__class__.__name__ == "QGraphicsLineItem": point1 = forme.line().p1() point2 = forme.line().p2() elif forme.__class__.__name__ == "QGraphicsRectItem" or forme.__class__.__name__ == "QGraphicsEllipseItem": point1 = forme.rect().topLeft() point2 = forme.rect().bottomRight() else: point1 = forme.boundingRect().topLeft() point2 = forme.boundingRect().bottomRight() #preselection des cases (meilleures perf) if point1 != None and point2 != None and point1 != point2: preSelection = self.preSelectionCollision(point1, point2) else: preSelection = [] for coord in self.cases: preSelection.append(coord) #on liste les cases en collision avec la forme for coord in preSelection: if self.cases[coord].collidesWithItem(forme, Qt.IntersectsItemShape): if plein: tmp.append(coord) else: contenu = True for i in range(0,len(self.cases[coord].polygon())): if not forme.contains(self.cases[coord].polygon().at(i)): contenu = False break if contenu == False: tmp.append(coord) #on applique l'epaisseur du pinceau (lignes ou formes vides seulement) si necessaire if not plein and epaisseur > 0: for coord in tmp: zone = self.zone(coord, epaisseur) for coord2 in zone: if not coord2 in listeCases: listeCases.append(coord2) else: listeCases = tmp #si la liste est vide, on ajoute l'origine de la forme if len(listeCases) == 0: listeCases = [self.coordonneesAuPoint(point1)] return listeCases def preSelectionCollision(self, point1, point2): """renvoie une liste des cases qui peuvent etre concernees par une collision avec un graphicsItem (pour des raisons de performance)""" preSelection = [] coord1 = self.coordonneesAuPoint(point1) coord2 = self.coordonneesAuPoint(point2) if coord1 != None and coord2 != None: minX = min(coord1[0], coord2[0]) - 1 maxX = max(coord1[0], coord2[0]) + 1 minY = min(coord1[1], coord2[1]) - 1 maxY = max(coord1[1], coord2[1]) + 1 for coord in self.cases: if coord[0] >= minX and coord[0] <= maxX and coord[1] >= minY and coord[1] <= maxY : preSelection.append(coord) else: preSelection = self.cases return preSelection ## def majLigneMireAttaqueDist(self, coordCible = None): ## """met a jour la ligne de mire representant l'attaque a distance""" ## if self.modeParam["cibleAttaqueDist"] != None and self.modeParam["cibleAttaqueDist"] != coordCible: ## self.cases[self.modeParam["cibleAttaqueDist"]].majEstCibleCurseur(False) ## ## if self.modeParam["pionCibleAttaqueDist"] != None: ## self.modeParam["pionCibleAttaqueDist"].estCibleAttaque(False) ## ## if coordCible != None and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist": ## if coordCible == None: ## coordCible = pion.position ## ## if coordCible != self.modeParam["cibleAttaqueDist"]: ## if self.modeParam["ligneAttaqueDist"] == None: ## self.modeParam["ligneAttaqueDist"] = QGraphicsLineItem() ## self.modeParam["ligneAttaqueDist"].setZValue(100) ## pinceau = QPen() ## pinceau.setWidth(6) ## self.modeParam["ligneAttaqueDist"].setPen(pinceau) ## self.modeParam["ligneAttaqueDist"].prepareGeometryChange() ## self.addItem(self.modeParam["ligneAttaqueDist"]) ## ## z = 0 ## pionSurCase = self.cases[coordCible].pionOccupant() ## if pionSurCase != None: ## z = pionSurCase.z ## cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible, z) ## ## if pionSurCase != None: ## pionSurCase.estCibleAttaque(True, cibleValide) ## self.modeParam["pionCibleAttaqueDist"] = pionSurCase ## else: ## self.cases[coordCible].majEstCibleCurseur(True, cibleValide) ## self.modeParam["cibleAttaqueDist"] = coordCible ## ## point1 = self.cases[self.pionSelectionne().position].centreGraphique ## point2 = self.cases[coordCible].centreGraphique ## ligne = QLineF(point1, point2) ## self.modeParam["ligneAttaqueDist"].setLine(ligne) ## else: ## if self.modeParam["ligneAttaqueDist"] != None: ## self.modeParam["ligneAttaqueDist"].prepareGeometryChange() ## self.removeItem(self.modeParam["ligneAttaqueDist"]) ## self.modeParam["ligneAttaqueDist"] = None ## self.modeParam["cibleAttaqueDist"] = None def estCibleAttaqueDistValide(self, coordOrigine, coordCible, zPion = 0): """la case cible est elle valide pour une attaque a distance depuis la position et hauteur du pion selectionne? on compare pour ce faire les altitudes des cases sur la ligne de mire""" casesLigneMire = [] #on preselectionne les cases concernees preSelection = self.preSelectionCollision(self.cases[coordOrigine].centreGraphique, self.cases[coordCible].centreGraphique) if coordOrigine in preSelection: preSelection.remove(coordOrigine) if coordCible in preSelection: preSelection.remove(coordCible) for coord in preSelection: ligne = QLineF(self.cases[coordOrigine].centreGraphique, self.cases[coordCible].centreGraphique) ligneGraphique = QGraphicsLineItem(ligne) ligneGraphique.prepareGeometryChange() self.addItem(ligneGraphique) if self.cases[coord].collidesWithItem(ligneGraphique, Qt.IntersectsItemShape): casesLigneMire.append(coord) self.removeItem(ligneGraphique) del ligneGraphique #on trie les cases par distance au point d'origine (de la plus proche a la plus eloignee) casesLigneMireDistance = {} #distance: coord for coord in casesLigneMire: distance = sqrt((coordOrigine[0] - coord[0])**2 + (coordOrigine[1] - coord[1])**2) casesLigneMireDistance[coord] = distance #on compare enfin les altitudes de chaque case en fonction de la distance zOrigine = self.cases[coordOrigine].altitude + self.pionSelectionne().z + self.pionSelectionne().hauteur zCible = self.cases[coordCible].altitude + zPion distanceTot = sqrt((coordCible[0] - coordOrigine[0])**2 + (coordCible[1] - coordOrigine[1])**2) valide = True for coord in casesLigneMireDistance: if self.cases[coord].terrain.visibilite == False: valide = False break else: if zOrigine >= zCible: z = (zOrigine - zCible) * (casesLigneMireDistance[coord] / distanceTot) else: z = (zCible - zOrigine) * ((distanceTot - casesLigneMireDistance[coord]) / distanceTot) if self.cases[coord].estOccupee(int(z)): if self.modeParam["pionCibleAttaqueDist"] != None: if self.cases[coord].estOccupeePar(int(z)) != self.modeParam["pionCibleAttaqueDist"]: valide = False else: valide = False break return valide ## def validerAttaqueDist(self): ## """on essaie de valider une attaque a distance vers un pion ou une case""" ## if self.modeParam["pionCibleAttaqueDist"] != None: ## msg = "{} attaque a distance le pion {}".format(self.pionSelectionne().txtId(), ## self.modeParam["pionCibleAttaqueDist"].txtId()) ## valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"], self.modeParam["pionCibleAttaqueDist"].z) ## else: ## msg = "{} attaque a distance la case {}".format(self.pionSelectionne().txtId(), ## self.modeParam["cibleAttaqueDist"]) ## valide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, self.modeParam["cibleAttaqueDist"]) ## if not valide: ## msg += " [INVALIDE]" ## print(msg) ## self.majModeCombat("aucun") ## def rectEllipseCirculaire(self, centre, rayon): ## """renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param ## attention: l'ellipse n'est pas tout a fait circulaire, elle couvre horizontalement et ## verticalement le nombre de cases demandees""" ## rect = QRectF() ## if rayon > 0: ## p1 = QPointF((centre.x() - (rayon*self.hCase)), (centre.y() - (rayon*self.hCase))) ## p2 = QPointF((centre.x() + (rayon*self.hCase)), (centre.y() + (rayon*self.hCase))) ## rect.setTopLeft(p1) ## rect.setBottomRight(p2) ## else: ## rect = None ## return rect ## def polygoneCone(self, point1, point2): ## """renvoie le polygone du cone defini par les deux points (origine, distance)""" ## ligne1 = QLineF(point1, point2) ## longueur = ligne1.length() ## ligne1.setAngle(ligne1.angle() + 22.5) ## ligne1.setLength(1.1547*longueur) ## ligne2 = QLineF(point1, point2) ## ligne2.setAngle(ligne2.angle() - 22.5) ## ligne2.setLength(1.1547*longueur) ## polygone = QPolygonF() ## polygone.append(point1) ## polygone.append(ligne1.p2()) ## polygone.append(ligne2.p2()) ## return polygone ## def majFormeAttaqueZone(self): ## """cree la forme de l'attaque de zone""" ## for coord in self.modeParam["listeCasesAttaqueZone"]: ## self.cases[coord].majEstCibleAttaque(False) ## for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]): ## self.combattants[numCombattant].estCibleAttaque(False) ## ## if self.modeCombat == "combatAttaqueZone" and self.pionSelectionne() != None: ## if self.modeParam["typeAttaqueZone"] == "ligne": ## if self.modeParam["formeAttaqueZone"] == None: ## self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["formeAttaqueZone"] = QGraphicsLineItem() ## self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black"))) ## self.modeParam["formeAttaqueZone"].prepareGeometryChange() ## self.addItem(self.modeParam["formeAttaqueZone"]) ## if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: ## ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"]) ## self.modeParam["formeAttaqueZone"].setLine(ligne) ## self.modeParam["listeCasesAttaqueZone"] = [] ## lst = self.casesSousForme(self.modeParam["formeAttaqueZone"],False) ## for coord in lst: ## self.modeParam["listeCasesAttaqueZone"].append(coord) ## #on retire la case du pion selectionne si besoin: ## if self.pionSelectionne().position in self.modeParam["listeCasesAttaqueZone"]: ## self.modeParam["listeCasesAttaqueZone"].remove(self.pionSelectionne().position) ## ## elif self.modeParam["typeAttaqueZone"] == "disque": ## if self.modeParam["ligneMireAttaqueZone"] == None: ## self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["ligneMireAttaqueZone"] = QGraphicsLineItem() ## self.modeParam["ligneMireAttaqueZone"].setPen(QPen(QColor("black"))) ## self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange() ## self.addItem(self.modeParam["ligneMireAttaqueZone"]) ## ## if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: ## ligne = QLineF(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"]) ## self.modeParam["ligneMireAttaqueZone"].setLine(ligne) ## coordCible = self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"]) ## cibleValide = self.estCibleAttaqueDistValide(self.pionSelectionne().position, coordCible) ## ## if cibleValide: ## rayon = self.fenetre.ui.pi_rayonAttaqueZone.value() ## if self.modeParam["formeAttaqueZone"] == None: ## self.modeParam["formeAttaqueZone"] = QGraphicsEllipseItem() ## self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black"))) ## self.modeParam["formeAttaqueZone"].prepareGeometryChange() ## self.addItem(self.modeParam["formeAttaqueZone"]) ## rect = self.rectEllipseCirculaire(self.modeParam["point2AttaqueZone"], rayon) ## self.modeParam["listeCasesAttaqueZone"] = [] ## if rect != None and rect.bottomRight() != rect.topLeft(): ## self.modeParam["formeAttaqueZone"].setRect(rect) ## lst = self.zone(coordCible, rayon, 0) #zone bcp plus rapide que casesSousforme ## self.modeParam["listeCasesAttaqueZone"] = lst ## else: ## self.cases[coordCible].majEstCibleCurseur(True, False) ## self.modeParam["listeCasesAttaqueZone"] = [] ## ## if self.modeParam["formeAttaqueZone"] != None: ## self.modeParam["formeAttaqueZone"].setVisible(cibleValide == True and rect != None) ## ## elif self.modeParam["typeAttaqueZone"] == "cone": ## if self.modeParam["formeAttaqueZone"] == None: ## self.modeParam["origineAttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["point2AttaqueZone"] = self.cases[self.pionSelectionne().position].centreGraphique ## self.modeParam["formeAttaqueZone"] = QGraphicsPolygonItem() ## self.modeParam["formeAttaqueZone"].setPen(QPen(QColor("black"))) ## self.modeParam["formeAttaqueZone"].prepareGeometryChange() ## self.addItem(self.modeParam["formeAttaqueZone"]) ## ## if self.modeParam["origineAttaqueZone"] != self.modeParam["point2AttaqueZone"]: ## cone = self.polygoneCone(self.modeParam["origineAttaqueZone"], self.modeParam["point2AttaqueZone"]) ## self.modeParam["formeAttaqueZone"].setPolygon(cone) ## lst = self.casesSousForme(self.modeParam["formeAttaqueZone"], True, True) ## self.modeParam["listeCasesAttaqueZone"] = [] ## for coord in lst: ## if coord != self.pionSelectionne().position: ## self.modeParam["listeCasesAttaqueZone"].append(coord) ## ## for coord in self.modeParam["listeCasesAttaqueZone"]: ## self.cases[coord].majEstCibleAttaque(True) ## for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]): ## self.combattants[numCombattant].estCibleAttaque(True) ## def validerAttaqueZone(self): ## """l'attaque de zone est validee""" ## if self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatAttaqueZone": ## for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]): ## print("{} a lance une attaque de zone sur {}".format(self.pionSelectionne().nom, self.pionSelectionne().numero , \ ## self.combattants[numCombattant].nom, self.combattants[numCombattant].numero)) ## self.majModeCombat("aucun") ## ## def reinitAttaqueZone(self): ## if self.modeParam["formeAttaqueZone"] != None: ## self.modeParam["formeAttaqueZone"].prepareGeometryChange() ## self.removeItem(self.modeParam["formeAttaqueZone"]) ## self.modeParam["formeAttaqueZone"] = None ## if self.modeParam["ligneMireAttaqueZone"] != None: ## self.modeParam["ligneMireAttaqueZone"].prepareGeometryChange() ## self.removeItem(self.modeParam["ligneMireAttaqueZone"]) ## self.modeParam["ligneMireAttaqueZone"] = None ## if self.modeParam["point2AttaqueZone"] != None: ## self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False) ## for coord in self.modeParam["listeCasesAttaqueZone"]: ## self.cases[coord].majEstCibleAttaque(False) ## for numCombattant in self.pionsSurListeCase(self.modeParam["listeCasesAttaqueZone"]): ## self.combattants[numCombattant].estCibleAttaque(False) def pionSurCase(self, coord): """renvoie le pion present sur la case, none sinon""" retour = None for num in self.combattants: if self.combattants[num].position == coord: retour = num return retour def pionsSurListeCase(self, listeCases): """renvoie la liste des pions presents sur la liste de cases""" retour = [] for coord in listeCases: pion = self.cases[coord].pionOccupant() if pion != None and not pion.numero in retour: retour.append(pion.numero) return retour def majZonePlacement(self, listeCases): """met a jour la forme et l'affichage de la zone de placement initale des joueurs""" if len(listeCases) > 0: if self.polygoneZonePlacement == None: self.polygoneZonePlacement = QGraphicsPolygonItem(scene=self) self.polygoneZonePlacement.setZValue(0) qCouleurFond = QColor("white") qCouleurFond.setAlpha(50) self.polygoneZonePlacement.setBrush(qCouleurFond) pinceau = QPen(QColor("orange")) pinceau.setWidth(20) self.polygoneZonePlacement.setPen(pinceau) self.polygoneZonePlacement.setAcceptedMouseButtons(Qt.NoButton) self.polygoneZonePlacement.setAcceptHoverEvents(False) self.addItem(self.polygoneZonePlacement) listeCases2 = [] for coord in listeCases: if self.cases[coord].estFranchissable(): listeCases2.append(coord) self.polygoneZonePlacement.setPolygon(self.polygoneAgglo(listeCases2)) self.listeCasesZonePlacement = listeCases def materialiserPions(self,actif): """avtive/desactive la reception par les pions (autres que le pion selectionne) des hover events""" for numCombattant in self.combattants: if numCombattant != self.modeParam["numPionSelectionne"]: self.combattants[numCombattant].setAcceptsHoverEvents(actif) self.combattants[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif) for numCombattant in self.decors: self.decors[numCombattant].setAcceptsHoverEvents(actif) self.decors[numCombattant].polygoneGraphique.setAcceptsHoverEvents(actif) ####################### ######## interaction avec les cases, decors et pions ############# def pionSelectionne(self): """renvoie le pion actuellement selectionne""" retour = None if self.modeActif.__class__.__name__ == "PionSelectionne": retour = self.modeActif.pion() return retour def pionDecorSelectionne(self): """renvoie le pion actuellement selectionne""" if self.modeParam["numPionSelectionne"] in self.decors: retour = self.decors[self.modeParam["numPionSelectionne"]] else: retour = None return retour def caseCliquee(self, x, y): """on a clique sur la case (clic gauche)""" coord = (x, y) self.modeActif.clic_case(coord) accepte = False if coord in self.cases: case = self.cases[coord] if self.modeActif_old == "pionDecorSelectionne": if coord != self.pionDecorSelectionne().position: self.pionDeposer(coord) accepte = True elif self.modeActif_old == "pionSelectionne": if self.modeCombat == "combatDeplacement": if self.pionSelectionne() != None: if coord != self.pionSelectionne().position: self.pionDeposer(coord) accepte = True elif self.modeCombat == "combatAttaqueCaC": if self.modeParam["cibleAttaqueCaC"] in self.modeParam["zoneAttaqueCaC"]: print("{} attaque {} au corps a corps".format(self.pionSelectionne().nom, self.modeParam["cibleAttaqueCaC"])) self.majMode("pionSelectionne", None) accepte = True else: print("cette case est invalide pour une corps a corps") accepte = True elif self.modeCombat == "combatAttaqueDist": self.validerAttaqueDist() accepte = True elif self.modeCombat == "combatAttaqueZone": self.validerAttaqueZone() accepte = True return accepte def caseSurvolClicEnfonce(self, coord): """une case est survolee par le curseur (le clic gauche est enfonce)""" self.modeActif.survolClic_case(coord) def caseSurvol(self, x, y): """une case est survole par le curseur, on affiche ses informations dans la zone prevue""" self.modeActif.survol_case((x,y)) case = self.cases[(x, y)] self.majInfosCase(case) if (self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatDeplacement") or self.modeActif_old == "pionCreation"\ or self.modeActif_old == "pionDecorSelectionne" or self.modeActif_old == "pionDecorCreation": self.proj.majCoord((x, y)) elif self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatAttaqueDist" and self.modeParam["cibleAttaqueDist"] != (case.x, case.y): self.majLigneMireAttaqueDist((case.x,case.y)) elif self.modeActif_old == "pionSelectionne" and self.pionSelectionne() != None and self.modeCombat == "combatAttaqueZone": if case.centreGraphique != self.modeParam["point2AttaqueZone"]: self.cases[self.coordonneesAuPoint(self.modeParam["point2AttaqueZone"])].majEstCibleCurseur(False) self.modeParam["point2AttaqueZone"] = case.centreGraphique self.majFormeAttaqueZone() def afficherListeCases(self, listeCases, actif): """met ou non en evidence les cases selectionnees""" for coord in listeCases: self.cases[coord].majEstCibleCurseur(actif) def majInfosCase(self, case=None): """met a jour les informations d'un pion dans la zone prevue""" if case != None: if len(case.terrain.nom) > 0: self.fenetre.ui.inf_caseTerrain.majTexte(case.terrain.nom) else: self.fenetre.ui.inf_caseTerrain.majTexte("Case") self.fenetre.ui.inf_caseCoord.majTexte("X: {} Y: {}".format(case.x, case.y)) self.fenetre.ui.inf_caseAltitude.majTexte("Alt.: {}".format(case.altitude)) if case.effetActif != "": pix = QPixmap(QString.fromUtf8("img\\"+case.imgEffet[case.effetActif])) pix = pix.scaled(21, 21, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.fenetre.ui.inf_caseEffet.setPixmap(pix) else: self.fenetre.ui.inf_caseEffet.clear() self.fenetre.ui.inf_boiteCase.setVisible(True) else: self.fenetre.ui.inf_boiteCase.setVisible(False) def pionClique(self, num): """on a clique sur ce pion""" accepte = False if num < 10000: self.modeActif.clic_combattant(num) accepte = False if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueDist": self.validerAttaqueDist() accepte = True else: self.modeActif.clic_decor(num) if self.modeActif.nom() == "Standard": self.activerMode(Modes.DeplacementPion, num) return accepte def pionSurvol(self, numCombattant): """le pion est survole par le curseur, on affiche ses informations dans la zone prevue""" self.modeActif.survol_combattant(numCombattant) if numCombattant in self.combattants: pion = self.combattants[numCombattant] else: pion = None self.majInfosPion(pion) if self.pionSelectionne() != None and self.modeCombat == "combatAttaqueCaC": self.majProjectionAttaqueCaC(pion) pass if numCombattant in self.combattants: ## case = self.cases[self.combattants[numCombattant].position] self.caseSurvol(self.combattants[numCombattant].position[0], self.combattants[numCombattant].position[1]) def pionDoubleClic(self, numCombattant): """on a double-clique sur le pion""" self.modeActif.doubleClic_combattant(numCombattant) accepte = False if self.pionSelectionne() == self.combattants[numCombattant] and self.modeCombat == "aucun": ## self.pionSaisir(numCombattant) self.majModeCombat("combatDeplacement") accepte = True return accepte def creerPion(self, pionModele): """creer un pion (combattant ou decor) aux coordonnees indiquees""" cree = False if self.proj.projectionValide(): if pionModele.__class__.__name__ == "Combattant": pion = Combattant() elif pionModele.__class__.__name__ == "Decor": pion = Decor() for elt in pionModele.__dict__: pion.__dict__[elt] = pionModele.__dict__[elt] if pionModele.__class__.__name__ == "Combattant": numero = 1 if len(self.combattants) > 0: numero = max(self.combattants) + 1 pion.numero = numero pion.numComplementaire = self.numeroterNom(pion.nom) self.combattants[numero] = pion self.pionDeplacerDansOrdreJeu(numero, len(self.ordreJeu) + 2) elif pionModele.__class__.__name__ == "Decor": numero = 10001 if len(self.decors) > 0: numero = max(self.decors) + 10001 pion.numero = numero self.decors[numero] = pion pion.position = self.proj.coord() pion.nbRotations = self.proj.nbRotations() pion.ajouterAuPlateau(self) cree = True return cree def numeroterNom(self, nom): """renvoie le nom du pion avec un numero complementaire si necessaire """ i = 1 for numCombattant in self.combattants: if self.combattants[numCombattant].nom == nom: i += 1 if i == 1: retour = "" else: retour = str(i) return retour def pionSaisir(self, numCombattant): """on saisit un pion""" if numCombattant != self.modeParam["numPionSelectionne"]: self.majMode("pionSelectionne", numCombattant) def pionDeposer(self, coordCase): """on depose le pion sur la case voulue""" if self.pionSelectionne() != None: pion = self.pionSelectionne() else: pion = self.pionDecorSelectionne() if pion != None: if self.proj.projectionValide(): pion.majPosition(self.proj.coord(), self.proj.nbRotations()) def afficherChampDeplacement(self, actif): """cree et affiche ou efface et detruit le champ de deplacement du pion selectionne""" if self.pionSelectionne() != None: if actif: self.pionSelectionne().champDeplacement = self.zone(self.pionSelectionne().position, \ self.pionSelectionne().deplacementRestant, \ True) for coord in self.pionSelectionne().champDeplacement: self.cases[coord].majEstDansChampDeplacement(actif) if not actif: self.pionSelectionne().champDeplacement = {} def majInfosPion(self, pionSurvole=None): """met a jour les informations d'un pion dans la zone prevue""" if pionSurvole != None: pion = pionSurvole else: if self.pionSelectionne() != None: pion = self.pionSelectionne() else: pion = None if pion != None: self.fenetre.ui.inf_pionNom.majTexte(pion.nom) if len(pion.img.nomFichier) > 0: pix = QPixmap(QString.fromUtf8("img\\"+pion.img.nomFichier)) pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.fenetre.ui.inf_pionImage.setPixmap(pix) self.fenetre.ui.inf_boitePion.setVisible(True) self.fenetre.ui.inf_pionEffet.setVisible(False) else: self.fenetre.ui.inf_boitePion.setVisible(False) def majZPion(self, valeur): """met a jour l'altitude du pion selectionne""" if self.pionSelectionne() != None: self.pionSelectionne().majZ(valeur) def pionDecorSurvol(self, numPionDecor): """le pion-decor est survole par le curseur, on affiche ses informations dans la zone prevue""" if numPionDecor in self.decors: self.majInfosDecor(self.decors[numPionDecor]) else: self.majInfosDecor(None) def pionDecorSaisir(self, numPionDecor): """on saisit un pion decor (mode creation seulement)""" if numPionDecor != self.modeParam["numPionSelectionne"]: self.majMode("pionDecorSelectionne", numPionDecor) def majInfosDecor(self, pionDecor=None): """met a jour les informations d'un pion dans la zone prevue""" if pionDecor != None: self.fenetre.ui.inf_decorNom.majTexte(pionDecor.nom) if len(pionDecor.img.nom) > 0: pix = QPixmap(QString.fromUtf8("img\\"+pionDecor.img.nom)) pix = pix.scaled(61, 51, Qt.KeepAspectRatio, Qt.SmoothTransformation) self.fenetre.ui.infoDecorEnCours_image.setPixmap(pix) self.fenetre.ui.inf_boiteDecor.setVisible(True) else: self.fenetre.ui.inf_boiteDecor.setVisible(False) def majProjectionAttaqueCaC(self, pionCible): """affiche ou non la cible de l'attaque au corps a corps, selon sa validite ou non""" if self.modeActif_old == "pionSelectionne" and self.modeCombat == "combatAttaqueCaC": if pionCible != self.pionSelectionne(): if pionCible != None: conditionPossible = (pionCible.position in self.modeParam["zoneAttaqueCaC"]) pionCible.estCibleAttaque(True, conditionPossible) else: if self.modeParam["cibleAttaqueCaC"] != None: self.modeParam["cibleAttaqueCaC"].estCibleAttaque(False) self.modeParam["cibleAttaqueCaC"] = pionCible def majZoneAttaqueCaC(self, actif = True): """affiche ou non les cases a portee du pion selectionne pour une attaque au corps-a-corps""" for coord in self.modeParam["zoneAttaqueCaC"]: self.cases[coord].majEstDansChampDeplacement(actif) def pionSupprimer(self, num): """supprime le pion entre en parametre""" #settrace(trace_calls) if num in self.combattants: for coord in self.combattants[num].forme.listeCases(self.combattants[num].position, self.combattants[num].nbRotations): self.cases[coord].majOccupation(self.combattants[num]) self.pionSurvol(None) self.pionDeplacerDansOrdreJeu(num, 0) pionSuppr = self.combattants.pop(num) pionSuppr.retirerDuPlateau() else: print("erreur: ce pion n'est pas dans la liste des pions") def pionDecorSupprimer(self, num): """supprime le pion entre en parametre""" if num in self.decors: for coord in self.decors[num].forme.listeCases(self.decors[num].position, self.decors[num].nbRotations): self.cases[coord].majOccupation(self.decors[num]) self.pionDecorSurvol(None) pionDecorASuppr = self.decors.pop(num) pionDecorASuppr.supprimer() else: print("ce pion n'est pas dans la liste des decors") ############### ######### caches ############### def voirCacheEnCours(self): """centre la vue sur et met en evidence le cache actif""" if len(self.caches[self.cacheEnCours]["listeCases"]) > 0: #centre la vue sur le premier point du polygone d'une case du milieu de la liste indiceMilieu = int((len(self.caches[self.cacheEnCours]["listeCases"])/2)) self.fenetre.ui.cbt_vue.centerOn(self.cases[self.caches[self.cacheEnCours]["listeCases"][indiceMilieu]].polygon()[0]) #mettre en surbrillance #for coord in self.caches[self.cacheEnCours]["listeCases"]: # self. def placerCacheEnCours(self): """active le mode de mise a jour de la liste des cases cachees par ce cache""" self.majMode("cachePlacer") self.fenetre.ui.cacheActif.setChecked(True) self.majEtatCacheEnCours() def majEtatCacheEnCours(self): """met a jour l'etat (actif ou non) du cache selon l'etat de la case correspondante""" self.caches[self.cacheEnCours]["actif"] = self.fenetre.ui.cacheActif.isChecked() self.majAffichageCache(self.cacheEnCours, self.caches[self.cacheEnCours]["actif"]) def majAffichageCache(self, numCache, afficher = True): """met a jour l'affichage des cases selon les parametres enregistres pour le cache""" if self.polygonesCaches[numCache] == None: self.polygonesCaches[numCache] = Cache(self, numCache) self.polygonesCaches[numCache].afficher(afficher, self.pinceau.selection()) ###############" ######### gestion des evenements souris et clavier ############### def wheelEvent(self, event): """zoom/dezoom avec la molette de la souris""" #on zoom/dezoom et on recentre sur la position du curseur #super (Plateau, self).wheelEvent(event) zoom = 1.00 if event.delta() > 0: if self.nbZoomActuel <= 10: self.nbZoomActuel += 1 zoom = 1.25 elif event.delta() < 0: if self.nbZoomActuel >= -10: zoom = 0.8 self.nbZoomActuel -= 1 if zoom != 0.00: self.fenetre.ui.cbt_vue.scale(zoom, zoom) self.fenetre.ui.cbt_vue.centerOn(event.scenePos()) event.accept() #pour considerer l'evenement comme resolu, sans ca les barres de defilement reagissent aussi def mouseMoveEvent(self, event): super(Plateau, self).mouseMoveEvent(event) if event.buttons() == Qt.LeftButton and self.fenetre.ui.cbt_vue.dragMode() != QGraphicsView.ScrollHandDrag: coord = self.coordonneesAuPoint(event.scenePos()) if coord != None: self.caseSurvolClicEnfonce(coord) else: self.modeActif.mouvementSouris(event) event.ignore() def mousePressEvent(self, event): super(Plateau, self).mousePressEvent(event) if event.button() == 1: self.modeActif.clicGauche(event) if event.button() == 1 and self.fenetre.ui.cbt_vue.dragMode() != QGraphicsView.ScrollHandDrag: if self.modeActif_old == "pionSupprimer": for item in self.items(event.scenePos()): if item.__class__.__name__ == "PionDecor": self.pionDecorSupprimer(item.numero) break elif item.parentItem().__class__.__name__ == "Pion": self.pionSupprimer(item.parentItem().numero) break else: ## if not event.isAccepted(): ## self.caseCliquee(self.coordonneesAuPoint(event.scenePos())) event.ignore() elif event.button() == 2: if self.pionSelectionne() != None and self.modeCombat != "" and self.modeCombat != "aucun": self.majModeCombat("aucun") else: self.majMode("standard") self.modeActif.clicDroit(event) event.accept() #event.ignore() def mouseReleaseEvent(self, event): super(Plateau, self).mouseReleaseEvent(event) self.modeActif.finClicGauche(event) def keyPressEvent(self, event): """gestion des evenements clavier""" toucheClavier = event.key() self.modeActif.toucheClavier(event) if self.modeActif_old == "pionCreation" or self.modeActif_old == "pionSelectionne" or self.modeActif_old == "pionDecorSelectionne" or self.modeActif_old == "pionDecorCreation": #pivots de la projection du deplacement if toucheClavier == Qt.Key_Right: self.proj.majRotation(1) event.accept() elif toucheClavier == Qt.Key_Left: self.proj.majRotation(-1) event.accept() if toucheClavier == Qt.Key_Delete: if self.pionSelectionne() != None: num = self.pionSelectionne().numero if self.modeActif_old == "pionSelectionne": self.pionSupprimer(num) elif self.modeActif_old == "pionDecorSelectionne": self.pionDecorSupprimer(num) self.majMode("standard") ################