Projet ISN Pac-man

Lily1611 Messages postés 6 Date d'inscription   Statut Membre Dernière intervention   -  
 critou -
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()

1 réponse

  1. critou
     
    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
    1. Lily1611 Messages postés 6 Date d'inscription   Statut Membre Dernière intervention  
       
      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
    2. critou
       
      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
    3. Lily1611 Messages postés 6 Date d'inscription   Statut Membre Dernière intervention  
       
      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
    4. critou > Lily1611 Messages postés 6 Date d'inscription   Statut Membre Dernière intervention  
       
      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
    5. Lily1611 Messages postés 6 Date d'inscription   Statut Membre Dernière intervention  
       
      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