Bonjour à tous, 

Suite à un problème de placement de pions je me retrouve aujourd'hui à vous redemander votre aide concernant le déplacement des pions. En effet Après avoir réaliser mon interface graphique, mon damier, mon placement des pions ainsi que les tests de déplacement (inséré dans un widget Text), je souhaite désormais comme tout bon jeu de dames qui se respecte pouvoir bouger mes pions, cependant je ne vois pas comment réaliser cette prouesse.

Je m'explique, je souhaiterais dans un premier temps lorsque je clique sur un pions du damier que celui-ci fasse apparaître des pions d'une autres couleur correspondant aux déplacements possible. 

Dans un second temps j'aimerais que lorsque je clique sur l'un de ces pions l'autre disparaisse et que le pion à déplacer  fasse place au pion cliqué par l'utilisateur, autrement dit un déplacement avec un choix visuel .

 si mon code est mal présenté je m'en excuse.

Si vous avez une quelconque question concernant ce que je cherche à faire n'hésitez pas. Je précise que j'ai essayé plusieurs chose mais je n'arrive pas à m'y retrouver dans les méthodes possibles en python (j'utilise le module tkinter).

Je vous remercie d'avance.

-
Edité par supral 1 avril 2014 à 8:59:03

Salut, je n'ai pas regardé ton code dans le détail, cela dit tu devrais pouvoir décomposer ton problème en plusieurs étapes :

• afficher dans la console les coordonnées d'un pion lorsque tu cliques dessus dans la grille.

• appeler une méthode avec ces coordonnées qui :

  • sauvegarde la grille actuelle (grille réelle),

  • ajoute des pions de couleur correspondant aux deplacements possibles depuis la case passée en argument,

  • affiche la grille temporaire

• ajouter dans ton programme un système de "modes" :

  • le mode "sélection" dans lequel un clic sur un pion sélectionne celui-ci et passe au mode validation en affichant ses déplacements possibles,

  • le mode "validation" dans lequel un clic sur une case réalise le déplacement en mettant à jour la grille réelle si l'utilisateur a cliqué sur un déplacement possible, ou bien restore la grille réelle et revient au mode sélection si l'utilisateur a cliqué ailleurs.

Ça s'implémente avec un simple booléen.

GLHF.

-
Edité par nohar 21 mars 2014 à 9:18:54

Bonjour,

je vois très bien ce que tu me propose toutefois il y a quelques points que je ne sais pas comment réaliser. 

Le premier point pour afficher des pions en fonctions des possibilités j'y arrive en effet j'affiche les possibilités en créant des cercles.

Cependant les 2 autres points je ne vois pas du tout comment les réaliser c'est à dire pour stocker dans mes variables les nouvelles coordonnée du pions sélectionné ou encore pour supprimer les coordonnées du pions que l'on veut déplacer.

un problème que j'ai est que je n'arrive pas à écrire de condition de booléen car je n'arrive pas à réutiliser mes coordonnée car ce sont des int ainsi je me retrouve avec un message d'erreur:

TypeError: argument of type 'int' is not iterable

de plus je me retrouve avec l'erreur suivante (AttributeError: 'int' object has no attribute 'delete'

) quand je cherche à supprimer une des possibilités représenté par des pions auxquelles j'ai donné les noms suitvant ( hautgauche ou hautdroit) . 

Dans le code ci-dessous qui ne représente qu'une partie ciblé du code je calcule dans un premier temps les possibilités de jeux pour un pion cliqué. Et je fait ainsi apparaitre des pions si les conditions sont respecté , et je créer un .bind sur mon damier pour que si je clique dans le damier cela lance la fonction deplacementBlancs qui si hautgauche est vrai je supprime l'autre possibilité. je n'y arrive toutefois pas. J'ai un problème de int de base je pense.

Si par exemple je veux réaliser le booléen en reprenant les coordonnée d'un clic dans la valeur coord je ne peut pas:

if coord in hautgauche:## hautgauche étant un cercle je me retrouve avec une erreur
    actions à réaliser

def deplacementsBlancs(event):
    if hautgauche:
        damier.delete(hautdroit)
    testCases()
    
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
                damier.bind("<Button-1>",deplacementsBlancs)    

            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
                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,"")

Grossomodo les points que je n'ai pas reussis à comprendre sont ceux-ci:

• nohar a écrit:

  • appeler une méthode avec ces coordonnées qui :

    • sauvegarde la grille actuelle (grille réelle),
    • ajoute des pions de couleur correspondant aux deplacements possibles depuis la case passée en argument,
    • affiche la grille temporaire

  • ajouter dans ton programme un système de "modes" :

    • le mode "sélection" dans lequel un clic sur un pion sélectionne celui-ci et passe au mode validation en affichant ses déplacements possibles,
    • le mode "validation" dans lequel un clic sur une case réalise le déplacement en mettant à jour la grille réelle si l'utilisateur a cliqué sur un déplacement possible, ou bien restore la grille réelle et revient au mode sélection si l'utilisateur a cliqué ailleurs.

  -

Je me pose quelques questions comme par exemple , comment peut ont écrire ce genre d'évenement:

if hautgauche.bind():### hautgauche permet la création d'un pions respectant la possibilité d'aller en haut à gauche

    actions à effectuer

Voici le processus qui me semble logique mais que je n'arrive malheureusement pas à créer:

• A partir des fonction de test de déplacement je créer des cercles représentant les possibilités ( ça je l'ai fait)
• Ensuite SI un utilisateur clique sur une possibilité les coordonnées du pions cliqué viennent s'ajouter à la liste de variables et le pion de départ et l'autre possibilités disparaissent tout en supprimant les coordonnées du pions d'origine.(Je ne vois pas comment faire du tout en fonction de mon code) 
• Seulement SI un utilisateur clique autre part que dans les possibilités on supprime les pions possibilités.(  je ne vois pas comment faire étant donné que je n'arrive pas à vérifier avec un booléen la position du pion possibilité, j'avais pensé à un if not in hautgauche: mais cela me renvoie une erreur car le cerlce hautgauche n'est pas un int)
• Ensuite on réactualise les variable pour afficher le nouveau damier(Je ne sais pas comment recharger les valeurs sans relancer toutes les fonctions depuis le début) 

Si tu pouvais me montrer en pseudo code à partir de ma fonction test la marche à suivre pour la réalisation cela me serait d'une grande aide.

Si je n'ai pas été assez clair ou pas assez précis je m'en excuse je reste à l'écoute pour tes eventuelles questions ou conseils. 

Merci de ta réponse.

-
Edité par supral 21 mars 2014 à 21:17:36

Bonjour, 

je viens d'avancer un peu mais malheureusement je suis bloqué. En effet à partir de mes fonctions de test de déplacement je réalise le processus suivant:

• Je créer mes pions de possibilités et je les ajoutes avec append dans une liste vide 

Cependant je voudrais par la suite testé si l'utilisateur à cliqué ailleurs que dans les possibilités les possibilités se suppriment. si l'utilisateur clique sur une possibilité l'autre possibilité disparait avec le pions de départ.

Malheureusement je n'arrive pas à réaliser ces test.

j'avais essayé ça mais rien ne marche:

########################
#### Importations ######
########################

from tkinter import *
from tkinter.simpledialog import *
from tkinter.messagebox import showerror

#########################
### 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()

J'attendrai avec impatience votre aide.

Merci d'avance.

-
Edité par supral 22 mars 2014 à 13:18:41