MOTUS EN PYTHON 2.6 AVEC TKSNACK

        # -*- coding:UTF-8 -*-
###############################
#       Jeu du Motus          #
#     écrit en Python         #
###############################
from Tkinter import *
from time import sleep
import tkSnack
from grilleLoto_Snack import *


def initialisation():
    """Initialisation de toutes les variables de la grille de jeu
    lors d'une nouvelle partie ou d'un nouveau mot.
    La grille de jeu est un tableau de canevas nb_lettres x 6 lignes
                                                    de propositions."""
    global enigme, tableau_de_propositions, nb_lettres, proposition, ligne,\
            colonne, tableau_de_canevas, bonnes_lettres, mot_trouve,\
              grille_jeu, correspondance, grilles_reinit,son_nouveau_mot,\
              son_aide,son_trouve,beep_rouge,beep_jaune,beep_bleu,son_mot_errone

    enigme = select_Mot()

    #print enigme

    nb_lettres = len(enigme)
    proposition = []
    ligne,colonne = 0,0
    tableau_de_canevas = []
    bonnes_lettres = ['']*nb_lettres
    tableau_de_propositions = []

    mot_trouve = 0
    grille_jeu.destroy()
    fen.update()

    grille_jeu = Frame(fen)

    for i in range(6):
        tableau_de_canevas.append([[]]*nb_lettres)

    for x in range(6):
        for y in range(nb_lettres):
            tableau_de_canevas[x][y] = Canvas(grille_jeu,bg='blue',height=50,
                                          width=50,borderwidth=5,relief='ridge')
            tableau_de_canevas[x][y].grid(row=x,column=y)

    grille_jeu.grid(row=1,column=1)
    fen.update()

    tkSnack.initializeSnack(fen)
    son_nouveau_mot = tkSnack.Sound(file='nouveau_mot.wav')
    son_aide = tkSnack.Sound(file='aide.wav')
    son_trouve = tkSnack.Sound(file='kultur0407.wav')
    son_mot_errone = tkSnack.Sound(file='incorrect.wav')
    beep_rouge = tkSnack.Sound(file='beep-3.wav')
    beep_jaune = tkSnack.Sound(file='beep-6.wav')
    beep_bleu = tkSnack.Sound(file='beep-4.wav')
    
##    musique_fond=tkSnack.Sound()
##    musique_fond.read('FB033.wav')
##    musique_fond.play()

    grille_Est_Reinit()

def grille_Est_Reinit():
    """vérifie que les grilles de loto sont bien reinitialisées
    avant de d'afficher la 1ere lettre du mot et de donner la main
    au joueur."""
    global grilles_reinit

    if grilles_reinit == 1:
        son_nouveau_mot.play()
        attente_Proposition()
        return

    fen.after(50,grille_Est_Reinit)

def nlle_Partie(fichierMots):
    """Remet à zero les scores, appelle la fonction de chargement de mots,
    donne la main au joueur 1 par défaut."""
    global grilles_reinit,equipe_qui_a_la_main

    grilles_reinit = 0

    charger(fichierMots)
    initialisation()
    for i in equipes:
        i.score = 00
        i.label_score.configure(text="Score : "+str(i.score))
        i.label_equipe.configure(text=" ")
        i.configure(bg='white')
        i.reinit_Grille()

    equipe_qui_a_la_main = 0
    equipes[equipe_qui_a_la_main].label_equipe.configure(text=" A VOUS !")
    equipes[equipe_qui_a_la_main].configure(bg='maroon')

    grilles_reinit = 1


def charger(fichier_mots):
    """Charge le fichier de mots correspondant au nombre de lettres
    désiré dans une liste primaire qui permettra de vérifier si le mot tapé
     est correct, et dans une liste secondaire de laquelle il sera retiré pour
      éviter les répétitions.Appel l'initialisation de la grille de jeu."""
    global liste_mots, liste_secondaire

    fichier = open(fichier_mots,'r')
    liste_mots = []
    while 1:
        mot = fichier.readline()
        if mot == "":
            break
        liste_mots.append(mot[:-1])
    liste_secondaire = liste_mots[:]

    fichier.close()

def select_Mot():
    """Sélectionne un mot au hazard dans la liste de mots chargé et
    la retire de la liste secondaire pour éviter les répétitions."""
    global liste_secondaire

    hazard = randrange(0,len(liste_secondaire))
    mot_a_trouver = liste_secondaire[hazard]
    del liste_secondaire[hazard]
    return mot_a_trouver

def attente_Proposition():
    """Mise à jour de la ligne courante de la grille de jeu.
    Toutes les lettres bien placées au fur et à mesure des essaies
    ont été morisées dans bonnes_lettres[], c'est ici qu'on les
     affiche.Ecoute du clavier avec appel de la fonction lettre_Tapee."""
    global ligne, tableau_de_canevas, nb_lettres, bonnes_lettres

    fen.bind('<Key>',lettre_Tapee)
    bonnes_lettres[0] = enigme[0]

    i = 0
    while i < len(bonnes_lettres) :
        couleur = 'blue'
        if bonnes_lettres[i] != '':
            couleur = 'red'
        tableau_de_canevas[ligne][i].delete(ALL)
        tableau_de_canevas[ligne][i].create_text(30,30,
                           font='Century 28 bold ',text=bonnes_lettres[i])
        tableau_de_canevas[ligne][i].configure(bg=couleur)
        i += 1

def aide():
    """Appelée en guise d'aide sur la dernière ligne de jeu pour afficher
    la première lettre non trouvée après que la main soit passée."""
    global nb_lettres, bonnes_lettres, enigme

    fen.unbind('<Key>')    
    son_aide.play()
    i = 0
    while i < nb_lettres:
        if bonnes_lettres[i] == '':
            bonnes_lettres[i] = enigme[i]
            for j in range(5):
                fen.after(100,anim_Mot(i,'red',bonnes_lettres[i]))
                fen.update()
                fen.after(100,anim_Mot(i,'blue'))
                tableau_de_canevas[ligne][i].delete(ALL)
                fen.update()

            tableau_de_canevas[ligne][i].configure(bg='red')
            tableau_de_canevas[ligne][i].create_text(30,30,
                           font='Century 28 bold ',text=bonnes_lettres[i])
            break
        i += 1

def lettre_Tapee(event):
    """Récupération de la lettre tapée(conversion en majuscule) et
    constitution de la proposition du joueur.
    Vérification de la position dans la grille de jeu."""
    global ligne, colonne, proposition, tableau_de_canevas, nb_lettres,\
                                                                mot_incorrect

    tableau_de_canevas[ligne][colonne].delete(ALL)
    c = str.upper(event.char)
    if str.isalpha(c):
        proposition.append(c)

        if colonne < nb_lettres:
            tableau_de_canevas[ligne][colonne].create_text(30,30,
                                         font='Century 28 bold ',text=c)
            tableau_de_canevas[ligne][colonne].configure(bg='purple')
            colonne += 1
        #Le nombre de lettres autorisées est atteint
        if colonne == nb_lettres:
            #Le mot tapé est envoyé dans l'algorithme de vérification
            if not verification(proposition) :
                colonne = 0
                ligne += 1
                if ligne > len(tableau_de_canevas) - 1:
                    ligne -= 1
                    if not mot_incorrect:
                        la_main_Passe()
                    attente_Proposition()
                    aide()
                attente_Proposition()
                proposition = []

def mot_Trouve():
    """Mise à jour du score et animation du mot trouvé."""
    fen.unbind('<Key>')

    for i in range(nb_lettres):
        fen.after(350,anim_Mot(i,correspondance[i][1],None,
                                                    correspondance[i][2]))

    equipes[equipe_qui_a_la_main].score += 50
    equipes[equipe_qui_a_la_main].label_score.configure(text="Score : "+
                                      str(equipes[equipe_qui_a_la_main].score))

    son_trouve.play()
    for j in range(3):
        for i in range(nb_lettres):
            fen.update()
            fen.after(50,anim_Mot(i,'green'))
        for i in range(nb_lettres):
            fen.update()
            fen.after(50,anim_Mot(i,'red'))
   
    tirage_Boules()

def verification(propo):
    """Algorithme principal
      Pour des raisons d'affichage le mot tapé est entré dans un tableau
      de correspondance du type :
      [['lettre1',couleur,son associé],['lettre2',couleur,son assoocié],
                                                                         []...]
      1)
      les lettres du mot tapé et du mot à découvrir sont comparés 2 à 2.
      Si il y a correspondance on change la couleur de la lettre en rouge
      et on la retire dans les 2 tableaux de mots intermediaires
      (reste_de_proposition,reste_d_enigme)
      2)
      Une double boucle est alors effectuée sur les lettres restantes
      en comparant une lettre du mot tapé avec celles du mot à trouver."""
    global enigme, nb_lettres, bonnes_lettres, mot_trouve, tableau_de_canevas,\
    correspondance,liste_mots, liste_secondaire, grille1, grille2, ligne,\
     colonne, mot_incorrect, equipe_qui_a_la_main

    propo_en_string = ''

    for i in propo:
        propo_en_string += i

    reste_de_proposition = propo
    reste_d_enigme = list(enigme)
    correspondance = []

    #Par défaut toutes les lettres sont considérées mauvaises
    for i in propo:
        correspondance.append([i,"blue",beep_bleu])

    #Vérifie si le mot fait parti de la liste autorisée
    mot_incorrect = False
    if propo_en_string not in liste_mots :
        fen.update()
        son_mot_errone.play()
        mot_incorrect = True
        la_main_Passe()

    #Démarrage de l'algorithme
    else :
        m = 0
        lettres_bien_tapees = 0
        while(m < nb_lettres):
            #Lettres bien placées
            if propo[m] == enigme[m]:
                
                correspondance[m][1] = "red"
                correspondance[m][2] = beep_rouge
                reste_d_enigme[m] = " "
                reste_de_proposition[m] = " "
                bonnes_lettres[m] = enigme[m]
                lettres_bien_tapees += 1
            m += 1

        if lettres_bien_tapees == nb_lettres:

            mot_Trouve()
             
            return True

        p, q = 0, 0
        while(p < len(reste_de_proposition) ):
            if reste_de_proposition[p] == " ": #On compare pas les espaces
                p += 1
                continue
            #Lettres mal placées
            while(q <len(reste_d_enigme)):
                if reste_de_proposition[p] == reste_d_enigme[q] :
                    correspondance[p][1] = "yellow"
                    correspondance[p][2] = beep_jaune 
                    reste_d_enigme[q] = " "
                    break
                q += 1
            q = 0
            p += 1

        for i in range(nb_lettres):
            fen.after(350,anim_Mot(i,correspondance[i][1],None,
                                                        correspondance[i][2]))

    tableau_de_propositions.append(correspondance)
    maj_Proposition()
    propo =[]

    return False

def maj_Proposition():
    """Toutes les propositions ont été morisées dans un tableau.
    C'est ici qu'elles sont affichées.Si leur nombre dépasse 5,
    on copie le tableau sur lui même en enlevant la 1ère."""
    global tableau_de_propositions

    for x in range(6):
        for y in range(nb_lettres):
            tableau_de_canevas[x][y].delete(ALL)
            tableau_de_canevas[x][y].configure(bg="blue")
    x = 0

    if len(tableau_de_propositions)==6:
        tableau_de_propositions = tableau_de_propositions[1:]

    for i in tableau_de_propositions:
        for y in range(nb_lettres):
            tableau_de_canevas[x][y].create_text(30,30,
               font='Century 28 bold ',text=i[y][0])
            tableau_de_canevas[x][y].configure(bg=i[y][1])
        x += 1

def anim_Mot(index,couleur,caract=None,son=None):
    """Fonction qui cré un caractère passé en paramettre, à un endroit donné de
    la grille.En alternant espace et lettre on obtient un clignotement(Aide()).
    Mais on peut aussi jouer uniquement sur la couleur de fond(mot_Trouve())."""
    if son != None:
        son.play()
    tableau_de_canevas[ligne][index].configure(bg=couleur)
    tableau_de_canevas[ligne][index].create_text(30,30,
                           font='Century 28 bold ',text=caract)
    fen.update()

def tirage_Boules():
    """Un appel récurssif de cette fonction nous donne l'etat des membres des
    instances de Grille_Loto à chaque instant.3 cas possibles :
                                     1/ il y a motus
                                     2/ boule noire tiré
                                     3/ 2 boules jaunes tirées"""
    global grilles_reinit,equipes,equipe_qui_a_la_main

    equipes[equipe_qui_a_la_main].bouton.config(state='active')

    if equipes[equipe_qui_a_la_main].ya_motus == 1:
        equipes[equipe_qui_a_la_main].bouton.config(state='disable')
        grilles_reinit = 0

        if equipes[equipe_qui_a_la_main].fin_anim == 1:
            equipes[equipe_qui_a_la_main].score += 100
            equipes[equipe_qui_a_la_main].label_score.configure\
                    (text="Score : "+str(equipes[equipe_qui_a_la_main].score))
            sleep(2)
            initialisation()
            for i in equipes:
                i.reinit_Grille()

            grilles_reinit = 1
            return

    if equipes[equipe_qui_a_la_main].boule_noire_tiree :
        la_main_Passe()
        initialisation()
        return

    if equipes[equipe_qui_a_la_main].nb_boule_jaune_tiree == 2:
        equipes[equipe_qui_a_la_main].bouton.config(state='disable')
        equipes[equipe_qui_a_la_main].nb_boule_jaune_tiree = 0
        initialisation()
        return

    fen.after(50,tirage_Boules)

def la_main_Passe():
    """Fonction qui met a jour les grilles de loto et qui passe la main à
    l'autre joueur."""
    global equipes, equipe_qui_a_la_main

    equipes[equipe_qui_a_la_main].bouton.config(state='disable')
    equipes[equipe_qui_a_la_main].boule_noire_tiree = False
    equipes[equipe_qui_a_la_main].nb_boule_jaune_tiree = 0
    equipes[equipe_qui_a_la_main].label_equipe.configure(text=" ")
    equipes[equipe_qui_a_la_main].configure(bg='white')

    equipe_qui_a_la_main += 1
    if equipe_qui_a_la_main == 2:
        equipe_qui_a_la_main = 0
    
    equipes[equipe_qui_a_la_main].label_equipe.configure(text=" A VOUS !")
    equipes[equipe_qui_a_la_main].configure(bg='maroon')

def presentation():
    """Ecrit le mot "MOTUS" sur toutes les lignes de la grille de jeu
    instanciation de 2 Grille_Loto."""
    global grille_jeu,equipes,equipe_qui_a_la_main

    motus = "MOTUS"
    tableau_de_canevas = []
    nb_lettres = 5
    grille_jeu = Frame(fen)

    for i in range(6):
        tableau_de_canevas.append([[]]*nb_lettres)

    for x in range(6):
        for y in range(nb_lettres):
            tableau_de_canevas[x][y] = Canvas(grille_jeu,bg='blue',
                              height=50,width=50,borderwidth=5,relief='ridge')
            tableau_de_canevas[x][y].create_text(30,30,
                           font='Century 28 bold ',text=motus[y])
            tableau_de_canevas[x][y].grid(row=x,column=y)

    grille_jeu.grid(row=1,column=1)

    nbrs_grille1 = ['7','17','35','49','57','11','25','29','51','59','3','19',\
                '41','43','69','5','21','33','53','63','9','23','37','45','61']
    omis_grille1 = [['7',(0,0)],['49',(0,3)],['29',(1,2)],['59',(1,4)],\
                            ['19',(2,1)],['33',(3,2)],['63',(3,4)],['9',(4,0)]]
    nbrs_grille2 = ['12','26','40','52','60','10','22','30','46','58','8','18',\
                '32','44','70','6','16','38','54','62','2','20','36','56','66']
    omis_grille2 = [['12',(0,0)],['52',(0,3)],['30',(1,2)],['58',(1,4)],\
                            ['18',(2,1)],['38',(3,2)],['62',(3,4)],['2',(4,0)]]

    equipes = []
    equipes.append(Grille_Loto(fen,nbrs_grille1,omis_grille1,'white'))
    equipes[0].grid(row=1,column=0)
    equipes.append(Grille_Loto(fen,nbrs_grille2,omis_grille2,'white'))
    equipes[1].grid(row=1,column=2)

fen = Tk()
fen.title("Motus")
fen.resizable(0,0)

barreMenu = Menu(fen)
options=Menu(barreMenu)
barreMenu.add_cascade(label="Nouvelle Partie",menu=options)
options.add_command(label = "Mots de 6 lettres",
                    command=lambda : nlle_Partie("mots6.txt"))
options.add_command(label = "Mots de 7 lettres",
                    command=lambda : nlle_Partie("mots7.txt"))
options.add_command(label = "Mots de 8 lettres",
                    command=lambda : nlle_Partie("mots8b.txt"))
options.add_command(label = "Quiter",
                    command=fen.destroy)
fen.config(menu=barreMenu)

presentation()
fen.mainloop()