Projet ISN Pac-man

Fermé
Lily1611 Messages postés 5 Date d'inscription mardi 13 mars 2018 Statut Membre Dernière intervention 8 mai 2018 - Modifié le 21 avril 2018 à 01:05
 critou - 27 avril 2018 à 10:17
Bonjour !

Voilà j'aurais besoin d'aide pour mon projet en ISN pour le bac. Avec mon groupe, nous avons décidé de créer un pac-man simplifié mais nous bloquons quand au déplacement du Pac-Man dans le labyrinthe. Ce dernier est censé se déplacer grâce aux touches directionnelles, mais lorsqu'on les utilise, c'est comme si le Pac-Man parcourait tout le labyrinthe. De plus, je ne comprends pas pourquoi les billes jaunes sont décalées. Si quelqu'un pouvait nous aider, ça serait vraiment gentil. Nous aimerions bien terminer ce jeu ! Merci d'avance ! Je joins les captures d'écran prise juste après l'exécution du programme et la seconde lorsque l'on appuie sur une des touches directionnelles.




Voici notre code : ( bien entendu il manque les fonctions des fantômes)

    #création de la grille qui servira comme support au jeux
    G=[[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1],
        [7, 7, 7, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 7, 7, 7],
        [1, 1, 1, 1, 0, 1, 0, 1, 7, 7, 7, 7, 1, 0, 1, 0, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 1, 6, 4, 3, 5, 1, 0, 0, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1],
        [7, 7, 7, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 1, 7, 7, 7],
        [1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1],
        [1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1],
        [1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] 
        
    def dessine_pacman(p):
    
        r=10

        zf.draw_fill_circle(p,r,jaune)
        a= Point(p.x-1, p.y+3)
        b= Point(p.x+12,p.y+2)
        c= Point(p.x+20, p.y+12)
        zf.draw_fill_triangle(a,b,c,noir)
        
        e=Point(p.x-4,p.y-5)
        zf.draw_fill_circle(e,4,blanc)
        
    
        g=Point(p.x-4,p.y-4)
        zf.draw_fill_circle(g,2,noir)
    
        h=Point(p.x+4,p.y-5)
        zf.draw_fill_circle(h,4,blanc)
    
        i=Point(p.x+4,p.y-4)
        zf.draw_fill_circle(i,2,noir)
        

    def deplacement (event):
        global i,j
        global l
        for i in range (20):
            for j in range (25):
                p=Point(39*i,29*j)
                if event.keysym=='Right' and G[j][i]==2 and G[j][i+1]==0:
                    G[j][i+1]==2
                    G[j][i]==0
                elif event.keysym=='Left' and G[j][i]==2 and G[j][i-1]==0:
                    G[j][i-1]==2
                    G[j][i]==0
                elif event.keysym=='Up' and G[j][i]==2 and G[j-1][i]==0:
                    G[j-1][i]==2
                    G[j][i]==0
                elif event.keysym=='Down' and G[j][i]==2 and G[j+1][i]==0:
                    G[j+1][i]==2
                    G[j][i]==0
                    
                    
                elif event.keysym=='Right' and G[j][i]==2 and G[j][i+1]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Left' and G[j][i]==2 and G[j][i-1]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Up' and G[j][i]==2 and G[j-1][i]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Down' and G[j][i]==2 and G[j+1][i]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                    
        dessine_pacman(p)

    def dessine_grille(G):
        global p
        global w
        global u
        global t
        for i in range (20):
            for j in range (25):
                if G[j][i]==1:
                    #correspond à un mur
                    zf.draw_rectangle(Point(35*i,28*j), Point(35*i+35, 28*j+28), blue)
                elif G[j][i]==2:
                    #correspond au pacman
                    p=Point(39*i,29*j)
                    dessine_pacman(p)
                elif G[j][i]==3: #correspond aux fantômes
                    w=Point(37*i,29*j)
                    fantome_vert(w)
                    #fantome_vert(i, j)
                elif G[j][i]==4:
                    u=Point(37*i,29*j)
                    fantome_rouge(u)
                    #fantome_rouge(i, j)
                elif G[j][i]==5:
                    t=Point(37*i,29*j)
                    fantome_bleu(t)
                    #fantome_bleu(i, j)
                elif G[j][i]==6:
                    s=Point(37*i,29*j)
                    fantome_rose(s)
                    #fantome_rose(i, j)
                elif G[j][i]==0:
                    zf.draw_fill_circle(Point(37*i,29*j),2, yellow)
                elif G[j][i]==7:
                    zf.draw_fill_circle(Point(37*i,29*j),1, black)
                    #correspond pièces
 
    
    #tests

    dessine_grille(G)
    zf.activer_clavier( )
    zf.bind('<Key>',deplacement)
    f.mainloop()

A voir également:

1 réponse

Bonjour.

Il manque trop d'informations dans ton code (Point, zf, etc.) pour que l'on puisse en déterminer les problèmes rencontrés.

Si ton projet est hébergé sur github ou autres hébergeurs de projets, tu pourrais en donner le lien, ça sera plus facile de te donner une solution en testant ton jeu et visualisant ton code en entier que d'essayer de deviner où tes erreurs se situent.
0
Lily1611 Messages postés 5 Date d'inscription mardi 13 mars 2018 Statut Membre Dernière intervention 8 mai 2018
Modifié le 22 avril 2018 à 10:16
Bonjour,

Déjà je voulais vous remercier de prendre la peine d'essayer de m'aider. Quant au site hébergeur, je suis une grande débutante et nous disposons de peu de moyens et de compétences. Nous utilisons uniquement le logiciel python et je ne sais pas comment héberger mon projet. Du coup, je vais mettre le code dans son entièreté ou si vous préférez que je l'héberge, pouvez vous m'indiquez comment faire ? Il y a un générique du début du code : la création de la nouvelle fenêtre est permise avec la fonction début_du_jeu.


from graphics.fenetres import*
from graphics.couleurs import*

#création du générique du jeu

def dessine_pacman(s): #création du Pac-Man
    l=[]
    l.append(zg.draw_fill_circle(s,r,jaune))# corps jaune du Pac-Man
    
    r0=4
    s1=Point(s.x-4,s.y-5)
    l.append(zg.draw_fill_circle(s1,r0,blanc))#oeil gauche 

    b=2
    s2=Point(s.x-4,s.y-4)
    l.append(zg.draw_fill_circle(s2,b,noir))# pupille oeil gauche    

    s3=Point(s.x+4,s.y-5)
    l.append(zg.draw_fill_circle(s3,r0,blanc))# oeil droit


    s4=Point(s.x+4,s.y-4)
    l.append(zg.draw_fill_circle(s4,b,noir))# pupille oeil droit

    s5=Point(s.x-1,s.y+3)
    s6=Point(s.x+12,s.y+2)
    s7=Point(s.x+20,s.y+12)
    l.append(zg.draw_fill_triangle(s5,s6,s7,noir))# bouche
    
    return l
    
def efface_pacman(l): #fonction qui efface le Pac-Man
    for i in l :
        zg.efface (i)


def anim(s,vx,vy): #fonction qui déplace le Pac-Man 
    global l
    s=Point(s.x+vx,s.y+vy)
    efface_pacman(l)
    l=dessine_pacman(s)
    zg.after(40,anim,s,vx,vy)
    

def fantome_rose(p): #création du fantôme rose
    a=[]

    a.append (zg.draw_fill_circle(p,r,lightcoral)) #corps rose du fantôme
    p1=Point(p.x-4,p.y-5)
    a.append(zg.draw_fill_circle(p1,r1,blanc))#oeil gauche

    p2=Point(p.x-4,p.y-4)
    a.append(zg.draw_fill_circle(p2,r2,noir)) #pupille oeil gauche

    p3=Point(p.x+4,p.y-5)
    a.append(zg.draw_fill_circle(p3,r1,blanc))#oeil droit

    p4=Point(p.x+d,p.y+d)
    p5=Point(p.x-d,p.y)
    a.append(zg.draw_fill_rectangle(p4,p5,lightcoral))# corps
   

    p6=Point(p.x+4,p.y-4)
    a.append(zg.draw_fill_circle(p6,r2,noir))#pupille oeil droit

    p7=Point(p.x+d,p.y+d)
    p8=Point(p.x+6,p.y+6)
    p9=Point(p.x+5,p.y+d)
    a.append(zg.draw_fill_triangle(p7,p8,p9,noir))#dentellage du corps

    p10=Point(p.x-d,p.y+d)
    p11=Point(p.x-6,p.y+6)
    p12=Point(p.x-5,p.y+d)
    a.append(zg.draw_fill_triangle(p10,p11,p12,noir))#dentellage du corps

    p13=Point(p.x-4,p.y+d)
    p14=Point(p.x,p.y+6)
    p15=Point(p.x+4,p.y+d)
    a.append(zg.draw_fill_triangle(p13,p14,p15,noir))#dentellage du corps
    
    return a
    
def efface_fantrose(a):#fonction qui efface le fantôme rose
    for i in a:
        zg.efface (i) 
    
def animrose(p,vx,vy):#fonction déplaçant le fantôme rose
    global a
    p=Point(p.x+vx,p.y+vy)
    efface_fantrose(a)
    a=fantome_rose(p)
    zg.after(40,animrose,p,vx,vy)
    


def fantome_bleu(t):#création du fantôme bleu

    b=[]

    b.append(zg.draw_fill_circle(t,r,lightblue))#corps du fantôme
    t1=Point(t.x-4,t.y-5)
    b.append(zg.draw_fill_circle(t1,r1,blanc))#oeil gauche

    t2=Point(t.x-4,t.y-4)
    b.append(zg.draw_fill_circle(t2,r2,noir))#pupille oeil gauche

    t3=Point(t.x+4,t.y-5)
    b.append(zg.draw_fill_circle(t3,r1,blanc))#oeil droit

    t4=Point(t.x+d,t.y+d)
    t5=Point(t.x-d,t.y)
    b.append(zg.draw_fill_rectangle(t4,t5,lightblue))#corps
   

    t6=Point(t.x+4,t.y-4)
    b.append(zg.draw_fill_circle(t6,r2,noir))#pupille oeil droit

    t7=Point(t.x+d,t.y+d)
    t8=Point(t.x+6,t.y+6)
    t9=Point(t.x+5,t.y+d)
    b.append(zg.draw_fill_triangle(t7,t8,t9,noir))#dentellage du corps

    t10=Point(t.x-d,t.y+d)
    t11=Point(t.x-6,t.y+6)
    t12=Point(t.x-5,t.y+d)
    b.append(zg.draw_fill_triangle(t10,t11,t12,noir))#dentellage du corps

    t13=Point(t.x-4,t.y+d)
    t14=Point(t.x,t.y+6)
    t15=Point(t.x+4,t.y+d)
    b.append(zg.draw_fill_triangle(t13,t14,t15,noir))#dentellage du corps

    return b
    
def efface_fantbleu(b):#
    for i in b :
        zg.efface (i)   

    
def animbleu(t,vx,vy):#
    global b    
    t=Point(t.x+vx,t.y+vy)
    efface_fantbleu(b)
    b=fantome_bleu(t)
    zg.after(40,animbleu,t,vx,vy)
    

def fantome_rouge(u):
    
    c=[]
    c.append(zg.draw_fill_circle (u,r,rouge))#corps du fantôme rouge

    u1=Point(u.x-4,u.y-5)
    c.append(zg.draw_fill_circle(u1,r1,blanc))# oeil gauche

    u2=Point(u.x-4,u.y-4)
    c.append(zg.draw_fill_circle(u2,r2,noir)) # pupille oeil gauche

    u3=Point(u.x+4,u.y-5)
    c.append(zg.draw_fill_circle(u3,r1,blanc))#oeil blanc

    u4=Point(u.x+d,u.y+d)
    u5=Point(u.x-d,u.y)
    c.append(zg.draw_fill_rectangle(u4,u5,rouge))#corps
   

    u6=Point(u.x+4,u.y-4)
    c.append(zg.draw_fill_circle(u6,r2,noir)) #pupille oeil droit

    u7=Point(u.x+d,u.y+d)
    u8=Point(u.x+6,u.y+6)
    u9=Point(u.x+5,u.y+d)
    c.append(zg.draw_fill_triangle(u7,u8,u9,noir))#dentellage du corps

    u10=Point(u.x-d,u.y+d)
    u11=Point(u.x-6,u.y+6)
    u12=Point(u.x-5,u.y+d)
    c.append(zg.draw_fill_triangle(u10,u11,u12,noir))#dentellage du corps

    u13=Point(u.x-4,u.y+d)
    u14=Point(u.x,u.y+6)
    u15=Point(u.x+4,u.y+d)
    c.append(zg.draw_fill_triangle(u13,u14,u15,noir))#dentellage du corps

    return c

def efface_fantrouge(c):#fonction qui efface le fantôme rouge
    for i in c :
        zg.efface (i)


def animrouge(u,vx,vy):#fonction qui déplace le fantôme rouge
    global c
    u=Point(u.x+vx,u.y+vy)
    efface_fantrouge(c)
    c=fantome_rouge(u)
    zg.after(40,animrouge,u,vx,vy)
    


def fantome_vert(w):#création du fantôme vert
    
    z=[]
    
    z.append(zg.draw_fill_circle (w,r,vert))#corps du fantôme vert

    w1=Point(w.x-4,w.y-5)
    z.append(zg.draw_fill_circle(w1,r1,blanc)) #oeil gauche  

    w2=Point(w.x-4,w.y-4)
    z.append(zg.draw_fill_circle(w2,r2,noir)) #pupille oeil gauche   

    w3=Point(w.x+4,w.y-5)
    z.append(zg.draw_fill_circle(w3,r1,blanc))#oeil droit

    w4=Point(w.x+d,w.y+d)
    w5=Point(w.x-d,w.y)
    z.append(zg.draw_fill_rectangle(w4,w5,vert))#corps
   

    w6=Point(w.x+4,w.y-4)
    z.append(zg.draw_fill_circle(w6,r2,noir))#pupille oeil droit  

    w7=Point(w.x+d,w.y+d)
    w8=Point(w.x+6,w.y+6)
    w9=Point(w.x+5,w.y+d)
    z.append(zg.draw_fill_triangle(w7,w8,w9,noir))# dentellage du corps

    w10=Point(w.x-d,w.y+d)
    w11=Point(w.x-6,w.y+6)
    w12=Point(w.x-5,w.y+d)
    z.append(zg.draw_fill_triangle(w10,w11,w12,noir))#dentellage du corps

    w13=Point(w.x-4,w.y+d)
    w14=Point(w.x,w.y+6)
    w15=Point(w.x+4,w.y+d)
    z.append(zg.draw_fill_triangle(w13,w14,w15,noir))#dentellage du corps

    return z

def efface_fantvert(z):#fonction qui efface le fantôme vert
    for i in z :
        zg.efface (i)


def animvert(w,vx,vy): #fonction qui déplace le fantôme vert
    global z
    w=Point(w.x+vx,w.y+vy)
    efface_fantvert(z)
    z=fantome_vert(w)
    zg.after(40,animvert,w,vx,vy)
    
        
def debut_du_jeu (): # fonction utilisée lors du clic sur le bouton "Start"
    f.destroy() #destruction du bouton
    f1=Fenetre()#création de la nouvelle fenêtre
    L,H=(700,700)
    zf=f1.graphique(largeur=L,hauteur=H,couleur=noir)
    p=Point(350,16*28)
    
        
    def fantome_vert(w):#création fantôme vert dans le labyrinthe 
        
        zf.draw_fill_circle (w,r,vert)#corps du fantôme vert
    
        w1=Point(w.x-4,w.y-5)
        zf.draw_fill_circle(w1,r1,blanc) #oeil gauche
    
        w2=Point(w.x-4,w.y-4)
        zf.draw_fill_circle(w2,r2,noir)#pupille oeil gauche
    
        w3=Point(w.x+4,w.y-5)
        zf.draw_fill_circle(w3,r1,blanc)#oeil droit
    
        w4=Point(w.x+d,w.y+d)
        w5=Point(w.x-d,w.y)
        zf.draw_fill_rectangle(w4,w5,vert)#corps
    
    
        w6=Point(w.x+4,w.y-4)
        zf.draw_fill_circle(w6,r2,noir)#pupille oeil gauche
    
        w7=Point(w.x+d,w.y+d)
        w8=Point(w.x+6,w.y+6)
        w9=Point(w.x+5,w.y+d)
        zf.draw_fill_triangle(w7,w8,w9,noir)#dentellage du corps
    
        w10=Point(w.x-d,w.y+d)
        w11=Point(w.x-6,w.y+6)
        w12=Point(w.x-5,w.y+d)
        zf.draw_fill_triangle(w10,w11,w12,noir)#dentellage du corps
    
        w13=Point(w.x-4,w.y+d)
        w14=Point(w.x,w.y+6)
        w15=Point(w.x+4,w.y+d)
        zf.draw_fill_triangle(w13,w14,w15,noir)#dentellage du corps
       
        
    def fantome_rouge(u):
        
        zf.draw_fill_circle (u,r,rouge)#corps du fantôme rouge
    
        u1=Point(u.x-4,u.y-5)
        zf.draw_fill_circle(u1,r1,blanc)#oeil gauche
    
        u2=Point(u.x-4,u.y-4)
        zf.draw_fill_circle(u2,r2,noir) #pupille oeil gauche
    
        u3=Point(u.x+4,u.y-5)
        zf.draw_fill_circle(u3,r1,blanc)#oeil droit
    
        u4=Point(u.x+d,u.y+d)
        u5=Point(u.x-d,u.y)
        zf.draw_fill_rectangle(u4,u5,rouge)#corps
    
    
        u6=Point(u.x+4,u.y-4)
        zf.draw_fill_circle(u6,r2,noir) #pupille oeil gauche   
    
        u7=Point(u.x+d,u.y+d)
        u8=Point(u.x+6,u.y+6)
        u9=Point(u.x+5,u.y+d)
        zf.draw_fill_triangle(u7,u8,u9,noir)#dentellage du corps
    
        u10=Point(u.x-d,u.y+d)
        u11=Point(u.x-6,u.y+6)
        u12=Point(u.x-5,u.y+d)
        zf.draw_fill_triangle(u10,u11,u12,noir)#dentellage du corps
    
        u13=Point(u.x-4,u.y+d)
        u14=Point(u.x,u.y+6)
        u15=Point(u.x+4,u.y+d)
        zf.draw_fill_triangle(u13,u14,u15,noir)#dentellage du corps
        
    def fantome_bleu(t):

    
        zf.draw_fill_circle(t,r,lightblue)#corps du fantôme bleu
        t1=Point(t.x-4,t.y-5)
        zf.draw_fill_circle(t1,r1,blanc) #oeil gauche
    
        t2=Point(t.x-4,t.y-4)
        zf.draw_fill_circle(t2,r2,noir)#pupille oeil gauche
    
        t3=Point(t.x+4,t.y-5)
        zf.draw_fill_circle(t3,r1,blanc)#oeil droit
    
        t4=Point(t.x+d,t.y+d)
        t5=Point(t.x-d,t.y)
        zf.draw_fill_rectangle(t4,t5,lightblue)#corps
    
    
        t6=Point(t.x+4,t.y-4)
        zf.draw_fill_circle(t6,r2,noir) #pupille oeil gauche
    
        t7=Point(t.x+d,t.y+d)
        t8=Point(t.x+6,t.y+6)
        t9=Point(t.x+5,t.y+d)
        zf.draw_fill_triangle(t7,t8,t9,noir)#dentellage du corps
    
        t10=Point(t.x-d,t.y+d)
        t11=Point(t.x-6,t.y+6)
        t12=Point(t.x-5,t.y+d)
        zf.draw_fill_triangle(t10,t11,t12,noir)#dentellage du corps
    
        t13=Point(t.x-4,t.y+d)
        t14=Point(t.x,t.y+6)
        t15=Point(t.x+4,t.y+d)
        zf.draw_fill_triangle(t13,t14,t15,noir)#dentellage du corps
        
    def fantome_rose(s):
        
        
        zf.draw_fill_circle(s,r,lightcoral)#corps du fantôme rose
        s1=Point(s.x-4,s.y-5)
        zf.draw_fill_circle(s1,r1,blanc)#oeil gauche
    
        s2=Point(s.x-4,s.y-4)
        zf.draw_fill_circle(s2,r2,noir) #pupille oeil gauche
    
        s3=Point(s.x+4,s.y-5)
        zf.draw_fill_circle(s3,r1,blanc)#oeil droit
    
        s4=Point(s.x+d,s.y+d)
        s5=Point(s.x-d,s.y)
        zf.draw_fill_rectangle(s4,s5,lightcoral)#corps
    
    
        s6=Point(s.x+4,s.y-4)
        zf.draw_fill_circle(s6,r2,noir)#pupille oeil gauche
    
        s7=Point(s.x+d,s.y+d)
        s8=Point(s.x+6,s.y+6)
        s9=Point(s.x+5,s.y+d)
        zf.draw_fill_triangle(s7,s8,s9,noir)#dentellage du corps
    
        s10=Point(s.x-d,s.y+d)
        s11=Point(s.x-6,s.y+6)
        s12=Point(s.x-5,s.y+d)
        zf.draw_fill_triangle(s10,s11,s12,noir)#dentellage du corps
    
        s13=Point(s.x-4,s.y+d)
        s14=Point(s.x,s.y+6)
        s15=Point(s.x+4,s.y+d)
        zf.draw_fill_triangle(s13,s14,s15,noir)#dentellage du corps


    
    #création de la grille qui servira comme support au jeux
    G=[[7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7], 
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1],
        [7, 7, 7, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 7, 7, 7],
        [1, 1, 1, 1, 0, 1, 0, 1, 7, 7, 7, 7, 1, 0, 1, 0, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 1, 6, 4, 3, 5, 1, 0, 0, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1],
        [7, 7, 7, 1, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 1, 7, 7, 7],
        [1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1],
        [1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1],
        [1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1],
        [1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        [1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1],
        [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] 
        
    def dessine_pacman(p):#création du Pac-Man dans le labyrinthe
    
        r=10

        zf.draw_fill_circle(p,r,jaune)#création du corps du Pac-Man
        a= Point(p.x-1, p.y+3)
        b= Point(p.x+12,p.y+2)
        c= Point(p.x+20, p.y+12)
        zf.draw_fill_triangle(a,b,c,noir)#bouche 
        
        e=Point(p.x-4,p.y-5)
        zf.draw_fill_circle(e,4,blanc)#oeil gauche
        
    
        g=Point(p.x-4,p.y-4)
        zf.draw_fill_circle(g,2,noir)#pupille oeil gauche
    
        h=Point(p.x+4,p.y-5)
        zf.draw_fill_circle(h,4,blanc)#oeil droit
    
        i=Point(p.x+4,p.y-4)
        zf.draw_fill_circle(i,2,noir)#pupille oeil droit
        
    
    def dessine_pacman1(p):#création du Pac-Man noir, recouvrant le précédent, pour le faire                      disparaître 
        
        r=10
        
        zf.draw_fill_circle(p,r,noir)#création du corps noir du 2e Pac-Man
        b= Point(p.x+12,p.y+2)
        c= Point(p.x+20, p.y+12)
        zf.draw_fill_triangle(a,b,c,noir)#bouche
        
        
        e=Point(p.x-4,p.y-5)
        zf.draw_fill_circle(e,4,noir)#oeil gauche
        
    
        g=Point(p.x-4,p.y-4)
        zf.draw_fill_circle(g,2,noir)#pupille oeil gauche
    
        h=Point(p.x+4,p.y-5)
        zf.draw_fill_circle(h,4,noir)#oeil droit
    
        i=Point(p.x+4,p.y-4)
        zf.draw_fill_circle(i,2,noir))#pupille oeil droit
        
        
    def deplacement (event):
        global i,j
        global l
        for i in range (20):
            for j in range (25):
                p=Point(39*i,29*j)
                dessine_pacman1(p)
                if event.keysym=='Right' and G[j][i]==2 and G[j][i+1]==0: #si le Pac-Man rencontre un espace vide en allant à droite 
                    G[j][i+1]==2
                    G[j][i]==0
                elif event.keysym=='Left' and G[j][i]==2 and G[j][i-1]==0:#si le Pac-Man rencontre un espace vide en allant à gauche
                    G[j][i-1]==2
                    G[j][i]==0
                elif event.keysym=='Up' and G[j][i]==2 and G[j-1][i]==0:#si le Pac-Man rencontre un espace vide en allant en haut
                    G[j-1][i]==2
                    G[j][i]==0
                elif event.keysym=='Down' and G[j][i]==2 and G[j+1][i]==0:#si le Pac-Man rencontre un espace vide en allant en bas
                    G[j+1][i]==2
                    G[j][i]==0
                    
                    
                elif event.keysym=='Right' and G[j][i]==2 and G[j][i+1]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Left' and G[j][i]==2 and G[j][i-1]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Up' and G[j][i]==2 and G[j-1][i]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                elif event.keysym=='Down' and G[j][i]==2 and G[j+1][i]==1:
                    G[j+1][i]==1
                    G[j][i]==2
                    
        dessine_pacman(p)

    def dessine_grille(G):
        global p
        global w
        global u
        global t
        for i in range (20):
            for j in range (25):
                if G[j][i]==1:
                    #correspond à un mur
                    zf.draw_rectangle(Point(35*i,28*j), Point(35*i+35, 28*j+28), blue)
                elif G[j][i]==2:
                    #correspond au pacman
                    p=Point(39*i,29*j)
                    dessine_pacman(p)
                elif G[j][i]==3: #correspond aux fantômes
                    w=Point(37*i,29*j)
                    fantome_vert(w)
                    #fantome_vert(i, j)
                elif G[j][i]==4:
                    u=Point(37*i,29*j)
                    fantome_rouge(u)
                    #fantome_rouge(i, j)
                elif G[j][i]==5:
                    t=Point(37*i,29*j)
                    fantome_bleu(t)
                    #fantome_bleu(i, j)
                elif G[j][i]==6:
                    s=Point(37*i,29*j)
                    fantome_rose(s)
                    #fantome_rose(i, j)
                elif G[j][i]==0:
                    zf.draw_fill_circle(Point(37*i,29*j),2, yellow)
                elif G[j][i]==7:
                    zf.draw_fill_circle(Point(37*i,29*j),1, black)
                    #correspond pièces
                    
    
                    
    bbb=Point(50,45)
    zf.aff_texte("Score :",bbb,20,police='arial',couleur='yellow')
    sss=Point(550,45)
    ttt=Point(600,45)
    uuu=Point(650,45)
    dessine_pacman(sss)
    dessine_pacman(ttt)
    dessine_pacman(uuu)
    
    
    #tests

    dessine_grille(G)
    zf.activer_clavier( )
    zf.bind('<Key>',deplacement)
    f.mainloop()



#tests
f=Fenetre()
L,H=500,500
zg=f.graphique(largeur=L,hauteur=H,couleur=noir)
vx,vy=5,0 #vitesse
s=Point(100,300)#point Pac-Man 
d=10 #rayon
r=10 #rayon
p=Point(70,300)#point fantôme rose
r1=4 #rayon
r2=2 #rayon
t=Point(47,300)#point fantôme bleu
u=Point (25,300)#point fantôme rouge
w=Point (3,300)#point fantôme vert

jj=Point(325,150)#titre et dessin dans le générique
nn=zg.draw_fill_circle (jj,40,jaune)
bb=Point(330,130)
zg.draw_fill_circle(bb,8,blanc)
zg.draw_fill_circle (bb,4,noir)
cc=Point (330,160)
dd=Point (380,130)
ee= Point (380,200)
zg.draw_fill_triangle (cc,dd,ee,noir)
aa=Point(170,150)
zg.aff_texte("Pac-Man",aa, couleur=jaune,taille=30)

bouton2=f.bouton(commande=debut_du_jeu,texte="Start game",largeur="10",hauteur="2",alignement='bas',couleur=jaune)#bouton pour commencer le jeu



l=dessine_pacman(s)
a=fantome_rose(p)
b=fantome_bleu(t)
c=fantome_rouge(u)
z=fantome_vert(w)
anim(s,vx,vy)
animrose(p,vx,vy)
animbleu(t,vx,vy)
animrouge(u,vx,vy)
animvert(w,vx,vy)

zg.activer_clavier( )  

f.mainloop()







0
Bonjour.

Pour le déplacement de ton pacman, la 1ère chose que je ne comprends pas est pourquoi n'importe quelle touche du clavier peut le faire se déplacer alors qu'à la base pacman doit se déplacer dans 4 directions, donc il faut revoir cela en utilisant les flèches directionnelles du clavier reliée chacune à une fonction de déplacement (gauche, droit, haut, bas).

Tu t'étonnes que ton pacman parcours tout ton labyrinthe, mais c'est un peu ce que fait ton code puisque dans ta fonction déplacement tu parcours (je suppose) ton labyrinthe dans tes boucles range.

Pour le positionnement des billes, je ne sais pas ce que fait ta fonction draw_fill_circle, alors je vais partir dans une supposition, je pense que c'est en rapport avec la bordure par défaut des items canvas qui sont à 1, si tu veux des dimensions strictes, il faut définir le paramètre width à 0, et qu'ensuite tu ne centres pas ta bille correctement dans l'espace lui étant imparti, 37 et 29 correspondent au coin supérieur gauche de cet espace, à toi de calculer comment centre un élément de dimension x, y, x2, y2 dans un autre élément de dimension x, y, x2, y2.

Il y a également beaucoup de choses à revoir dans ton code.
0
Lily1611 Messages postés 5 Date d'inscription mardi 13 mars 2018 Statut Membre Dernière intervention 8 mai 2018
22 avril 2018 à 13:28
Bonjour,

Je ne comprends pas pourquoi vous dites que n'importe quelle touche peut le faire se déplacer. Quand j'utilise elif event.system=="Up" par exemple, c'est si on actionne la flèche du haut. C'est la même chose pour les autres flèches.
Pour les boucles, il faudrait simplement les retirer ?

Merci beaucoup
0
critou > Lily1611 Messages postés 5 Date d'inscription mardi 13 mars 2018 Statut Membre Dernière intervention 8 mai 2018
23 avril 2018 à 12:25
Bonjour.

Oui, tu as raison, je n'ai pas bien fait attention à ton code, n'en reste pas moins qu'il y a des choses qui ne vont pas du tout.

Ce qui m'a induit en erreur était ton dessine_pacman1(p), ce qui m'a semblé sur le coup logique que tu créais un pacman chaque fois et j'ai pas cherché plus que ça.
Mais c'est pire en fait, cette fonction sert juste à le cacher au cas où le pacman serait sur cette case du jeu, t'imagines bien que ce n'est pas possible de faire ça, pour un déplacement, tu crées 500 pacman noir, au bout de 100 déplacements tu en auras 5 000...
tkinter est gentil, mais là, il ne va pas apprécier.

Et je ne compte pas non plus les fois où tu crées également un nouveau pacman, j'imagine que pour les fantômes ça doit être à peu près la même chose ?

Ce n'est pas comme ça que l'on procède.

1 - Création de ton pacman à telle position de ta grille G, position que l'on garde en mémoire au chaud dans un coin.
2 - Lors de la demande d'un déplacement par un appui sur une touche directionnelle, on regarde selon la direction désirée, si le déplacement est possible, et pas besoin de faire des boucles pour ça, on utilise la position actuelle du pacman (que l'an a gardée au chaud) pour effectuer cette vérification.

3 - Si le déplacement est possible, on déplace (et non en crée un à nouveau) le pacman à la nouvelle position dans le jeu (avec Canvas.move ou Canvas.coords) , on met à jour sa nouvelle position, et on fait tout ce qu'il y a à faire d'autres.
Inutile de parcourir toute ta grille pour faire ça.

Et mets-toi à la place de ceux qui vont lire ton code, des variables abrégées comme u7, t5, G, p, w, u, t, zf, zg rend ton code totalement incompréhensible et ça donne pas envie d'essayer de le comprendre, nomme tes variables explicitement par ce qu'elles représentent, des fonctions comme "dessine_pacman1" ne représentent pas ce qu'elles font, de plus une fonction effectuant une action se met à l'infinif, au lieu de "deplacement" un nom correct de fonction qui effectue cette action serait plus du genre "deplacer_pacman".
0
Lily1611 Messages postés 5 Date d'inscription mardi 13 mars 2018 Statut Membre Dernière intervention 8 mai 2018
26 avril 2018 à 13:44
Bonjour,

Tout d'abord, je suis désolée, j'ai oublié de préciser que nous n'utilisons pas tkinter. Nous sommes très limités quant au matériel et aux logiciels. Notre professeur ne nous guide que très peu, et la plupart du temps, il nous induit en erreurs. La plupart des fonctions créées, comme la fonction qui crée un pac-man noir par dessus le précédent nous a été conseillé par notre professeur.

A plusieurs reprises, nous lui avons demandé comment mémoriser la position du Pac-Man et comment nous pouvions nous en servir, mais il se met en colère et nous rabaisse. C'est de plus en plus dur de travailler avec lui et nous sommes complètement bloqués. Je comprends les conseils que tu donnes, mais je ne sais absolument pas comment les appliquer...
0