Jeu du serpent (snake)

Commenter

Contenu du snippet

Il s'agit du jeu classique 'snake'.
Vous dirigez un serpent a la recherche de nourriture . vous perdez si vous cognez les limites de la cage ou si le serpent se coupe lui même.
Le but du jeu étant de faire le plus haut score.

Source / Exemple : 


######################################
##                                  ##
##      SNAKE by ZARASH NIKOV       ## 
##            11/09/2011            ##
######################################

from tkinter import *
from random import randrange
#Fonction pour le deplacement du serpent
def move():
    global x,y,dx,dy,corps,coord,flag,px,py,p,point
    if flag:
        x,y=x+dx,y+dy
        can.coords(tete[0],x-4,y-4,x+4,y+4)
        #les yeux du serpents se deplaceront differement selon x ou y
        if dx:                                                       
            can.coords(tete[1][0],x-1,y-3,x+1,y-1)
            can.coords(tete[1][1],x-1,y+1,x+1,y+3)
        if dy:
            can.coords(tete[1][0],x-3,y-1,x-1,y+1)
            can.coords(tete[1][1],x+1,y-1,x+3,y+1)
        #mouvement du corps du serpent
        #chaque petit carré prend les coordonnées du carré qu'il suit
        i=0
        for e in corps:
            can.coords(e,coord[i][0]-4,coord[i][1]-4,\
                         coord[i][0]+4,coord[i][1]+4)
            i+=1
        #On verifie si le serpent n'est pas entré en contact avec les limites du canevas ou s'il s'est pas coupé lui meme
        colision()
        del(coord[0])
        coord.append([x,y])
        #Si le serpent rencontre la pomme
        if dx and  x+4>=px-4 and py-8<=y and y<=py+8 and x-4<=px+4 \
           or dy and y+4>=py-4 and px-8<=x and x<=px+8 and y-4<=py+4 :
            can.delete(p)
            p=0
            pomme()
            segment=can.create_rectangle(x-4,y-4,x+4,y+4,fill='dark blue',outline='dark blue')
            corps.append(segment)
            l=coord
            coord=0,0
            for e in l:
                coord.append(e)
            point+=10
            affiche='Score : '+str(point)
            score.configure(text=affiche)
        
        fen.after(50,move)
def colision():
    global x,y,flag,col
    col=1
    if x+4>=300 or x-4<=0\
       or y+4>=300 or y-4<=0:                #Quand la balle atteint les limites a gauche ou a droiteou les limites en haut ou en bas du canevas
        flag=0
    for e in coord:
        if x==e[0] and y==e[1]:                                 #si le serpent se coupe 
            flag=0
    if not flag:
        tableau.configure(text='PERDU!!')
     

#Fonction qui fait tourner le serpent a droite
def right(event):
    global dx,dy
    if dy:                                                       #il ne tourne qu'il descendait ou montait donc dy!=0
        dy,dx=0,8                                               #il se depalace plus selon y mais selon X
        
#Fonction qui fait tourner le serpent a gauche
def left(event):
    global dx,dy
    if dy:
        dy,dx=0,-8

#Fonction qui fait tourner le serpent en haut
def up(event):
    global dx,dy
    if dx:
        dy,dx=-8,0

#Fonction qui fait tourner le serpent a gauche
def down(event):
    global dx,dy
    if dx:
        dy,dx=8,0
#Fonction qui initialise le jeu
def new_Game():
    global tete,corps,coord,x,y,dy,dx,flag,point,col
    col=0
    if not flag:
        point=0
        can.delete(ALL)
        x,y,dx,dy=150,150,8,0
        tete,corps,coord=[],[],[]
        coord.append([x,y])
        tete.append(can.create_rectangle(x-4,y-4,x+4,y+4,fill='dark blue'))   
        tete.append([can.create_oval(x-1,y-3,x+1,y-1,fill='red')\
                 ,can.create_oval(x-1,y+1,x+1,y+3,fill='red')])           
        n=0
        cx=x-8
        while n<3:
            segment=can.create_rectangle(cx-4,y-4,cx+4,y+4,fill='dark blue',outline='dark blue')
            corps.append(segment)
            coord.append([cx,y])
            cx,cy=cx-8,y
            n+=1
        del(coord[n])                                                   #la liste doit etre du meme nombre que la liste corps
        coord.reverse()
        tableau.configure(text='Cliquez sur Start')
        score.configure(text='Score:'+str(point))
        pomme()
#Fonction pour la creation de la pomme
def pomme():
    global x,y,coord,px,py,p
    #px py doivent bien etre dans le canevas et ne pas etre confondu avec le serpent
    px=randrange(4,297,8)
    py=randrange(4,297,8)
    for e in coord:
        while coord[coord.index(e)][0]+8>=px and coord[coord.index(e)][0]-8<=px and py<=coord[coord.index(e)][1]+8 and py>=coord[coord.index(e)][1]-8:
            px=randrange(4,297,8)
            py=randrange(4,297,8)
    p=can.create_oval(px-4,py-4,px+4,py+4,fill='yellow')
    
#Fonction qui permet de mettre le jeu en pause
def pause(event):
    global flag
    if flag:
        flag=0
    else:
        flag=1
        move()
            
          
#fonction qui lance le jeu(elle permet aussi que plusieurs appuies
#sur le bouton start ne lance plusieurs fonctions move)
def start():                                                        
    global flag,col
    if not flag and not col:
        flag=1
        move()
x,y,dx,dy=150,150,8,0                                               #coordonné du centre du premier carré
p=0                                                                 #la pomme
px,py=0,0                                                           #coordonnées de la pomme
flag=0                                                              #a 0 le serpent ne circule pas , a 1 il circule
tete=[]                                                             #La tete du serpent est une liste,qui contient le premier carré et les deux yeux
point=0
col=0                                                               #Valeur indiquant s'il y a colision ou pas
#creation du reste du corps du serpent
corps=[]                                                            #liste contenant l'ensemble des objets carrés
coord=[]                                                            #liste contenant les coordonnés des carrés
coord.append([x,y])
fen=Tk()
fen.title('jeu du serpent')
can=Canvas(fen,width=300,height=300,bg='grey')
can.grid(row=0,column=0,rowspan=4)
Button(fen,text='New Game',command=new_Game).grid(row=0,column=1)
Button(fen,text='Start',command=start).grid(row=1,column=1)
tableau=Label(fen,text='')
tableau.grid(row=2,column=1)
score=Label(fen,text='Score : ')
score.grid(row=3,column=1)
fen.bind('<Right>',right)
fen.bind('<Left>',left)
fen.bind('<Up>',up)
fen.bind('<Down>',down)
fen.bind('<p>',pause)
fen.mainloop()

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.