Problème valeur avec TkInter

Signaler
-
 trifou -
Bonjour, je suis un débutant (je suis élève de première) et j'aurais besoins d'aide sur un programme que je me suis mis le defi de réaliser.
Je tente de programmer un jeu de puissance4 qui fonctionne en utilisant la seule fonction "print" pour faire l'affichage du jeu. Mais en essayant de faire une fenêtre TkInter pour l'affichage du jeu, je rencontre un problème de valeur ( en l’occurrence, sur la valeur du joueur à qui c'est le tour, pouvant être 1 ou 2). Je pense que le problème viens du fait du fonctionnement de TkInter qui n'est pas "compatible" avec mon programme. Je sollicite donc l'aide des vétérans de pythons pour résoudre mon problème, merci d’avance à ceux qui prendront le temps d'y réfléchir (et surtout de lire mon programme, il est assez long et brouillon car je débute).

Le programme qui fonctionne sans Tkinter:

line1=[0,0,0,0,0,0,0,0,0,0]   #tableau de jeu (+3 colonne systeme a droite)
line2=[0,0,0,0,0,0,0,0,0,0]
line3=[0,0,0,0,0,0,0,0,0,0]
line4=[0,0,0,0,0,0,0,0,0,0]
line5=[0,0,0,0,0,0,0,0,0,0]
line6=[0,0,0,0,0,0,0,0,0,0]
blank=[0,0,0,0,0,0,0,0,0,0]
################################################################################
cl=255      #colonne choisie
p=2         #tour du joueur 1 ou 2
w=0         #partie terminée ou non
lp=0        #dernier coup joué"[ligne][colonne][joueur]"
y=0         #coordonnées dernier coups
x=0
ps=0        #playersystem (utilisé dans coordonnées)
chcktbl=[0,0,0,0,0,0,0,0,0,0]
################################################################################
def placement(x):  #fonction de placement de piece pour la colonne x
    if line6[x]==0:
        if p==1:
            line6[x]=3
            lp=601+(10*x)
        elif p==2:
            line6[x]=5
            lp=602+(10*x)
    else:
        if line5[x]==0:
            if p==1:
                line5[x]=3
                lp=501+(10*x)
            elif p==2:
                line5[x]=5
                lp=502+(10*x)
        else:
            if line4[x]==0:
                if p==1:
                    line4[x]=3
                    lp=401+(10*x)
                elif p==2:
                    line4[x]=5
                    lp=402+(10*x)
            else:
                if line3[x]==0:
                    if p==1:
                        line3[x]=3
                        lp=301+(10*x)
                    elif p==2:
                        line3[x]=5
                        lp=302+(10*x)
                else:
                    if line2[x]==0:
                        if p==1:
                            line2[x]=3
                            lp=201+(10*x)
                        elif p==2:
                            line2[x]=5
                            lp=202+(10*x)
                    else:
                        if line1[x]==0:
                            if p==1:
                                line1[x]=3
                                lp=101+(10*x)
                            elif p==2:
                                line1[x]=5
                                lp=102+(10*x)
                        else:
                            print("colonne pleine, changer de choix")
                            lp=-1
    return lp
################################################################################
def line(x):    #utilisé dans check(coord)
    if x==6:
        return line6
    elif x==5:
        return line5
    elif x==4:
        return line4
    elif x==3:
        return line3
    elif x==2:
        return line2
    elif x==1:
        return line1
    else:
        return blank

def check(coord):       #vérifie si le coup est gagnant
    y=coord//100
    x=(coord-((coord//100)*100))//10
    ps=(coord-((coord//100)*100))-(((coord-((coord//100)*100))//10)*10)
    checktbl=[line(y)[x-3],line(y)[x-2],line(y)[x-1],line(y)[x],line(y)[x+1],line(y)[x+2],line(y)[x+3]]
    w=tblcheck(ps,checktbl)
    if w==1:
        return w
    checktbl=[line(y+3)[x],line(y+2)[x],line(y+1)[x],line(y)[x],line(y-1)[x],line(y-2)[x],line(y-3)[x]]
    w=tblcheck(ps,checktbl)
    if w==1:
        return w
    checktbl=[line(y+3)[x-3],line(y+2)[x-2],line(y+1)[x-1],line(y)[x],line(y-1)[x+1],line(y-2)[x+2],line(y-3)[x+3]]
    w=tblcheck(ps,checktbl)
    if w==1:
        return w
    checktbl=[line(y+3)[x+3],line(y+2)[x+2],line(y+1)[x+1],line(y)[x],line(y-1)[x-1],line(y-2)[x-2],line(y-3)[x-3]]
    w=tblcheck(ps,checktbl)
    return w


def tblcheck(ps,checktbl):        #analyse les séries de cases en recherche de 4 de suite
    w=0
    if ps==1:
        if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==12:
            w=1
            print("partie remporté par le joueur 1")
        elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==12:
            w=1
            print("partie remporté par le joueur 1")
        elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==12:
            w=1
            print("partie remporté par le joueur 1")
        elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==12:
            w=1
            print("partie remporté par le joueur 1")
    elif ps==2:
        if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==20:
            w=1
            print("partie remporté par le joueur 2",)
        elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==20:
            w=1
            print("partie remporté par le joueur 2")
        elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==20:
            w=1
            print("partie remporté par le joueur 2")
        elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==20:
            w=1
            print("partie remporté par le joueur 2")
    return w
################################################################################
#éxécution du programme
while w!=1:       #vérifie si la partie est finie ou non
    cl=int(input("colonne séléctionnée (entrée valide: 1,2,3,4,5,6,7")) #choix du coup à jouer

    lp=placement(cl-1)                                                   #effectue le placement du choix
    if lp!=-1:
        w=check(lp)
        if p==1:
            p=2
        elif p==2:
            p=1
        colo=[1,2,3,4,5,6,7]
        print("\n \n \n")
        print("",colo)
        print("",line1,"\n",line2,"\n",line3,"\n",line4,"\n",line5,"\n",line6)





Le programme avec Tkinter que je n'arrive pas à faire fonctionner:

line1=[0,0,0,0,0,0,0,0,0,0]   #tableau de jeu (+3 colonne systeme a droite)
line2=[0,0,0,0,0,0,0,0,0,0]
line3=[0,0,0,0,0,0,0,0,0,0]
line4=[0,0,0,0,0,0,0,0,0,0]
line5=[0,0,0,0,0,0,0,0,0,0]
line6=[0,0,0,0,0,0,0,0,0,0]
blank=[0,0,0,0,0,0,0,0,0,0]


cl=255      #colonne choisie
p=1         #joueur
w=0         #partie terminée ou non
lp=0        #dernier coup joué"[ligne][colonne][joueur]"
y=0         #coordonnées dernier coups
x=0
ps=0
textentry=0
chcktbl=[0,0,0,0,0,0,0,0,0,0]  #zone mémoire

def line(x):
    if x==6:
        return line6
    elif x==5:
        return line5
    elif x==4:
        return line4
    elif x==3:
        return line3
    elif x==2:
        return line2
    elif x==1:
        return line1
    else:
        return blank




def click():
    player=1
    try:
        player=r
    except NameError:
        player=p
    else:
        player=r
    colonne=''
    colonne=textentry.get()
    textentry.delete(0,END)
    if colonne=='1' or colonne=='2' or colonne=='3' or colonne=='4' or colonne=='5' or colonne=='6' or colonne=='7':
        cl=int(colonne)
        if cl>=1 and cl<=7:
            lp=-1
            cl=cl-1
            if line6[cl]==0:
                if player==1:
                    line6[cl]=3
                    lp=601+(10*cl)
                elif player==2:
                    line6[cl]=5
                    lp=602+(10*cl)
            else:
                if line5[cl]==0:
                    if player==1:
                        line5[cl]=3
                        lp=501+(10*cl)
                    elif player==2:
                        line5[cl]=5
                        lp=502+(10*cl)
                else:
                    if line4[cl]==0:
                        if player==1:
                            line4[cl]=3
                            lp=401+(10*cl)
                        elif player==2:
                            line4[cl]=5
                            lp=402+(10*cl)
                    else:
                        if line3[cl]==0:
                            if player==1:
                                line3[cl]=3
                                lp=301+(10*cl)
                            elif player==2:
                                line3[cl]=5
                                lp=302+(10*cl)
                        else:
                            if line2[cl]==0:
                                if player==1:
                                    line2[cl]=3
                                    lp=201+(10*cl)
                                elif player==2:
                                    line2[cl]=5
                                    lp=202+(10*cl)
                            else:
                                if line1[cl]==0:
                                    if player==1:
                                        line1[cl]=3
                                        lp=101+(10*cl)
                                    elif player==2:
                                        line1[cl]=5
                                        lp=102+(10*cl)
                                else:
                                    print("colonne pleine, changer de choix")
                                    lp=-1

            y=lp//100
            x=(lp-((lp//100)*100))//10
            ps=(lp-((lp//100)*100))-(((lp-((lp//100)*100))//10)*10)
            checktbl=[line(y)[x-3],line(y)[x-2],line(y)[x-1],line(y)[x],line(y)[x+1],line(y)[x+2],line(y)[x+3]]
            w=0
            if ps==1:
                if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==12:
                    w=1
                    print("partie remporté par le joueur 1")
                elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==12:
                    w=1
                    print("partie remporté par le joueur 1")
                elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==12:
                    w=1
                    print("partie remporté par le joueur 1")
                elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==12:
                    w=1
                    print("partie remporté par le joueur 1")
            elif ps==2:
                if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==20:
                    w=1
                    print("partie remporté par le joueur 2",)
                elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==20:
                    w=1
                    print("partie remporté par le joueur 2")
                elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==20:
                    w=1
                    print("partie remporté par le joueur 2")
                elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==20:
                    w=1
                    print("partie remporté par le joueur 2")
            if w==0:
                checktbl=[line(y+3)[x],line(y+2)[x],line(y+1)[x],line(y)[x],line(y-1)[x],line(y-2)[x],line(y-3)[x]]
                if ps==1:
                    if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==12:
                        w=1
                        print("partie remporté par le joueur 1")
                    elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==12:
                        w=1
                        print("partie remporté par le joueur 1")
                    elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==12:
                        w=1
                        print("partie remporté par le joueur 1")
                    elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==12:
                        w=1
                        print("partie remporté par le joueur 1")
                elif ps==2:
                    if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==20:
                        w=1
                        print("partie remporté par le joueur 2",)
                    elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==20:
                        w=1
                        print("partie remporté par le joueur 2")
                    elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==20:
                        w=1
                        print("partie remporté par le joueur 2")
                    elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==20:
                        w=1
                        print("partie remporté par le joueur 2")
                if w==0:
                    checktbl=[line(y+3)[x-3],line(y+2)[x-2],line(y+1)[x-1],line(y)[x],line(y-1)[x+1],line(y-2)[x+2],line(y-3)[x+3]]
                    if ps==1:
                        if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==12:
                            w=1
                            print("partie remporté par le joueur 1")
                        elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==12:
                            w=1
                            print("partie remporté par le joueur 1")
                        elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==12:
                            w=1
                            print("partie remporté par le joueur 1")
                        elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==12:
                            w=1
                            print("partie remporté par le joueur 1")
                    elif ps==2:
                        if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==20:
                            w=1
                            print("partie remporté par le joueur 2",)
                        elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==20:
                            w=1
                            print("partie remporté par le joueur 2")
                        elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==20:
                            w=1
                            print("partie remporté par le joueur 2")
                        elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==20:
                            w=1
                            print("partie remporté par le joueur 2")
                    if w==0:
                        checktbl=[line(y+3)[x+3],line(y+2)[x+2],line(y+1)[x+1],line(y)[x],line(y-1)[x-1],line(y-2)[x-2],line(y-3)[x-3]]
                        if ps==1:
                            if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==12:
                                w=1
                                print("partie remporté par le joueur 1")
                            elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==12:
                                w=1
                                print("partie remporté par le joueur 1")
                            elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==12:
                                w=1
                                print("partie remporté par le joueur 1")
                            elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==12:
                                w=1
                                print("partie remporté par le joueur 1")
                        elif ps==2:
                            if (checktbl[0])+(checktbl[1])+(checktbl[2])+(checktbl[3])==20:
                                w=1
                                print("partie remporté par le joueur 2",)
                            elif (checktbl[1])+(checktbl[2])+(checktbl[3])+(checktbl[4])==20:
                                w=1
                                print("partie remporté par le joueur 2")
                            elif (checktbl[2])+(checktbl[3])+(checktbl[4])+(checktbl[5])==20:
                                w=1
                                print("partie remporté par le joueur 2")
                            elif (checktbl[3])+(checktbl[4])+(checktbl[5])+(checktbl[6])==20:
                                w=1
                                print("partie remporté par le joueur 2")
            print("",line1,"\n",line2,"\n",line3,"\n",line4,"\n",line5,"\n",line6)
            if w==1:
                print("Le joueur {} l'emporte!".format(player))
            if player==1:
            	player=2
            elif player==2:
            	player=1




def quitter():
    window.destroy()
    quit()



from tkinter import *
window=Tk()
pasdepion=PhotoImage(file="D:\puissance 4 data\pasdepion.gif")
pionjaune=PhotoImage(file="D:\puissance 4 data\pionjaune.gif")
pionrouge=PhotoImage(file="D:\puissance 4 data\pionrouge.gif")
for z in range (0,7):
    for f in range(0,6):
        Label(window,image=pasdepion,bg="blue").grid(row=f,column=z,sticky=W)
window.title("Puissance 4")
window.configure(background="black")
textentry= Entry(window,width=10,bg="white")
textentry.grid(row=0,column=8,sticky=W)
Label (window, text="Choisissez une colonne (1,2,3,4,5,6 ou 7):",bg="black",fg="white",font="none 12 bold").grid(row=0,column=7,sticky=W)
Label (window, text="Joueur {}".format(p),bg="black",fg="white",font="none 16 bold").grid(row=3,column=7,sticky=N)
Button(window, text="Confirmer",width=9,command=click).grid(row=1,column=7,sticky=N)
Button(window, text="Quitter",width=7,command=quitter).grid(row=5,column=8,sticky=S)
window.mainloop()

3 réponses

Messages postés
9677
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
21 février 2020
532
bonjour, peux-tu expliquer ce qu'est "un problème de valeur"?
Le problème est dans la fonction "click()" déclenché par le bouton sur le fenêtre TkInter.

Quand la valeur "p" est actualisée dans la fonction pour passer au joueur 2(p=2), à la prochaine exécution de click(), la valeur p reste 1. Je suppose que l'erreur viens du mainloop(). J'ai tenté beaucoup de choses pour régler le problème mais avec mes connaissances je trouve pas.
Je ferai un détail plus précis du problème ce soir quand je serai chez moi.
yg_be
Messages postés
9677
Date d'inscription
lundi 9 juin 2008
Statut
Contributeur
Dernière intervention
21 février 2020
532 > NaXoS
Bonjour,

Que c'est laborieux.

Pourquoi ne pas avoir utiliser un tableau plutôt que x listes ?
Un tableau aurait permis de te passer de toutes ces conditions des line*.

try:
    player=r
except NameError:
    player=p
else:
    player=r


Le else ne sert à rien, puis ce n'est pas une très bonne pratique de faire cela (NameError).

#tableau de jeu (+3 colonne systeme a droite)


Quel est le but de rajouter 3 colonnes non exploitables dans ces lignes ?
Cela représente quoi des "colonnes système" ?
Alors , je n'ai pas utilisé de tableau car je ne sais pas encore m'en servir ^^ (je suis novice).
Je sais que le except n'est pas joli mais c'est simplement que c'était mon dernier test avant que j'arrête de trifouiller.
Et les colonnes système sont utilisés lorsque je vérifie si un coup est gagnant, avec le checktbl qui, si ces trois colonnes ne sont pas présentes, me met une erreur de index out of range, et c'est la seule solution à laquelle j'ai pensé.
Je sais que ce n'est pas agréable d'essayer de comprendre un programme pas très beau, c'est sympa de me donner un peu de ton temps :)
> NaXoS
Un tableau en python, c'est une liste de listes, si tu sais manipuler les listes alors tu n'auras aucun mal à manipuler un tableau.

Ok, tu as ajouté des colonnes pour palier aux IndexError, ce serait mieux de trouver et comprendre pourquoi ça plante ^^

Le problème n'a pas vraiment à voir si c'est agréable à lire ou non, mais qu'il va être difficile à partir de ton 1er code de garder quelque chose pour programmer ton jeu avec tkinter.
> trifou
D'accord, je ne suis pas pressé je peux refaire un programme compatible avec TkInter, juste je n'ai pas vraiment d'idée d'une autre manière de faire le programme qui marcherait avec Tk, une idée de la trame à suivre ?
> NaXoS
La trame à suivre est d'utiliser des fonctions et dans la programmation séquentielle séparer logique du code du reste.

Dans la logique du code, il y aurait par exemple une fonction déterminant si un alignement existe, une fonction insérant un pion dans telle colonne.

Dans le reste, il y aurait une fonction affichant la grille, une fonction demandant dans quelle colonne le joueur veut jouer son pion en gérant les erreurs.

Je peux te montrer un simple code partant de cela tenant en une 100aine de lignes, mais comme c'est pas commenté et que j'ai la flemme de le faire, pas certain que tu le comprennes.
> trifou
D'accord merci de l'aide, et en effet comme j'ai réalisé ce code afin d'apprendre et non pour un objectif, je préfère réaliser moi même le code plutôt que d'essayer de comprendre un code trop avancé pour moi, je laisse le forum ouvert si je rencontre d'autres impasses lors de mon parcours.
J'ai retravaillé le code et je suis arrivé à ca (le code fonctionne), si vous avez des idées pour le rendre plus "propre", je prends.
from tkinter import *

########## Initialise des listes ##########
j=[]
entree=[0]
coup=[]
memoire=[]

########## Crée la grille de jeu ##########
def grille():
    ligne0=[0,0,0,0,0,0,0,0,0,0]
    ligne1=[0,0,0,0,0,0,0,0,0,0]
    ligne2=[0,0,0,0,0,0,0,0,0,0]
    ligne3=[0,0,0,0,0,0,0,0,0,0]
    ligne4=[0,0,0,0,0,0,0,0,0,0]
    ligne5=[0,0,0,0,0,0,0,0,0,0]
    vide=  [0,0,0,0,0,0,0,0,0,0]
    tableau=[ligne0,ligne1,ligne2,ligne3,ligne4,ligne5,vide,vide,vide]
    return tableau

########## Détermine le joueur ##########
def joueur():
    if len(j)%2==1:
        return 1
    elif j==[]:
        return 1
    else:
        return 2

########## Place dans le tableau le pion (mémoire et affichage) ##########
def placement(colonne,joueur):
    col=colonne-1
    for o in range(5,-1,-1):
        if tableau[o][col]==0:
            if joueur==1:
                tableau[o][col]=3
                Label(window,image=pionjaune,bg="blue").grid(row=o,column=colonne-1,sticky=W)
                Label (window, text="   Joueur 2    ",bg="black",fg="white",font="none 16 underline").grid(row=2,column=7,sticky=N)
                coup.append(o)
                coup.append(col)
                if o==0:
                    Label (window, text=" X ",bg="black",fg="red",font="none 16 bold").grid(row=6,column=col,sticky=N)
                    entree.append(0)
                break
            elif joueur==2:
                tableau[o][col]=5
                Label(window,image=pionrouge,bg="blue").grid(row=o,column=colonne-1,sticky=W)
                Label (window, text="   Joueur 1    ",bg="black",fg="white",font="none 16 underline").grid(row=2,column=7,sticky=N)
                coup.append(o)
                coup.append(col)
                if o==0:
                    Label (window, text=" X ",bg="black",fg="red",font="none 16 bold").grid(row=6,column=col,sticky=N)
                    entree.append(0)
                break

########## Modification sur la fenêtre quand la partie se termine ##########
def partifini():
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=0,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=1,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=2,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=3,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=4,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=5,sticky=N)
    Label (window, text="     ",bg="black",font="none 16 bold").grid(row=6,column=6,sticky=N)
    Label (window, text="       ",bg="black",font="none 16 bold").grid(row=7,column=3,sticky=N)
    Label (window, text="            ",bg="black",font="none 16 bold").grid(row=3,column=7,sticky=N)
    Label (window, text="Le joueur {} gagne!".format(joueur()),bg="black",fg="green",font="none 16 bold").grid(row=2,column=7,sticky=N)

########## Vérifie si un coup est gagnant (étape 2) ##########
def verification2(memoire):
    if (memoire[0])+(memoire[1])+(memoire[2])+(memoire[3])==12:
            partifini()
    elif (memoire[1])+(memoire[2])+(memoire[3])+(memoire[4])==12:
            partifini()
    elif (memoire[2])+(memoire[3])+(memoire[4])+(memoire[5])==12:
            partifini()
    elif (memoire[3])+(memoire[4])+(memoire[5])+(memoire[6])==12:
            partifini()
    elif (memoire[0])+(memoire[1])+(memoire[2])+(memoire[3])==20:
            partifini()
    elif (memoire[1])+(memoire[2])+(memoire[3])+(memoire[4])==20:
            partifini()
    elif (memoire[2])+(memoire[3])+(memoire[4])+(memoire[5])==20:
            partifini()
    elif (memoire[3])+(memoire[4])+(memoire[5])+(memoire[6])==20:
            partifini()

########## Vérifie si un coup est gagnant (étape 1) ##########
def verification(y,x):
    memoire=[tableau[y][x-3],tableau[y][x-2],tableau[y][x-1],tableau[y][x],tableau[y][x+1],tableau[y][x+2],tableau[y][x+3]]
    verification2(memoire)
    memoire=[tableau[y+3][x],tableau[y+2][x],tableau[y+1][x],tableau[y][x],tableau[y-1][x],tableau[y-2][x],tableau[y-3][x]]
    verification2(memoire)
    memoire=[tableau[y+3][x-3],tableau[y+2][x-2],tableau[y+1][x-1],tableau[y][x],tableau[y-1][x+1],tableau[y-2][x+2],tableau[y-3][x+3]]
    verification2(memoire)
    memoire=[tableau[y+3][x+3],tableau[y+2][x+2],tableau[y+1][x+1],tableau[y][x],tableau[y-1][x-1],tableau[y-2][x-2],tableau[y-3][x-3]]
    verification2(memoire)

########## Fil conducteur ##########
def deroulement():
    choix=entree[-1]
    if choix>=1 and choix<=7:
        j.append(0)
        placement(choix,joueur())
        verification(coup[-2],coup[-1])
        entree.append(0)
        Label (window, text="                  ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)
    else:
        Label (window, text="Colonne invalide",bg="black",fg="red",font="none 12 bold").grid(row=3,column=7,sticky=N)

########## Fonctions différents boutons ##########
def click0():
    entree.append(1)
    Label (window, text="      Colonne 1      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click1():
    entree.append(2)
    Label (window, text="      Colonne 2      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click2():
    entree.append(3)
    Label (window, text="      Colonne 3      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click3():
    entree.append(4)
    Label (window, text="      Colonne 4      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click4():
    entree.append(5)
    Label (window, text="      Colonne 5      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click5():
    entree.append(6)
    Label (window, text="      Colonne 6      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def click6():
    entree.append(7)
    Label (window, text="      Colonne 7      ",bg="black",fg="white",font="none 12 bold").grid(row=3,column=7,sticky=N)

def quitter():
    window.destroy()
    print("Partie finie")
    quit()

########## Création fenêtre de jeu ##########
tableau=grille()
window=Tk()
pasdepion=PhotoImage(file="F:\puissance 4 data\pasdepion.gif")
pionjaune=PhotoImage(file="F:\puissance 4 data\pionjaune.gif")
pionrouge=PhotoImage(file="F:\puissance 4 data\pionrouge.gif")
for z in range (0,7):
    for f in range(0,6):
        Label(window,image=pasdepion,bg="blue").grid(row=f,column=z,sticky=W)
window.title("Puissance 4")
window.configure(background="black")
Label (window, text="   Joueur {}     ".format(joueur()),bg="black",fg="white",font="none 16 underline").grid(row=2,column=7,sticky=N)
Button(window, text=" 1 ",width=3,command=click0).grid(row=6,column=0,sticky=N)
Button(window, text=" 2 ",width=3,command=click1).grid(row=6,column=1,sticky=N)
Button(window, text=" 3 ",width=3,command=click2).grid(row=6,column=2,sticky=N)
Button(window, text=" 4 ",width=3,command=click3).grid(row=6,column=3,sticky=N)
Button(window, text=" 5 ",width=3,command=click4).grid(row=6,column=4,sticky=N)
Button(window, text=" 6 ",width=3,command=click5).grid(row=6,column=5,sticky=N)
Button(window, text=" 7 ",width=3,command=click6).grid(row=6,column=6,sticky=N)
Button(window, text="Valider",width=5,command=deroulement).grid(row=7,column=3,sticky=S)
Button(window, text="Quitter",width=7,command=quitter).grid(row=7,column=7,sticky=SE)
print("Partie lancee")
window.mainloop()




  • Il faut bien sur rajouter une images de pions rouge, jaune et pas de pion chez vous, car je ne peux pas attacher les miennes en pièces jointes.
Bonjour,

Beaucoup de choses à revoir, la première étant d'absolument régler ce problème d'IndexError si on définit la dimension de la grille à ce qu'elle devrait être, une liste de 6 listes de 7 zéros.

def grille():
    return [[0] * 7 for _ in range(6)]


Il est nécessaire de centraliser les clics sur une seule fonction, pour cela on utilise une fermeture (closure en anglais), le principe est de retourner la référence d'une fonction.

Supprime toutes tes fonctions click* et déclare une fonction click.

def click(col):
    def _click():
        entree.append(col)
        text = "      Colonne {}      ".format(col)
        lbl = Label(window, text=text, bg="black", fg="white", font="none 12 bold")
        lbl.grid(row=3,column=7,sticky=N)
    return _click


Puis au lieu de créer tes boutons de colonnes un à un

Button(window, text=" 1 ",width=3,command=click0).grid(row=6,column=0,sticky=N)
Button(window, text=" 2 ",width=3,command=click1).grid(row=6,column=1,sticky=N)
Button(window, text=" 3 ",width=3,command=click2).grid(row=6,column=2,sticky=N)
Button(window, text=" 4 ",width=3,command=click3).grid(row=6,column=3,sticky=N)
Button(window, text=" 5 ",width=3,command=click4).grid(row=6,column=4,sticky=N)
Button(window, text=" 6 ",width=3,command=click5).grid(row=6,column=5,sticky=N)
Button(window, text=" 7 ",width=3,command=click6).grid(row=6,column=6,sticky=N)


Fais cela dans une boucle en passant un appel à la fonction click avec le n° de colonne en paramètre.

for i in range(7):
    text = " {} ".format(i + 1)
    bt = Button(window, text=text, width=3, command=click(i + 1))
    bt.grid(row=6, column=i, sticky=N)


Revois aussi cette nouvelle fonction _click, chaque fois tu crées un nouveau label, alors que tu devrais définir le label pour l'affichage de la colonne choisie hors de cette fonction, et dans la fonction _click simplement changer le text de ce label avec la méthode configure.
> trifou
Bonjour, le problème c'est que ma fonction qui regarde si un coup joué est gagnant va vérifier les valeurs situé en x-1 , x-2 et x-3 ( pareil pour y, sur x abscisse et y ordonné de la grille) si la colonne sélectionné est 0, x-3 donne indice de recherche[ -3] et il va donc vérifier la 3 eme valeur en partant de la fin de la liste, ce qui ne crée pas d'indexerror mais juste une incohérence de vérification (la partie pourrais alors se terminer avec 2 pions alignés avec 2 autres pions de l'autre côté de la grille tel que: x-x-0-0-0-x-x les x etants les pions).La manière de régler ce problème d'index négatif est de rajouter en index de mes listes des valeurs tampons en [-1], [-2] et [-3] (aussi référencés par [7], [8] et [9]). J'ai cherché en refaisant le programme à résoudre ce problème d'une autre manière mais après quelques heures, j'ai repris le principe de mon ancien programme pour la grille.

Pour les autres points cités, je vais me documenter sur le sujet et réécrire les parties à modifier.
> NaXoS
Bonjour,

Et qu'est-ce qui t'empêche de mettre des points d'arrêts si tu n'es plus entre les index 0 et 6 ?

On commence par faire un test sur une simple liste.

l = [1, 0, 0, 0, 1, 1, 1]


Le dernier coup joué est à l'index 5

colonne = 5
valeur_pion = l[colonne]


Comment vérifier que quatre 1 sont alignés ?
On commence par définir les extrémités de la liste jusqu'où regarder

index_min = colonne - 3
if index_min < -1: # -1 et non 0 car le range n'inclus pas la dernière valeur
    index_min = -1
index_max = colonne + 3
if index_max > 7: # 7 et non 6 car le range n'inclus pas la dernière valeur
    index_max = 7


Puis on comptabilise le nombre de valeur_pion dans les 2 directions
nombre_alignes = 1 # pion de départ
# Vers la gauche
for i in range(colonne - 1, index_min, -1):
    if l[i] != valeur_pion:
        # Valeur différente du pion, inutile de continuer
        break
    nombre_alignes += 1
# Vers la droite
for i in range(colonne + 1, index_max):
    if l[i] != valeur_pion:
        break
    nombre_alignes += 1

print(nombre_alignes)


Si tu arrives à comprendre ça, il te restera à faire la même chose pour les alignements verticaux et diagonaux.