# Créé par alexandc, le 03/04/2014
from __future__ import division
from lycee import *



#########################
### Variables globales###
#########################
player1=''
player2=''
started=True

#########################################################################
############################# Fonctions principales #####################
#############################                       #####################
#########################################################################


##### Les fonctions pions1 et pions2 permettent l'affichage des pions sur le damier
def pions1():
    global pionsNoirs,black
    x,j=0,0
    for y, x in pionsNoirs:
        damier.create_oval(x*dimension_case, y*dimension_case, (x+1)*dimension_case, (y+1)*dimension_case,outline='white', fill="#623005")## Pions Noirs

def pions2():
    global pionsblanc,white
    x,j=0,0

    for y, x in pionsBlancs:
        damier.create_oval(x*dimension_case, y*dimension_case, (x+1)*dimension_case, (y+1)*dimension_case,outline='black', fill="#D78A46")## Pions Blancs



##### La fonction generateDamier permet l'affichage du damier
def generateDamier():

    i=0
    while i<sizeDamier:
        j=0
        while j<sizeDamier:
            if i%2==0:
                if j%2==0:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#E49E60")## Couleur foncé
                else:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case,fill="#623005")## Couleur claire
            else:
                if j%2==0:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#623005")
                else:
                    damier.create_rectangle(j*dimension_case, i*dimension_case, (j*dimension_case)+dimension_case, (i*dimension_case)+dimension_case, fill="#E49E60")
            j+=1
        i+=1
        pions1()
        pions2()

##### Les fonctions damier8 et damier10 permettent l'affichage d'un damier de 8X8 10X10 ou encore 12X12 cases
def damier8():
    global dimension_case, sizeDamier, rangee_pions,damier,x0,y0,c,nb,casesBlanches,casesNoires, pionsNoirs,pionsBlancs,casesDamier,provisoireBlancs
    dimension_case=75##600/8
    sizeDamier=8
    rangee_pions=3
    nb= 8# nombre de cases (grille carree)
    c=75
    x0,y0=0,0

    pionsNoirs=[   [0,1],[0,3],[0,5],[0,7],
                   [1,0],[1,2],[1,4],[1,6],
                   [2,1],[2,3],[2,5],[2,7]]

    casesDamier=[  [0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],
                   [1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],
                   [2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],
                   [3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],
                   [4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],
                   [5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],
                   [6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],
                   [7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7] ]


    casesNoires=[  [0,1],[0,3],[0,5],[0,7],
                   [1,0],[1,2],[1,4],[1,6],
                   [2,1],[2,3],[2,5],[2,7],
                   [3,0],[3,2],[3,4],[3,6],
                   [4,1],[4,3],[4,5],[4,7],
                   [5,0],[5,2],[5,4],[5,6],
                   [6,1],[6,3],[6,5],[6,7],
                   [7,0],[7,2],[7,4],[7,6]]

    pionsBlancs=[  [5,0],[5,2],[5,4],[5,6],
                   [6,1],[6,3],[6,5],[6,7],
                   [7,0],[7,2],[7,4],[7,6]]

    provisoireBlancs=[]


    generateDamier()

def damier10():
    global dimension_case, sizeDamier, rangee_pions,damier,nb,c,x0,y0,casesBlanches,casesNoires,pionsNoirs,pionsBlancs,casesDamier,provisoireBlancs
    dimension_case=60## 600/15
    sizeDamier=10
    rangee_pions=4
    nb=10
    c=60## Tailles des cases d'un damier en 10*10
    x0,y0=0,0

    pionsNoirs=[   [0,1],[0,3],[0,5],[0,7],[0,9],
                   [1,0],[1,2],[1,4],[1,6],[1,8],
                   [2,1],[2,3],[2,5],[2,7],[2,9],
                   [3,0],[3,2],[3,4],[3,6],[3,8]]

    casesDamier=[  [0,0],[0,1],[0,2],[0,3],[0,4],[0,5],[0,6],[0,7],[0,8],[0,9],
                   [1,0],[1,1],[1,2],[1,3],[1,4],[1,5],[1,6],[1,7],[1,8],[1,9],
                   [2,0],[2,1],[2,2],[2,3],[2,4],[2,5],[2,6],[2,7],[2,8],[2,9],
                   [3,0],[3,1],[3,2],[3,3],[3,4],[3,5],[3,6],[3,7],[3,8],[3,9],
                   [4,0],[4,1],[4,2],[4,3],[4,4],[4,5],[4,6],[4,7],[4,8],[4,9],
                   [5,0],[5,1],[5,2],[5,3],[5,4],[5,5],[5,6],[5,7],[5,8],[5,9],
                   [6,0],[6,1],[6,2],[6,3],[6,4],[6,5],[6,6],[6,7],[6,8],[6,9],
                   [7,0],[7,1],[7,2],[7,3],[7,4],[7,5],[7,6],[7,7],[7,8],[7,9],
                   [8,0],[8,1],[8,2],[8,3],[8,4],[8,5],[8,6],[8,7],[8,8],[8,9],
                   [9,0],[9,1],[9,2],[9,3],[9,4],[9,5],[9,6],[9,7],[9,8],[9,9]]



    casesNoires=[  [0,1],[0,3],[0,5],[0,7],[0,9],
                   [1,0],[1,2],[1,4],[1,6],[1,8],
                   [2,1],[2,3],[2,5],[2,7],[2,9],
                   [3,0],[3,2],[3,4],[3,6],[3,8],
                   [4,1],[4,3],[4,5],[4,7],[4,9],
                   [5,0],[5,2],[5,4],[5,6],[5,8],
                   [6,1],[6,3],[6,5],[6,7],[6,9],
                   [7,0],[7,2],[7,4],[7,6],[7,8],
                   [8,1],[8,3],[8,5],[8,7],[8,9],
                   [9,0],[9,2],[9,4],[9,6],[9,8]]


    pionsBlancs=[  [6,1],[6,3],[6,5],[6,7],[6,9],
                   [7,0],[7,2],[7,4],[7,6],[7,8],
                   [8,1],[8,3],[8,5],[8,7],[8,9],
                   [9,0],[9,2],[9,4],[9,6],[9,8]]

    provisoireBlancs=[]

    generateDamier()


def deplacementsBlancs(event):

    if [y,x] not in provisoireBlancs:
        damier.delete(hautdroit)
        damier.delete(hautgauche)

    if [y,x] in provisoireBlancs[y-1,x+1]:
        damier.delete(hautgauche)

def deplacementpossiblesBlancs():
    global hautdroit,hautgauche

############TEST possibilitées
    ### Possibilités pionsBlancs
    if[y,x] in pionsBlancs:
        t1.delete("0.0",END)

        ## Déplacement pionsBlancs en haut à droite
        if [y-1,x+1] in casesNoires:
            if [y-1,x+1]not in( pionsNoirs and pionsBlancs):
                t1.insert(END,"(coup haut droite )+")

                hautdroit=damier.create_oval((x+1)*dimension_case, (y-1)*dimension_case, (x+2)*dimension_case, (y)*dimension_case,outline='white', fill="green")## Pions Noirs
                provisoireBlancs.append([y-1,x+1])
                print(provisoireBlancs)
                damier.bind("<Button-1>",deplacementsBlancs)


##                pionsBlancs.remove([y,x])
##                pionsBlancs.append([y,x])
##                print(pionsBlancs)


            if [y-1,x+1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")



        ## Déplacement pionsBlancs en haut à gauche
        if [y-1,x-1] in casesNoires:
            if [y-1,x-1]not in( pionsNoirs and pionsBlancs):
                t1.insert(END,"(coup haut gauche)+")


                hautgauche=damier.create_oval((x-1)*dimension_case, (y-1)*dimension_case, (x)*dimension_case, (y)*dimension_case,outline='white', fill="red")## Pions Noirs
                provisoireBlancs.append([y-1,x-1])
                print(provisoireBlancs)

                damier.bind("<Button-1>",deplacementsBlancs)




            if [y-1,x-1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")


        ## Si ce n'est pas dans une cases noire déplacement impossible
        if [y-1,x+1] not in casesNoires:
                t1.insert(END,"")


def deplacementpossibleNoirs():

    ## possibilitées pionsNoirs
    if[y,x] in pionsNoirs:
        t1.delete("0.0",END)

        ## Déplacement pionsNoirs en bas à droite
        if [y+1,x+1] in casesNoires:
            if [y+1,x+1]not in( pionsNoirs or pionsBlancs):
                t1.insert(END,"(coup bas droite )")

            if [y+1,x+1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")



        ## Déplacement pionsNoirs en bas à gauche
        if [y+1,x-1] in casesNoires:
            if [y+1,x-1]not in( pionsNoirs or pionsBlancs):
                t1.insert(END,"(coup bas gauche )")
            if [y+1,x-1] in (pionsBlancs or pionsNoirs):
                t1.insert(END,"")





### Detection des coordonnées
# fonction de correspondance
def correspond(x,y):
    global  damier,mainFen,texto,coord
    return((y-y0)//c,(x-x0)//c)

def ecrire(event):
    global  damier,mainFen,texto ,sizeDamier,dimension_case,coord,x,y

    t.delete("0.0",END)
    t1.delete("0.0",END)
    (i,j)=correspond(event.x,event.y)
    if i in range(nb) and j in range (nb):
        t.insert(END,"click dans la case  ou i  et j vallent " + str(int(i)) + "," + str(int(j)))
    coord=[i,j]
    y=i
    x=j


    testCases()


def testCases():

    if started:
        deplacementpossiblesBlancs()


    if not started :
        deplacementpossibleNoirs()

######################################################################################
####################################                     #############################
#################################### INTERFACE GRAPHIQUE #############################
######################################################################################


def graphInterface():


    global mainFen,texto,dimension_case,damier,t1,t,t2

    mainFen=Tk()
    mainFen.title("Jeu de Dame")


    ###### Demande aux joueurs leurs noms
    player1 = askstring("Initialisation de la partie", "Joueur 1 (pions blancs) :" )
    player2 = askstring("Initialisation de la partie", "Joueur 2 (pions noirs) :")

    while (not player1 and not player2)or(not player1 or not player2) :
        false=showerror('Saisie incorrecte', 'Votre saisie est incorrecte veuillez recommencer')
        player1 = askstring("Initialisation de la partie", "Joueur 1 (pions blancs) :" )
        player2 = askstring("Initialisation de la partie", "Joueur 2 (pions noirs) :")

###### Label score Noirs
    scoreNoirs=Label(mainFen,text=player2+' :(score noir) : ',fg='#4E2E12',width=75,font = "Arial 22 bold italic",bg='#D78A46')
    scoreNoirs.pack()
    t2=Text(mainFen,height=1,width=60,bg="light grey",font=("comic",18,"bold"))
    t2.pack
##### Canvas du damier
    damier=Canvas(mainFen, width=600, height=600, bg="#4E2E12",relief='solid', borderwidth=4)
    damier.pack()

    scoreBlancs=Label(mainFen, text=player1+' :(score blanc) : ', fg='#D78A46',relief='sunken',width=75,font = "Arial 22 bold italic",bg='#4E2E12')
    scoreBlancs.pack()

    boutonNewGame=Button(mainFen, text="Nouvelle Partie", command=newGame)
    boutonNewGame.pack(side=LEFT)

    boutonQuitter=Button(mainFen, text="Quitter", command=mainFen.destroy)
    boutonQuitter.pack(side=RIGHT)

    b2=Button(mainFen,text="Commencer la partie",command=plateauSize)
    b2.pack()

    t1=Text(mainFen,height=1,width=60,bg="light grey",font=("comic",18,"bold"))
    t1.pack()
    t=Text(mainFen ,height=1,width=40,bg="light grey",font=("comic",18,"bold"))
    t.pack()

    damier.bind("<Button-1>",ecrire)
    ######################
    ### Menu en cascade###
    ######################
    menuCascading = Menu(mainFen)  ## Créer la barre de menu


    menuFile = Menu(menuCascading)
    menuCascading.add_cascade(label = "Fichier", menu=menuFile)
    menuFile.add_command(label="Nouvelle partie",command=newGame )
    menuFile.add_command(label="Quitter", command=mainFen.destroy)


    menuConfig=Menu(menuCascading)
    menuCascading.add_cascade(label = "Configuration", menu=menuConfig)
    menuConfig.add_command(label="Taille du plateau", command=plateauSize)

    menuSauvegarde=Menu(menuCascading)
    menuCascading.add_cascade(label = "Sauvegarde", menu=menuSauvegarde)
    menuSauvegarde.add_command(label="Sauvegarder partie", command=plateauSize)
    menuSauvegarde.add_command(label="Charger partie", command=plateauSize)

    menuInfo=Menu(menuCascading)
    menuCascading.add_cascade(label = "Informations", menu=menuInfo)
    menuInfo.add_command(label="Règles du jeu ", command=Regles)

    mainFen.config(menu = menuCascading)


    mainFen.mainloop()



## Règles du jeu

def Regles():
    regle=Tk()
    regle.title('Règles du jeu ')
    regle.geometry('1000x1000+150+150')
    ##  lecture du fichier test.txt qui contient les règles du jeu de dames

    f=open('regle.txt','r')
    data=f.read()

    texte=Text(regle,fg='blue',bg='grey',width=100,height=40)
    texte.insert(END, data)
    texte.pack()

    boutonQuitter=Button(regle, text="Quitter", command=regle.destroy)
    boutonQuitter.pack(side=BOTTOM)

## paramètre de la taille du plateau

def plateauSize():
    plateau=Tk()
    plateau.title('Paramètres du damier')
    plateau.geometry("225x150+785+50")
    def afterPlateauSize8():
        plateau.destroy()
        damier8()
    def afterPlateauSize10():
        plateau.destroy()
        damier10()

    bouton8=Button(plateau, text="Damier de 8 X 8 cases", command=afterPlateauSize8)
    bouton8.pack(pady=15)

    bouton10=Button(plateau, text="Damier de 10 X 10 cases", command=afterPlateauSize10)
    bouton10.pack(pady=15)

    boutonQuitter=Button(plateau, text="Quitter", command=plateau.destroy)
    boutonQuitter.pack()

    plateau.mainloop()





## Accueil du jeux demandant de choisir si l'on souhaite jouer contre une personne ou contre l'ordinateur

def accueil():
    accueil = Tk()
    accueil.title("Page d'accueil")
    accueil.geometry("367x330+785+230")

    ## La fonction afteraccueil permet de tuer le processus de la fenètre actuelle tout en lançant la fonction d'une autre fenètre
    def afteraccueil():
        accueil.destroy()
        graphInterface()



    ####### Fond d'écran de la page d'accueil
    image=Canvas(accueil,width="801",height="801")
    photo = PhotoImage(file= "DECO62.gif")
    image.create_image(40,90,image=photo)
    image.grid(row=0, column=0, rowspan=12,columnspan=12)


    humanvshuman=Button(text='Joueur contre Joueur',command=afteraccueil,font = "Arial 19 bold italic")
    humanvshuman.grid(row=1,column=1)

    humanvsmachine=Button(text='Joueur contre ordinateur',command=afteraccueil,font = "Arial 19 bold italic")
    humanvsmachine.grid(row=2,column=1)

    boutonQuitter=Button(accueil, text="Quitter", command=accueil.destroy,font = "Arial 19 bold italic")
    boutonQuitter.grid(row=3,column=1)


    accueil.mainloop()



## Fonction qui relance la partie
def newGame():
    mainFen.destroy()
    accueil()


### TEST
accueil()