#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from Pion import Pion
import regles
from mat import Materiel

class Combattant(Pion, Materiel):
    """combattant sur un plateau de combat"""
    def __init__(self, parent=None):
        super(Combattant, self).__init__()
        self._type = "cb"
        
        self.taille = 2
        self.depMarche = regles.valeurDefaut("depMarche")
        self.depNage = regles.valeurDefaut("depNage")
        self.depEscalade = regles.valeurDefaut("depEscalade")
        self.depVol = regles.valeurDefaut("depVol")
        self.saut = regles.valeurDefaut("saut")
        
        self.enVol = False   #mode vol active?
        
        self.attaques = []   #liste des attaques pre-parametrees du pion
        self.listeAttributs = regles.listeAttributs()
        self.inventaire = []
        self.details = {}
        self.notes = ""        

        #caracs liees au combat:
        self.deplacementRestant = 0        
        
    def ajouterAuPlateau(self, plateau):
#         self.plateau = plateau
        super(Combattant, self).ajouterAuPlateau(plateau)
        self.majEtiquette()

    def projectionValide(self, proj):
        if not super(Combattant, self).projectionValide(proj): return False
        #on ajoute des criteres de validite supplementaires lies aux combattants
        lst = proj.listeCases()
        lstH = []
        for case in lst:
            lstH.append(case.z1())
            #4- si le pion vole, c'est ok ici:
            if self.enVol: return True
            #5- sinon, selon possibilites de deplacement au sol du pion
            if not case.terrain.franchissable: return False
            if case.terrain.nage:
                if not self.depNage > 0: return False
            else:
                if not self.depMarche > 0: return False
        #fin: la difference de hauteur entre les cases n'excede pas la hauteur du pion -1
        if (max(lstH) - min(lstH)) > (self.h - 1): return False
        return True

    def pM(self):
        """les points de mouvement"""
        return max([self.depMarche, self.depNage, self.depEscalade, self.depVol])

    def coutDep(self, typeDep, dist = 1):
        """renvoie le cout en PM pour effectuer ce deplacement"""
        if not typeDep in self.__dict__: return 1
        dep = self.__dict__[typeDep] if typeDep in self.__dict__ else 0
        if dep > 0:
            cout = self.pM() / dep
            return dist * cout
        else:
            return -1
            
    def listeAttaques(self):
        return self.attaques

    def estCache(self):
        """met a jour le combattant selon qu'il soit cache ou non"""
        for x, y in self.coordOccupees():
            if not self.plateau.cases[(x, y)].estCachee(): return False
        return True

    def hoverEnterEvent(self, event):
        """evenement lors du survol de la souris (en entree)"""
        self.plateau.survol_combattant(self.numero)
#         event.ignore()

    def hoverLeaveEvent(self, event):
        """evenement lors du survol de la souris (en entree)"""
        self.plateau.finSurvol_combattant(self.numero)

    def mousePressEvent(self, event):
        """evenement lors du clic souris"""
        super(Pion, self).mousePressEvent(event)
        if event.button() == 1: #sur clic gauche
            accepte = self.plateau.clic_combattant(self.numero)
            if accepte: event.accept()
        else:
            event.ignore()

    def mouseDoubleClickEvent(self, event):
        """evenement lors du clic souris"""
        super(Pion, self).mouseDoubleClickEvent(event)
        if event.button() == 1: #sur clic gauche
            accepte = self.plateau.doubleClic_combattant(self.numero)
            if accepte: event.accept()
        else:
            event.ignore()


class PJ(Combattant):
    def __init__(self):
        super(PJ, self).__init__()
        self._type = "pj"
        self.creePar = ""