#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Tkinter import *
from tkMessageBox import *
from tkSimpleDialog import *



def damier(): #fonction qui affiche un damier
    for x in range(10):
        for y in range(10):
            if (x+y) % 2 == 0:
                can.create_rectangle(x * case, y * case, (x + 1) * case, (y + 1) * case, fill="black") #on dessine des carrés noirs sur le fond rouge

def start_game():
    global started, liste_des_joueurs

    #on demande le nom des joueurs
    nom_j1 = askstring("Nouvelle Partie...", "Joueur 1:")
    nom_j2 = askstring("Nouvelle Partie...", "Joueur 2:")
    nom_j1 += ' (rouge)' #on ajoute des suffixes pour être sur que les joueurs connaissent leur couleur
    nom_j2 += ' (jaune)'

    damier() #on affiche le damier
    initialisation_pion() #on reinitialise la position de tous les points
    joueur_qui_joue = 1 # On definit que c'est au tour du joueur 1
    showinfo('Tour', 'C\'est le tour de ' + nom_j1) # On affiche que c'est au joueur 1 de jouert
    liste_des_joueurs = [0, nom_j1, nom_j2]  #On crée une liste avec les noms des joueurs de facon à pouvoir y accéder facilement
    started = True #On dit que la partie commence

def dessiner_cercle(x_milieu, y_milieu, rayon, couleur): #Fonction qui déssine un cercle en fonction de l'origine, du rayon et de la couleur
    can.create_oval(x_milieu - rayon, y_milieu - rayon, x_milieu + rayon, y_milieu + rayon, fill=couleur)

def placePions(Pions): #fonction qui recupère la liste bi-dimentionnelle et qui affiche tous les pions
    for x in range(len(Pions)): #len(Pions) = 10
        for y in range(len(Pions[0])): #len(Pions[0]) = 10
            if Pions[x][y] != 0: #Si la case n'est pas vide

                #on definit l'origine du cercle
                x_milieu = x * case + case / 2
                y_milieu = y * case + case / 2

                if Pions[x][y] == 1: #si le pion appartient au joueur 1
                    dessiner_cercle(x_milieu, y_milieu, 15, 'red') #on dessine un cercle rouge
                if Pions[x][y] == 2: #si le pion appartient au joueur 2
                    dessiner_cercle(x_milieu, y_milieu, 15, 'yellow') #on dessine un cercle jaune
                if Pions[x][y] == 10: #si c'est une dame qui appartient au joueur 1
                    #on dessine un cercle rouge avec un anneau noir à l'interieur
                    dessiner_cercle(x_milieu, y_milieu, 15, 'red')
                    dessiner_cercle(x_milieu, y_milieu, 10, 'black')
                    dessiner_cercle(x_milieu, y_milieu, 9, 'red')
                if Pions[x][y] == 20: #si c'est une dame qui appartient au joueur 2
                    #on dessine un cercle jaune avec un anneau noir à l'interieur
                    dessiner_cercle(x_milieu, y_milieu, 15, 'yellow')
                    dessiner_cercle(x_milieu, y_milieu, 10, 'black')
                    dessiner_cercle(x_milieu, y_milieu, 9, 'yellow')

def initialisation_pion(): #fonction qui reinitialise la position des pions
    global position_pion #la liste position_pion contient pour chaque case du damier une information : 0 pour une case vide, 1/2 pour un pion du joueur 1/2 ou 10/20 pour une dame du joueur 1/2

    #on reinitialise la position des pions sur le damier
    position_pion =\
    [[1, 0, 1, 0, 0, 0, 2, 0, 2, 0],
    [0, 1, 0, 1, 0, 0, 0, 2, 0, 2],
    [1, 0, 1, 0, 0, 0, 2, 0, 2, 0],
    [0, 1, 0, 1, 0, 0, 0, 2, 0, 2],
    [1, 0, 1, 0, 0, 0, 2, 0, 2, 0],
    [0, 1, 0, 1, 0, 0, 0, 2, 0, 2],
    [1, 0, 1, 0, 0, 0, 2, 0, 2, 0],
    [0, 1, 0, 1, 0, 0, 0, 2, 0, 2],
    [1, 0, 1, 0, 0, 0, 2, 0, 2, 0],
    [0, 1, 0, 1, 0, 0, 0, 2, 0, 2]]

    placePions(position_pion) #On affiche les pions

def test_victoire():  # fonction qui verifie si un des joueurs a gagné
    #on cree 2 listes "temporaires"
    liste_test_j1 = []
    liste_test_j2 = []

    for x in range(10): # On test pour chaque colone
        if 1 in position_pion[x] or 10 in position_pion[x]: # Si aucun pion n'est dans la colonne, on ajoute un False
            liste_test_j1.append(False)

        elif 2 in position_pion[x] or 20 in position_pion[x]: #Si aucun pion n'est dans la colonne, on ajoute un False
            liste_test_j2.append(False)

    if True not in liste_test_j1: # Si dans liste_test_j1, il y a que des True, alors aucun pion du joueur 1 n'est sur le damier
        return False # Ainsi, on arrete de jouer
    elif True not in liste_test_j2: #Si dans liste_test_j2, il y a que des True, alors aucun pion du joueur 2 n'est sur le damier
        return False # Ainsi, on arrete de jouer
    else:
        return True #Ainsi, on continue à jouer

def select(clic): # Fonction qui traite les clics de la souris sur le damier
    global selected, ligne, colonne #on rends les variables selected, ligne et colonne globales de facon à éviter les erreurs "NameError: name 'variable' is not defined"

    if started == False: #on verifie que l'on a bien commencé une partie (et donc que les pionts sont bien mis en place)
        showinfo('Erreur', 'Veuillez commencez une partie en cliquant sur le bouton en bas à droite')
        return None # on quitte la fonction select

    if selected == False: # selected est une variable booléenne qui permet de savoir si le pion(ou la dame) que l'on veut deplacer a été selectionné
        if est_dans_le_damier(clic): # On verifie que le clic se trouve sur le damier
            ligne = clic.x // case # On calcule la partie entiere dans la division de clic.x par case, cela nous permet de transformer les coordonnés du clic (en pixel) en indice pour la liste position_pion
            colonne = clic.y // case # On calcule la partie entiere dans la division de clic.y par case
            if position_pion[ligne][colonne] == 0: # Si la case est vide, alors aucun pion n'est selectionne et on s'arrete
                return None # on quitte la fonction select
            elif position_pion[ligne][colonne] != joueur_qui_joue and position_pion[ligne][colonne] != joueur_qui_joue *10: # Si la case n'est pas vide et qu'il y a un pion qui n'appartient pas au joueur qui joue, alors le pion n'appartient pas au joueur qui joue
                showinfo('Erreur', 'Ce n\'est pas votre pion')
                return None # on quitte la fonction select
            selected = True #Sinon, le piont position_pion[ligne][colonne] a été selectionné

    else: #On attend qu'une case soit selectionnee:
        if est_dans_le_damier(clic): # On verifie que le second clic se trouve sur le damier
            ligne_arrivee = clic.x // case # On calcule la partie entiere dans la division de clic.x par case, cela nous permet de transformer les coordonnés du clic (en pixel) en indice pour la liste position_pion
            colonne_arrivee = clic.y // case # On calcule la partie entiere dans la division de clic.y par case
            if ligne_arrivee == ligne and colonne_arrivee == colonne: # Si on reclic le pion sélectionné, alors
                selected = False #on deselectionne le pion
                return None # on quitte la fonction select

            nature_deplacement = verification_deplacement(ligne, colonne, ligne_arrivee, colonne_arrivee) #on verifie le type de deplacement en utilisant la fonction verification_deplacement puis on stocke le resultat dans une variable (pour ne pas avoir à reappeler la fonction)
            if nature_deplacement == 'Deplacement invalide': # Si le deplacement a été qualifié d'invalide
                showinfo("Erreur", "Déplacement invalide") # On affiche une fenetre qui informe le joueur
                selected = False # On deselectionne le pion
                return None # on quitte la fonction select

            elif nature_deplacement == 'Deplacement valide': # Si le deplacement a été qualifié de valide (pion qui se déplace)
                position_pion[ligne][colonne] = 0 #On enlève le pion au point de départ
                if detection_transformation(joueur_qui_joue, colonne_arrivee): # on vérifie que le pion ne doit pas se transformer en dame
                    position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue*10 #si le pion doit se transformer en dame on fait *10 pour obtenir 10 ou 20, soit les differentes "codes" pour les dames
                else:
                    position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue #Sinon on place un pion normal à l'endroit où le pion de déplace
                damier() #on réaffiche le damier (par dessus)
                placePions(position_pion) #on réaffiche les pions (par dessus)
                tour_suivant() #on passe au tour suivant
                selected = False #on deselectionne le pion
                return None # on quitte la fonction select


            elif nature_deplacement == 'Un pion est mangé': #Si le deplacement constitue un pion mange un autre pion(ou dame)
                #On calcule les coordonnées de la dame ou du pion mangé en calculant le milieu entre le point de départ et le point d'arrivée
                x_dame_mangee = (ligne + ligne_arrivee) / 2
                y_dame_mangee = (colonne + colonne_arrivee) / 2
                position_pion[ligne][colonne] = 0 #On enlève la dame au point de départ
                position_pion[x_dame_mangee][y_dame_mangee] = 0 # On enleve la dame mangée
                if detection_transformation(joueur_qui_joue, colonne_arrivee): # on vérifie que le pion ne doit pas se transformer en dame
                    position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue*10 #si le pion doit se transformer en dame on fait *10 pour obtenir 10 ou 20, soit les differentes "codes" pour les dames
                else:
                    position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue #Sinon on place un pion normal à l'endroit où le pion de déplace
                damier( )#on réaffiche le damier (par dessus)
                placePions(position_pion)
                etat_partie = test_victoire() #on vérifie si un des joueurs a gagné et on stocke le resultat dans une variable
                if etat_partie: #si un joueur a gagné, alors on affiche quel joueur a gagné puis on ferme la fenetre quand on a cliqué sur OK
                    showinfo('Victoire', liste_des_joueurs[joueur_qui_joue] + ' a gagné la partie')
                    fen.destroy()
                else: # Sinon, on dis que le joueur qui joue a mangé un pion
                    showinfo('Alerte','Un pion est mangé, le joueur : ' + liste_des_joueurs[joueur_qui_joue] + ' rejoue.')
                    selected = False #on deselectionne le pion
                    return None # on quitte la fonction select

            elif nature_deplacement == 'Deplacement dame valide': #Si le deplacement est un deplacement de dame et qu'il est valide (auncun pion/dame mangé)
                position_pion[ligne][colonne] = 0  # On enlève le pion au point de départ
                position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue * 10 # On remet la dame à l'endroit d'arrivé
                damier() #on affiche le damier (par dessus)
                placePions(position_pion) #on affiche les pions (par dessus)
                tour_suivant() #on passe au tour suivant
                selected = False #on deselectionne le pion
                return None # on quitte la fonction select

            elif 'Deplacement dame mange et valide' in nature_deplacement: #si le resultat comprend 'Deplacement dame mange et valide'
                nature_deplacement = nature_deplacement[36:] #on enleve "Deplacement dame mange et valide. x=' de la string retournée par la fonction verification_deplacement()
                coord_x_du_point_mange = int(nature_deplacement[:1]) #on prend donc le 1er caractere de la string retourné, on le passe en entier (car on l'utilise comme un indice de liste) et on le stock dans une variable
                nature_deplacement = nature_deplacement[5:] #on enleve "x. y=" de la string
                coord_y_du_point_mange = int(nature_deplacement[:1]) #on prend donc le 1er caractere de la string retourné, on le passe en entier (car on l'utilise comme un indice de liste) et on le stock dans une variable
                position_pion[ligne][colonne] = 0 #on enleve la dame à l'endroit avant qu'elle bouge
                position_pion[coord_x_du_point_mange][coord_y_du_point_mange] = 0 # on enleve le pion mangé
                position_pion[ligne_arrivee][colonne_arrivee] = joueur_qui_joue * 10 # on rajoute la dame après son déplacement
                damier()  # on affiche le damier (par dessus)
                placePions(position_pion)  # on affiche les pions (par dessus)
                etat_partie = test_victoire()  # on vérifie si un des joueurs a gagné et on stocke le resultat dans une variable
                if etat_partie:  # si un joueur a gagné, alors on affiche quel joueur a gagné puis on ferme la fenetre quand on a cliqué sur OK
                    showinfo('Victoire', liste_des_joueurs[joueur_qui_joue] + ' a gagné la partie')
                    fen.destroy()
                else:  # Sinon, on dis que le joueur qui joue a mangé un pion
                    showinfo('Alerte','Un pion est mangé, le joueur : ' + liste_des_joueurs[joueur_qui_joue] + ' rejoue.')
                    selected = False  # on deselectionne le pion
                    return None  # on quitte la fonction select

def detection_transformation(joueur_qui_joue, y): #fonction qui renvoit True si le pion est arrivée au bout du damier et False sinon
    if joueur_qui_joue == 1 and y == 9: #si le pion appartient au joueur 1 et qu'il est en bas du damier
        return True #on renvoit True
    elif joueur_qui_joue == 2 and y == 0: #si le pion appartient au joueur 2 et qu'il est en haut du damier
        return True #on renvoit True
    else: #sinon
        return False #on renvoit False

def tour_suivant():
    global joueur_qui_joue #on rends la variable joueur_qui_joue globale de facon à éviter les erreurs "NameError: name 'variable' is not defined"

    if joueur_qui_joue == 1: #si le joueur 1 est entrain de jouer
        joueur_qui_joue = 2 # C'est au tour du joueur 2
    elif joueur_qui_joue == 2: #si le joueur 2 est entrain de jouer
        joueur_qui_joue = 1 # C'est au tour du joueur 1

    showinfo('Tour', 'C\'est le tour de ' + liste_des_joueurs[joueur_qui_joue]) # On affiche un message pour dire quel joueur doit jouer

def verification_deplacement(depart_x, depart_y, arrivee_x, arrivee_y): #On verifie la validite du deplacement, quel est le type de pion qui se déplace (pion ou dame) et si un pion/dame est mangé.
    global un_pion_est_deja_mange_par_ce_deplacement, x_piont_mange, y_piont_mange

    #1ère etape, on calcule les valeurs de déplacements sur les différentes variables
    deplacement_en_x = arrivee_x - depart_x
    deplacement_en_y = arrivee_y - depart_y
    deplacement_en_x = abs(deplacement_en_x) # On utilise la fonction valeur absolue pour determiner le deplacement en x
    deplacement_en_y = abs(deplacement_en_y) # On utilise la fonction valeur absolue pour determiner le deplacement en y

    if position_pion[depart_x][depart_y] >  5: # Si le pion est une dame, alors on a soit 10>5 soit 20>5 (donc ce n'est pas un pion normal)
        pion_normal = False
    else:
        pion_normal = True
    if pion_normal == True: #Si les règles de déplacement sont celles d'un piont
        if deplacement_en_x == 0 or deplacement_en_y == 0: # Un pion ne peut pas rester statique et donc le deplacement n'est pas valide
            return 'Deplacement invalide'
        if deplacement_en_y > 1 or deplacement_en_x > 1: #Valable uniquement dans le cas où on "mange" une dame
            if deplacement_en_x != 2 or deplacement_en_y != 2: #On vérifie que le deplacement correspond bien à un cas où on mange une dame
                return 'Deplacement invalide'

            else:
                joueur_qui_mange = position_pion[depart_x][depart_y] #on vérifie quel est le joueur qui mange
                # On calcule les coordonnées de la dame mangee en calculant le milieu entre le point de départ et le point d'arrivée
                x_dame_mangee = (depart_x + arrivee_x) / 2
                y_dame_mangee = (depart_y +
                                 arrivee_y) / 2
                if position_pion[x_dame_mangee][y_dame_mangee] == 0: # on vérifie que l'on ne mange pas une case vide
                    return 'Deplacement invalide'
                elif position_pion[x_dame_mangee][y_dame_mangee] == joueur_qui_mange: # On vérifie que l'on ne mange pas un pion de son propre camp
                    return 'Deplacement invalide'
                elif position_pion[arrivee_x][arrivee_y] != 0: #On vérifie qu'il n'y ai pas de pion à l'endroit où on veut aller (par dessus le pion qu'on mange)
                    return 'Deplacement invalide'
                else: # Sinon le deplacement est valide et correspond à un pion qui mange
                    return 'Un pion est mangé'

        else: #dans le cas où on ne mange pas de dame
            if position_pion[arrivee_x][arrivee_y] == 0: #on verifie que la case est libre
                #ce bloc vérifie que si aucun pion n'est mangé, alors le déplacement en bien "vers l'avant" (en fonction du joueur)
                if joueur_qui_joue == 1:
                    if arrivee_y > depart_y:
                        return 'Deplacement valide' # On valide le déplacement
                    else:
                        return 'Deplacement invalide'
                elif joueur_qui_joue == 2:
                    if arrivee_y < depart_y:
                        return 'Deplacement valide'
                    else:
                        return 'Deplacement invalide'
            else:
                return 'Deplacement invalide'

    elif pion_normal == False:
        if deplacement_en_x == 0 or deplacement_en_y == 0: # Un pion ne peut pas rester statique et donc le deplacement n'est pas valide
            print(3)
            return 'Deplacement invalide'
        if deplacement_en_x == deplacement_en_y: #on vérifie si le deplacement est bien en diagonal
            print(1)
            if position_pion[arrivee_x][arrivee_y] == 0: #on verifie que la case est libre d'arrivé est libre
                un_pion_est_deja_mange_par_ce_deplacement = False #on définit que pour l'instant aucun pion n'est mangé
                #donc les coordonnées sont nulles
                x_piont_mange = -1
                y_piont_mange = -1

                while depart_x != arrivee_x and depart_y != arrivee_y: #on vérifie que chaque case entre le point de départ et le point d'arrivé ne contienent pas de pion de son camp et uniquement un seul pion adverse (à l'aide de la varible un_pion_est_deja_mange_par_ce_deplacement)
                    #on vérifie pour chaque cas de déplacement en diagonal
                    if depart_x > arrivee_x and depart_y > arrivee_y:
                        depart_x -= 1
                        depart_y -= 1
                        verification_deplacement_dame(depart_x,depart_y)
                    elif depart_x < arrivee_x and depart_y < arrivee_y:
                        depart_x += 1
                        depart_y += 1
                        verification_deplacement_dame(depart_x, depart_y)
                    elif depart_x > arrivee_x and depart_y < arrivee_y:
                        depart_x -= 1
                        depart_y += 1
                        verification_deplacement_dame(depart_x, depart_y)
                    elif depart_x < arrivee_x and depart_y > arrivee_y:
                        depart_x += 1
                        depart_y -= 1
                        verification_deplacement_dame(depart_x, depart_y)
                if un_pion_est_deja_mange_par_ce_deplacement == True: #Si uniquement un pion est mangé par le deplacement,
                    return 'Deplacement dame mange et valide. x=' + str(x_piont_mange) + '. y=' + str(y_piont_mange) #alors on renvoit 'Deplacement dame mange et valide' et les coordonnéss du pion mangé pour qu'il soit traité plus tard
                else:
                    return 'Deplacement dame valide' #Si aucun pion n'est mangé, alors le déplacement est valide
            else:
                print(1)
                return 'Deplacement invalide'
        else:
            return 'Deplacement invalide'

def verification_deplacement_dame(depart_x, depart_y):
    global un_pion_est_deja_mange_par_ce_deplacement, x_piont_mange, y_piont_mange #on rends les variables un pion_est_deja_mange_par_ce_deplacement, x_piont_mange et y_piont_mange globales de facon à éviter les erreurs "NameError: name 'variable' is not defined"

    if position_pion[depart_x][depart_y] != 0:  # Si la case n'est pas libre
        if position_pion[depart_x][depart_y] == joueur_qui_joue or position_pion[depart_x][depart_y] == joueur_qui_joue * 10: #si il y a un pion ou une dame du même camp que nous sur la case que nous testons
            return 'Deplacement invalide'
        else:
            if un_pion_est_deja_mange_par_ce_deplacement == True: #si la case n'est pas libre et qu'un piont a déjà été mangé, alors il y a au moins deux pions sur la trajectoire
                return 'Deplacement invalide'
            else:
                un_pion_est_deja_mange_par_ce_deplacement = True #si c'est le premier pion qu'on mange, on stocke ses coordonnées
                x_piont_mange = depart_x
                y_piont_mange = depart_y

def est_dans_le_damier(clic):
    if clic.y <= 800 and clic.x <= 800: #si le clic se situe dans un carré de 800 par 800 donc une des arrêtes est le coin en haut à gauche de la fenetre
        return True
    else:
        return False

###PROGRAMME PRINCPAL###

fen = Tk() # Lance la fenêtre
fen.title("Jeu de Dame")
fen.resizable(width=False, height=False) # On désactive les modifications de taille de la fenetre pour éviter les complications avec l'enregistrement des clics

can = Canvas(fen, width=800, height=800, bg="red") # On dimensione la fenetre par un carré de 800 pixels et on y met un fond rouge
can.bind("<Button-1>", select)
can.pack(side=TOP, padx=5, pady=5) # Un rebord de 5 pixels

b1 = Button(fen, text="DAMONIUM !", command=start_game) # Le bouton DAMONIUM situé en bas à droite lance la fonciton start_game
b1.pack(side=RIGHT)

b2 = Button(fen, text="Quitter", command=fen.destroy)# Bouton en bas à gauche qui ferme la fenêtre
b2.pack(side=LEFT)

joueur_qui_joue = 1 # C'est au joueur 1 de jouer en premier
started = False # La partie n'a pas encore commencé
case = 80 # On dimensione la case ici pour pouvoir l'utiliser partout
selected = False # Rien n'est selectioné
damier() # Affiche le damier
can.bind("<Button-1>", select)
fen.mainloop()  # dernière instruction du programme : enclenche la réception d'événements