# -*- coding: utf-8 -*-

import random

class Plateau:


    def __init__(self):

        #on remplit le tableau de cases vides
        self.pions = []
        for i in range(0,30):
            self.pions.append([])
            for j in range(0,30):
                self.pions[i].append(0)

        #on stipule les regles de deplacement pour chaque type de pion sous forme de vecteurs.

        #ces vecteurs representeNT les deplacements possibles des proteines dans les 8 directions de l'espace
        liste_vecteur_p = [[0,1],[1,0],[1,1],[0,-1],[-1,0],[-1,-1],[-1,1],[1,-1]]

        #les lipides ne peuvent aller qu'en avant ou en arriere.
        liste_vecteur_l = [[1,0],[-1,0]]

        #on associe a chaque type une gamme de deplacements (vecteurs)
        self.mouvement_pions = {"P":liste_vecteur_p,"L":liste_vecteur_l,"M":liste_vecteur_p}

        #on associe a chaque type une longueur de deplacement
        self.longueur_deplacement_pions = {"P":1,"L":3,"M":3}

        #on definit les variables de jeu, commes les score des joueurs et le nombre de metabolite restant
        self.score_joueur = [0,0,0]

        self.metabolite_restant = 20


    #on cree une fonction qui ajoute des pions sur le plateau
    def ajouter_pion(self,x,y,type,taille_estomac=0,proprietaire=0,id=""):
        #dans le stockage en tuples, le premier indice correspond au numero de ligne donc a l'axe des y
        #le deuxieme indice correspond sa position dans la ligne donc a l'axe des x
        if(self.pions[y][x] == 0):
            self.pions[y][x] = {"type":type,"taille_estomac":taille_estomac,"proprietaire":proprietaire,"id":id}
            return True
        else :
            return False


    #on cree une fonction qui retourne le pion se trouvant dans le tuple de coordonnee
    def retourner_pion(self,coordonnee):
        #pymeta.ecrire_text(45,2,str(coordonnee),5)
        return self.pions[coordonnee[1]][coordonnee[0]]


    #on cree une fonction capable de retourner les deplacement que le pion se trouvant en position x,y peut effecteur.
    def retourner_deplacements_possibles(self,x,y):

        #on recupere les proprietes du pions dans une variable pour une manipulation plus aisee
        pion = self.pions[y][x]
        type_pion = pion["type"]

        liste_vecteur = self.mouvement_pions[type_pion]
        deplacement_possible = []


        for vecteur in liste_vecteur:
            deplacement = [x,y]
            #print deplacement
            compteur_de_case = 0
            nombre_deplacement_max = self.longueur_deplacement_pions[type_pion]

            while(True):
                if  nombre_deplacement_max < compteur_de_case: break;
                #on effectue un deplacement suivant le vecteur
                deplacement[0]+=vecteur[0]
                deplacement[1]+=vecteur[1]
                #on verifie qu'on ne sort pas des limites du plateau
                if(deplacement[0] < 0 or deplacement[1] < 0):
                        break;
                #si on trouve un autre pion sur la route, on stoppe la boucle

                if(self.retourner_pion(deplacement) != 0):
                        #si le pion que l'on deplace est une proteine et l'autre pion un metabolite, on ajoute tout meme le deplacement a la liste puisque les proteines mangent les metabolites.
                        #print self.retourner_pion(deplacement)
                        if self.retourner_pion(deplacement)["type"] == "M" and type_pion == "P":
                                deplacement_possible.append([deplacement[0],deplacement[1]])
                        break;
                #finalement, on ajoute le deplacement puisque rien ne l'a bloque
                deplacement_possible.append([deplacement[0],deplacement[1]])

                #et puis on ajoute 1 au compteur de case
                compteur_de_case+=1
        return deplacement_possible


    #cette fonction place un pion d'un type donne de facon aleatoire
    def placer_pion_aleatoirement(self,type,taille_estomac,proprietaire,id):

        #on genenere x et y au hasard et on verifie qu'il n'y a pas de pion a x e y.
        while(True):
            x = random.randint(0,29)
            y = random.randint(0,29)
            if self.pions[y][x] == 0:
                #la case est vide, on ajoute la piece et on stoppe la boucle
                self.ajouter_pion(x,y,type,taille_estomac,proprietaire,id)
                break;


    #place les pions d'un joueur de facon aleatoire
    def placer_pions_joueur_aleatoirement(self,joueur):
        #on place les proteines
        for i in range(1,6):
            self.placer_pion_aleatoirement("P",i,joueur,"P"+str(i)) #rappel : (type de pion,taille_estomac,numero de joueur,id_unique)
        #on place les lipides
        for i in range(1,21):
            self.placer_pion_aleatoirement("L",0,joueur,"L"+str(i))


    #place les metabolites aleatoirement
    def placer_metabolite_aleatoirement(self):
        for i in range(1,21):
            self.placer_pion_aleatoirement("M",0,0,"M"+str(i)) #rappel : les metabolites n'ont ni d'estomac, ni de proprietaire



    #cette fonction deplace un pion d'un endroit a un autre, si il s'agit d'une proteine et qu'elle atterit sur un metabolite,
    def deplacer_pion(self,x,y,nouveau_x,nouveau_y):

            #on copie le pion a deplacer dans une variable temporaire
            pion_a_deplacer = self.pions[y][x].copy()

            #on vide son ancienne position
            self.pions[y][x] = 0

            #si le pion a deplacer est une proteine et la case cible contient un metabolite, alors on modifie les scores du joueur a qui appartient le pion et on actualise le nombre de metabolite restant
            if self.pions[nouveau_y][nouveau_x] != 0:
                if pion_a_deplacer["type"] == "P" and self.pions[nouveau_y][nouveau_x]["type"] == "M":
                    self.score_joueur[pion_a_deplacer["proprietaire"]] += 1
                    self.metabolite_restant += -1

            #et pour finir, on transfert le pion a deplacer dans la case
            self.pions[nouveau_y][nouveau_x] = pion_a_deplacer

    #verifie que le deplacement d'un pion d'une position à un autre est possible. Renvoie True si le deplacement est possible
    def verifier_deplacement(self,depart_x,depart_y,arrivee_x,arrivee_y):

        #le depart et l'arrivee sont donnes sous forme de tuple de la forme [x,y]
        deplacements_possibles = self.retourner_deplacements_possibles(depart_x,depart_y)

        #on considere le deplacement comme invalide au depart
        deplacement_valide = False

        #si un des i correspond a un des deplacement possible, la variable deplacement_possible est changee en True
        for i in deplacements_possibles:
            if i == [arrivee_x,arrivee_y]:
                deplacement_valide = True

        return deplacement_valide

    #verifie si le pion est deplacable ou pas. Renvoie True si le deplacement est possible
    def verifier_si_pion_deplacable(self,pion_x,pion_y):
        return True

def fin_de_partie(type,taille_estomac):
    if retourner_deplacements_possibles(x,y)==0:
        print "fin de la partie"
        return sum["taille_estomac","proprietaire"]