Tetris en python 2.6

Soyez le premier à donner votre avis sur cette source.

Vue 20 098 fois - Téléchargée 2 856 fois

Description

Un petit tetris en python.Lisez le code TetrisPythonPrincipe pour avoir une explication plus exhaustive de la méthode employée.De par la présence du module winsound ne fonctionne que sous windows, cependant lisez le début pour contourner le problème.

Source / Exemple :


################################################################################
#                                 TETRIS                                       #       
#                        en Python pour windows                                #
#           pour les autres os veuillez mettre un '#' devant les lignes        #
#                       13,252,270,354,376,380,466                             #
################################################################################

from Tkinter import *
from time import sleep
from random import randrange
from winsound import *
import pickle

#-------------------------------------------------------------------------------
def initialisation():
    """ Création du tableau de canevas 20 lignes 10 colonnes et de sa matrice
        associée.Création du panneau d'informations.Définition des pièces et de
        leurs positions."""    
    global tab_can,tab_grille,tab_couleur,coord_courante,piece,sens,tab_pieces,\
           nbr_lignes,score,label_score,niveau,label_niveau,can_piece_suivante,\
           top_five,label_topfive,tab_scores,label_noms,label_scores,\
           informations,label_lignes,reliefs,interval,couleur_fond
    #----- Canevas et matrice -------------------------------------------------
    tab_can = []
    tab_grille = []
    tab_couleur = ['wheat','LimeGreen','blue','red','dark green','SteelBlue',\
                 'DarkOrange','navy','LightGoldenrodYellow']
    for i in range(20):
        tab_can.append([[]]*10)
        tab_grille.append([[]]*10)

    grille_jeu = Frame(fen)
    for ligne in range(20):
        for colonne in range(10):
            couleur = tab_couleur[0]
            tab_can[ligne][colonne] = Canvas(grille_jeu,bg=couleur,\
                                        highlightbackground="linen",height=20,\
                                           width=20,borderwidth=1,relief=GROOVE)
            tab_can[ligne][colonne].grid(row=ligne,column=colonne)
            tab_grille[ligne][colonne] = 0
    grille_jeu.grid(row=1,column=0)
    #----- Panneau d'informations ---------------------------------------------
    informations = Frame(fen,bg='DarkCyan',width=150,height=520)

    
    frame_suivante = Frame(informations,bg='DarkRed')
    label_titre = Label(informations,text="TETRIS",
                             fg='DarkOrange',font="Century 18 normal bold",
                                                    bg='DarkCyan')
    label_titre.place(x=22,y=05,width=100,height=40)        
    can_piece_suivante = []
    for i in range(4):
        can_piece_suivante.append([[]]*4)
    for ligne in range(4):
        for colonne in range(4):
            coul = tab_couleur[8]
            can_piece_suivante[ligne][colonne] = Canvas(frame_suivante,bg=coul,\
                                highlightbackground="linen",height=15,width=15,\
                                                    borderwidth=1,relief=GROOVE)
            can_piece_suivante[ligne][colonne].grid(row=ligne,column=colonne)

    label_next = Label(informations,text="SUIVANTE",
                             fg='white',font="Century 9 normal bold",
                                                    bg='DarkCyan')
    label_next.place(x=27,y=50,width=90,height=20)        

    frame_suivante.place(x=30,y=70,width=84,height=84)

    label_score = Label(informations,text="SCORE\n0",
                             fg='white',font="Century 13 normal bold",
                                              bg='CornflowerBlue',relief=RIDGE)
    label_score.place(x=30,y=180,width=90,height=40)

    niveau = 1
    label_niveau = Label(informations,text="NIVEAU\n"+str(niveau),
                             fg='white',font="Century 13 normal bold",
                                                  bg='DarkOrange',relief=RIDGE)
    label_niveau.place(x=30,y=230,width=90,height=40)
    ligne = 0
    label_lignes = Label(informations,text="LIGNES\n"+str(ligne),
                             fg='white',font="Century 13 normal bold",
                                                    bg='SeaGreen',relief=RIDGE)
    label_lignes.place(x=30,y=280,width=90,height=40)    
    #-----
    frame_top5 = Frame(informations,bg='maroon')

    label_top5 = Label(frame_top5,text="TOP 5",fg='white',\
                       font="Century 13 normal bold",bg='maroon',anchor=N,\
                                                               relief=SUNKEN)
    label_top5.pack(expand=NO,fill=BOTH)

    label_noms = Label(frame_top5,fg='white',font="Century 11 normal bold",\
                                           bg='maroon',anchor=NW,relief=SUNKEN)
    label_noms.pack(side=LEFT)

    label_scores = Label(frame_top5,fg='white',font="Century 11 normal bold",
                                 width=6,bg='maroon',anchor=E,relief=SUNKEN)
    label_scores.pack(side=RIGHT)

    frame_top5.place(x=5,y=330,width=140,height=160)

    informations.grid(row=1,column=1)
    #-----
    label_options = Frame(fen,bg='DarkCyan',width=500,height=150)

    MODES=[("Groove",GROOVE),("Ridge",RIDGE)]
    reliefs = StringVar()
    reliefs.set(GROOVE)
    for text,mode in MODES:
        b = Radiobutton(label_options,command=maj_Grille,bg='DarkCyan',
                      activebackground='DarkCyan',text=text,variable=reliefs,
                                                                  value=mode)
        b.pack(anchor=W,side=LEFT)

    interval = IntVar()
    dims = Scale(label_options,from_=1,to=5,length=100,width=5,\
                 orient=HORIZONTAL,tickinterval=1,variable=interval,\
                 command=maj_Grille,bg='DarkCyan',label="Intervalle",\
                 activebackground='DarkCyan',troughcolor='ivory')
    dims.pack(side=LEFT,padx=10)

    couleur_fond = StringVar()
    COUL_FOND=[("Crème","wheat"),("Rosé","Thistle"),("Métal","LightSteelBlue")]    
    couleur_fond.set("wheat")
    for text,couleur in COUL_FOND:
        b = Radiobutton(label_options,command=maj_Grille,bg='DarkCyan',\
                        text=text,activebackground='DarkCyan',\
                        variable=couleur_fond,value=couleur)
        b.pack(anchor=W,side=LEFT)

    label_options.grid(row=0,column=0,columnspan=2,sticky=W+E+N+S)
    #----- Définition des pièces ----------------------------------------------#                                           
    piece1 =[[(0,1,0,0),(0,1,1,0),(0,0,1,0),(0,0,0,0)],#<-1ere position->0 1 0 0
                   [(0,0,0,0),(0,0,1,1),(0,1,1,0),(0,0,0,0)],#<-2eme     0 1 1 0 
                   [(0,1,0,0),(0,1,1,0),(0,0,1,0),(0,0,0,0)],#<-3eme     0 0 1 0 
                   [(0,0,0,0),(0,0,1,1),(0,1,1,0),(0,0,0,0)]]#<-4eme     0 0 0 0

    piece2 = [[(0,2,2,0),(0,2,2,0),(0,0,0,0),(0,0,0,0)],         # 0 2 2 0
                 [(0,2,2,0),(0,2,2,0),(0,0,0,0),(0,0,0,0)],      # 0 2 2 0
                 [(0,2,2,0),(0,2,2,0),(0,0,0,0),(0,0,0,0)],      # 0 0 0 0
                 [(0,2,2,0),(0,2,2,0),(0,0,0,0),(0,0,0,0)]]      # 0 0 0 0

    piece3 = [[(0,3,0,0),(0,3,0,0),(0,3,0,0),(0,3,0,0)],        # 0 3 0 0
                [(3,3,3,3),(0,0,0,0),(0,0,0,0),(0,0,0,0)],      # 0 3 0 0
                [(0,3,0,0),(0,3,0,0),(0,3,0,0),(0,3,0,0)],      # 0 3 0 0
                [(3,3,3,3),(0,0,0,0),(0,0,0,0),(0,0,0,0)]]      # 0 3 0 0

    piece4 = [[(0,0,4,0),(0,4,4,0),(0,4,0,0),(0,0,0,0)],        # 0 0 4 0
                 [(0,0,0,0),(0,4,4,0),(0,0,4,4),(0,0,0,0)],     # 0 4 4 0
                 [(0,0,4,0),(0,4,4,0),(0,4,0,0),(0,0,0,0)],     # 0 4 0 0
                 [(0,0,0,0),(0,4,4,0),(0,0,4,4),(0,0,0,0)]]     # 0 0 0 0

    piece5 = [[(0,5,0,0),(0,5,5,0),(0,5,0,0),(0,0,0,0)],        # 0 5 0 0
                 [(0,0,0,0),(0,0,5,0),(0,5,5,5),(0,0,0,0)],     # 0 5 5 0
                 [(0,0,0,5),(0,0,5,5),(0,0,0,5),(0,0,0,0)],     # 0 5 0 0
                 [(0,5,5,5),(0,0,5,0),(0,0,0,0),(0,0,0,0)]]     # 0 0 0 0

    piece6 = [[(0,0,6,0),(0,0,6,0),(0,6,6,0),(0,0,0,0)],        # 0 0 6 0
                 [(0,0,0,0),(0,6,6,6),(0,0,0,6),(0,0,0,0)],     # 0 0 6 0
                 [(0,6,6,0),(0,6,0,0),(0,6,0,0),(0,0,0,0)],     # 0 6 6 0
                 [(0,0,0,0),(0,6,0,0),(0,6,6,6),(0,0,0,0)]]     # 0 0 0 0

    piece7 = [[(0,7,0,0),(0,7,0,0),(0,7,7,0),(0,0,0,0)],        # 0 7 0 0
                 [(0,0,0,0),(0,0,0,7),(0,7,7,7),(0,0,0,0)],     # 0 7 0 0
                 [(0,7,7,0),(0,0,7,0),(0,0,7,0),(0,0,0,0)],     # 0 7 7 0
                 [(0,0,0,0),(0,7,7,7),(0,7,0,0),(0,0,0,0)]]     # 0 0 0 0

    tab_pieces =(piece1,piece2,piece3,piece4,piece5,piece6,piece7)
    #----- 
    fen.bind('<Right>',droite)
    fen.bind('<Left>',gauche)
    fen.bind('<Up>',tourne)
    fen.bind('<Down>',tombe)    
    fen.bind('<KeyRelease-Down>',tombe_Relache)
    #-----
    tab_scores = [["Nom001",00000],["Nom002",00000],["Nom003",00000],
                                          ["Nom004",00000],["Nom005",00000]]
    #sauve_Top()
    charge_Top()
    maj_Grille()

#-------------------------------------------------------------------------------
def sauve_Top():
    """Sauvegarde du tableau des scores"""
    f = open('top5c','w')
    pickle.dump(tab_scores,f)
    f.close()
             
#-------------------------------------------------------------------------------
def charge_Top():
    """Chargement du tableau des scores"""
    global tab_scores
    
    nom_fichier = "top5c"
    fichier = open(nom_fichier, 'r')
    tab_scores = pickle.load(fichier)
    fichier.close()
    affiche_Scores()
    
#-------------------------------------------------------------------------------
def affiche_Scores():
    """Mise à jour du tableau des scores dans la partie information"""
    noms=""
    scores=""
    for i in tab_scores:
        noms += i[0]+"\n"
        scores += str(i[1])+"\n"
    label_noms.configure(text=noms,justify=LEFT)
    label_scores.configure(text=scores,justify=RIGHT)
    
#-------------------------------------------------------------------------------
def aide():
    """Tirage au hazard d'une pièce mémorisée dans piece_suivante.
       Affichage de cette pièce dans la partie information.Lorsque la pièce
       courante ne peut plus descendre, cette pièce devient la pièce courante"""
    global piece,can_piece_suivante,piece_suivante
    
    index = randrange(0,len(tab_pieces))
    piece_suivante = tab_pieces[index]    
    for i in range(4):
        for j in range(4):
            if piece_suivante[0][i][j] == 0:
                couleur = tab_couleur[8]
            else:
                couleur = tab_couleur[piece_suivante[0][i][j]]
            can_piece_suivante[i][j].configure(bg=couleur)

#-------------------------------------------------------------------------------
def nouvelle_Partie():
    """A chaque nouvelle partie on réinitialise la matrice et certaines
       variables de jeu.On tire au hazard une pièce mémorisée dans
       piece_courante."""
    global piece_courante,piece_suivante,piece_suivante,niveauUp,nbr_lignes,\
           label_score,score,label_niveau,niveau,coord_courante

    barreMenu.entryconfig(1,state=DISABLED)
    for ligne in range(20):
        for colonne in range(10):
            tab_grille[ligne][colonne] = 0

    piece_courante = []
    piece_suivante = []
    niveau = 1
    label_niveau.configure(text="NIVEAU\n"+str(niveau))
    score = 0
    label_score.configure(text="SCORE\n"+str(score))    
    nbr_lignes = 0
    index = randrange(0,len(tab_pieces))
    piece_courante = tab_pieces[index]
    niveauUp = False
    PlaySound("debut.wav",SND_ASYNC)
    nouvelle_Piece(piece_courante)
    
#-------------------------------------------------------------------------------    
def nouvelle_Piece(piece_courante):
    """A chaque nouvelle pièce on réinitialise la coordonnée courante.La piece
       courante devient celle reçue en argument autrement dit la pièce suivante.
       Si son déplacement n'est pas possible la partie est finie."""    
    global coord_courante,piece,sens,vitesse_courante,vitesse,niveau,tab_scores
           
    vitesse_courante = 550 - (niveau*50)
    vitesse = vitesse_courante
    coord_courante = [0,3]
    sens = 0
    piece = piece_courante
    aide()  #<--- Tirage de la pièce suivante

    if not verif_Deplacement(0,0,0):
        PlaySound("perdu.wav",SND_ASYNC)             
        imprime_Piece(sens)
        if score > tab_scores[4][1]:
            nouveau_score()
        barreMenu.entryconfig(1,state=ACTIVE)
    else :
        imprime_Piece(sens)
        sleep(1)
        descente()

#-------------------------------------------------------------------------------
def nouveau_score():
    """Appelée lorsque le score du joueur actuel dépasse le 5ème du tableau des
       scores."""
    global nom,tab_scores,entree,fen2

    nom = "new"
    fen2 = Toplevel(bg='Maroon')
    fen2.iconbitmap("Tetris_icone.ico")
    fen2.geometry(pos)
    fen2.wait_visibility()
    fen2.grab_set()
    fen2.transient(fen)
    fen2.focus_force()
    lbl = Label(fen2,text="Félicitations ! Vous faites partie du TOP5\n\
    Veuillez saisir votre nom svp(6caractères max):",fg='White',bg='maroon'\
                                                                    ,width=60)
    lbl.pack()
    entree = Entry(fen2,width=30)
    entree.bind('<Return>',recup_nom)
    entree.pack()
    fen.wait_window(fen2) #Attente de la destruction de fen2 avant de poursuivre
    new = [nom,score]
    tab_scores.append(new)
    tab_scores_range = sorted(tab_scores, key=lambda tab_scores: tab_scores[1],
                                                                   reverse=TRUE)
    tab_scores = tab_scores_range[:]
    del tab_scores[-1]
    affiche_Scores()
    sauve_Top()

#-------------------------------------------------------------------------------
def recup_nom(event):
    """Récupération des 6 premières lettres du widget entree."""
    global nom,fen2

    saisie = entree.get()
    nom = saisie[:6]
    fen2.destroy()
    
#-------------------------------------------------------------------------------
def imprime_Piece(sens):
    """On imprime la pièce dans la matrice par rapport à sa coordonnée
       courante."""
    for i in range(4):
        for j in range(len(piece)):
            if piece[sens][i][j] == 0:
                continue                
            tab_grille[coord_courante[0]+i][coord_courante[1]+j] =\
                                                            piece[sens][i][j]
    maj_Grille()

#-------------------------------------------------------------------------------
def tombe(event):
    """Touche BAS appuyée : augmentation de la vitesse."""
    global vitesse

    vitesse = 10

#-------------------------------------------------------------------------------
def tombe_Relache(event):
    """Touche BAS relachée : la vitesse prend sa valeur déterminée par le
       niveau."""
    global vitesse,vitesse_courante

    vitesse = vitesse_courante
    
#-------------------------------------------------------------------------------
def tourne(event):
    """Touche HAUT : si c'est possible la pièce tourne."""
    global sens
    
    efface_Piece()
    if verif_Deplacement(0,0,1):
        PlaySound("pieceTournee.wav",SND_ASYNC)        
        sens += 1
        if sens == 4:
            sens = 0
        imprime_Piece(sens)
    else:
        imprime_Piece(sens)

#-------------------------------------------------------------------------------    
def descente():
    """Appelée dès la mise en place d'une nouvelle pièce, cette méthode est
       chargée de la faire descendre ligne par ligne si c'est possible.Sinon
       on appelle nouvelle_Piece avec piece_suivante en parametre."""
    global piece_suivante,niveauUp,vitesse

    efface_Piece()
    if verif_Deplacement(1,0,0):
        coord_courante[0] += 1
        imprime_Piece(sens)
        fen.after(vitesse,descente)

    else :
        PlaySound("pieceTombee.wav",SND_ASYNC)
        imprime_Piece(sens)
        verif_Ligne()
        if niveauUp:
            PlaySound("niveauUp.wav",SND_ASYNC)  
            for i in range (5):
                fen.after(100,anim_Level('red'))
                fen.update()
                fen.after(100,anim_Level('DarkOrange'))
                fen.update()
            label_niveau.configure(text="NIVEAU\n"+str(niveau))
            niveauUp = False
        nouvelle_Piece(piece_suivante)
        
#-------------------------------------------------------------------------------
def anim_Level(coul):
    """Petite animation quand le niveau monte."""
    label_niveau.configure(bg=coul)
        
#-------------------------------------------------------------------------------
def gauche(event):
    """Touche GAUCHE : si c'est possible la pièce se déplace d'une colonne
       vers la gauche."""
    efface_Piece()
    if verif_Deplacement(0,-1,0):
        coord_courante[1] -=1
        imprime_Piece(sens)
    else:
        imprime_Piece(sens)
    return

#-------------------------------------------------------------------------------
def droite(event):
    """Touche DROITE : si c'est possible la pièce se déplace d'une colonne
       vers la droite."""
    efface_Piece()
    if verif_Deplacement(0,1,0):
        coord_courante[1] += 1
        imprime_Piece(sens)
    else:
        imprime_Piece(sens)
    return

#-------------------------------------------------------------------------------
def efface_Piece():
    """On efface la pièce de la matrice par rapport à sa coordonnée courante."""
    for i in range(4):
        for j in range(4):
            if piece[sens][i][j] == 0:
                continue
            tab_grille[coord_courante[0]+i][coord_courante[1]+j] = 0

#-------------------------------------------------------------------------------            
def verif_Deplacement(dx,dy,pivot):
    """Appelée avant chaque déplacement, cette méthode vérifie si la pièce ne
       débordera pas de la matrice.Si c'est la cas on renvoit un déplacement non
       possible à la méthode appelante.Si non, on test si elle ne chevauchera
       pas des blocs déja présent."""
    rotation = sens + pivot
    if rotation == 4:
        rotation = 0
    for i in range(4):
        for j in range(4):
            if coord_courante[1]+(dy+j) > 9 or coord_courante[1]+(dy+j) < 0 or\
                                                   coord_courante[0]+(dx+i) >19:
                if piece[rotation][i][j] != 0:
                    return False
                else:
                    continue
            if (piece[rotation][i][j] * tab_grille[coord_courante[0]+(dx+i)]\
                                                [coord_courante[1]+j+dy]) != 0:
                return False
    return True

#-------------------------------------------------------------------------------
def verif_Ligne():
    """Quand une pièce est posée on verifie par récursivité en partant du bas
       la ou les lignes contigues complètes."""
    global memoire,compt,nbr_lignes,score,label_score,niveau,label_niveau,\
                                                    label_lignes,niveauUp

    bonus = 0
    points = 0
    memoire =[]
    for i in range(19,-1,-1):
        ligne_complete = True
        for j in range(10):
            if tab_grille[i][j] == 0:
                ligne_complete = False
                if memoire != []:
                    PlaySound("ligneComplete3.wav",SND_ASYNC)
                    compt = 0
                    if animation_Ligne(i+1,memoire):
                        sleep(0.5)
                        for k in range(len(memoire)):
                            points += ((i+1)+k)*10
                            del tab_grille[(i+1)+k]
                            tab_grille[0:0]=0,0,0,0,0,0,0,0,0,0
                        maj_Grille()
                        score += points*bonus
                        label_score.configure(text="SCORE\n"+str(score))
                        label_lignes.configure(text="LIGNES\n"+str(nbr_lignes))                        
                    verif_Ligne()

        if ligne_complete:
            memoire.append(tab_grille[i])
            bonus += 1
            nbr_lignes += 1
            if nbr_lignes%20 == 0:
                niveau += 1
                niveauUp = True

#-------------------------------------------------------------------------------
def animation_Ligne(index,ligne):
    """Petite animation de la ou les lignes contigues complétées."""
    global compt,memoire

    if compt%2 == 0:
        ligne = 0,0,0,0,0,0,0,0,0,0 *len(ligne)
    else:
        ligne = memoire[:]

    for i in range(len(ligne)):
        tab_grille[index+i] = ligne[i]    
    maj_Grille()
    compt += 1
    if compt == 6:
        return True
    sleep(0.2)
    animation_Ligne(index,ligne)

    return True

#-------------------------------------------------------------------------------    
def maj_Grille(x=1):
    """Mise a jour des canevas en fonction des options et des couleurs
       référencées par les valeurs de la matrice."""
    tab_interval = [(20,20,1),(18,18,2),(16,16,3),(14,14,4),(12,12,5)]
    tab_couleur[0] = couleur_fond.get()
    for ligne in range(20):
        for colonne in range(10):
            couleur = tab_couleur[tab_grille[ligne][colonne]]
            tab_can[ligne][colonne].configure(bg=couleur,relief=reliefs.get(),
                width=tab_interval[interval.get()-1][0],
                 height=tab_interval[interval.get()-1][1],
                 borderwidth=tab_interval[interval.get()-1][2])

    fen.update()

def a_Propos():
    fen3 = Toplevel(bg='Maroon')
    fen3.resizable(0,0)
    fen3.iconbitmap("Tetris_icone.ico")
    fen3.geometry(pos)
    fen3.wait_visibility()
    fen3.grab_set()
    fen3.transient(fen)
    fen3.focus_force()
    lbl = Label(fen3,text="Calcul des points:\n\
La grille contenant 20 lignes,une ligne complète vaut en points sa position\
dans la grille.\nLorsque des lignes sont contigües, on additionne leure\
position et on multiplie la somme\npar le nombre de lignes se juxtaposant",\
                fg='White',bg='maroon',width=70,justify=LEFT,anchor=W)
    lbl.pack()
fen = Tk()
fen.title("Tetris")
fen.iconbitmap("Tetris_icone.ico")
fen.resizable(0,0)
barreMenu = Menu(fen)
options = Menu(barreMenu)
barreMenu.add_cascade(label="Jeu",menu=options,state=ACTIVE)
options.add_command(label = "Nouvelle Partie",command=nouvelle_Partie)
options.add_command(label = "Quitter",command=fen.destroy)
info = Menu(barreMenu)
barreMenu.add_cascade(label="?",menu=info,state=ACTIVE)
info.add_command(label="Calcul des points",command=a_Propos)
fen.config(menu=barreMenu)
print fen.winfo_screenwidth()
print fen.winfo_screenheight()
initialisation()
print fen.geometry()
hauteur = fen.winfo_height()
largeur = fen.winfo_width()
fen.winfo_screenwidth()
pos_x = str(((fen.winfo_screenwidth()-largeur)/2)-100)
pos_y = str(((fen.winfo_screenheight()-hauteur)/2)-100)
fen.winfo_width()
pos = '+' + pos_x + '+' + pos_y
fen.geometry(pos)
fen.mainloop()

Codes Sources

A voir également

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.