.

.

.

PROGRESSION D’UN PROJET: Littérature

A. LE PROJET :

B. INTERFACE GRAPHIQUE :

C. AFFICHER DES IMAGES :

D. UTILISER LA SOURIS :

E. LISTES ET CHAINES DE CARACTERES :

F. FICHIERS :

G. FINALISER LE PROGRAMME :

.

PROGRESSION D’UN PROJET:

  1. LE PROJET :
  1. L’objectif :

L’objectif du projet est de s’appuyer sur la fabrication d’un jeu pour apprendre à programmer et à utiliser des algorithmes. Nous allons faire un jeu qui propose des lettres. L’utilisateur doit trouver des mots pour obtenir des points. Le nombre de points va faire changer le niveau et le nombre de lettres proposées sera augmenté.

convert mp4 to webm by EasyHtml5Video.com v3.9.1

On doit avoir un programme principal le plus léger possible, ceci étant une façon de programmer plus facilement. Donc on doit parler des modules qui contiennent des fonctions utilisées par le programme principal.

.

Séance n°1 :

Déterminer la structure du programme et reprendre la définition des fonctions pour construire des modules.

tableau.py

def Tableau(ligne,colonne) : Fabrique un tableau de données

def remplir(ligne,colonne):

def melange(liste) : Mélange les lettres

def emplacement(niveau,x,y):

def verifie_coords(can,position,niveau):

souris.py

def coordonnees(colonne,ligne):

def souris_clic(event,can,position,marque):Met en avant la lettre sélectionnée.

def souris_deplace(event,x1,y1,can,colonne,ligne,position,marque):

def souris_releve(event,x2,y2,can,colonne,ligne,position,marque):

Place la lettre avec les coordonnées.

valide.py

def lire_fichier(fichier,mot):

def choisir_mot(nombre):

def rechercher(mot):

projet.py

def l_niveau(fenetre,can,l_image,l,h,niveau,position):

commandes(fenetre,can,l_image,l,h,niveau,position)

dessine_fond(fenetre,can,l_image,l,h,niveau)

position=dessine_lettres(fenetre,can,l_image,l,h,niveau,mot,position)

position=deplacement(can,position)

def commandes(fenetre,can,l_image,l,h,niveau,position):

def valider(fenetre,can,l_image,l,h,niveau,position):

def jouer(fenetre,can,l_image,l,h,niveau,position):

affiche_le_niveau(fenetre,can,l_image,l,h,niveau,position)

def quitter(fenetre):

def dessine_lettres(fenetre,can,l_image,l,h,niveau,mot,position):

def dessine_fond(fenetre,can,l_image,l,h,niveau):

def affiche_le_niveau(fenetre,can,l_image,l,h,niveau,position):

def deplacement(can,position )

#—————– Programme Principal —————–#

fenetre=Tk()

initialisation des variables

Création d’un widget ‘Canvas’ contenant une image png :

jouer(fenetre,can,l_image,l,h,niveau,position) 

fenetre.mainloop()

#——————————————————-#

.

INTERFACE GRAPHIQUE :

Propriétés des fenêtres :

.

Séance n°2 :

Utilisation du module tkinter pour obtenir le premier écran du jeu.

  • Rappel de la construction d’une fenêtre.
  • Construction d’un Canevas.
  • Affichage d’images dans une fenêtre et dans un Canvas.
  • image2Placement d’objets dans un écran (Méthode GRID)

Ecriture du premier programme

image3

image4

.

AFFICHER DES IMAGES :

.

Séance n°3 : Propriétés des listes 

Construction des images avec le logiciel The GIMP et écriture du module image.pyimage5

image.py

Mettre les images dans une liste pour pouvoir les utiliser par toutes les fonctions. (Ce module doit fonctionner dans le programme principal, sinon les images ne sont pas utilisables)

image6

.

On peut maintenant utiliser les images dans toutes les fonctions du programme.

Il faut ajouter dans le fichier projet.py la ligne :

from image import*

Cela permet de bénéficier des fonctions du module image et surtout il n’est plus à l’origine d’erreurs.

C’est le plus grand bénéfice des modules.

.

Séance n°4 : Utilisation du module image :

Introduction des marques (tags).
  • Une marque tag= ‛texte ’ est une chaîne de caractères que l’on peut associer à un objet crée dans un canevas. Lorsque can.tag_bind est appelée elle exécute la fonction associée au tag.
  • Introduction de la fonction lambda. Elle permet de passer des paramètres dans les fonctions et donc de ne pas se servir de variables globales.

image7

image8

Les fonctions suivantes ne seront plus modifiées.

image9

image10

image11

image12

image13

fonction jouer

image14

fonction affiche_le_niveau

fonction l_niveau

image15

fonction dessine_fond

fonction commandes

image16Pour afficher un mot on ajoute la fonction

image17

.

UTILISER LA SOURIS :

.

Séance n°5 : Ecrire un module souris.py

Fonctionnement de la souris :

  • Revoir les propriétés des boutons de la souris : “<Button>”………
  • Une marque tag= ‛texte ’ est une chaîne de caractères que l’on peut associer à un objet crée dans un canevas. Lorsque can.tag_bind est appelée elle exécute la fonction associée au tag.
  • Fonction lambda. Elle permet de passer des paramètres dans les fonctions et donc de ne pas se servir de variables globales.
  • On peut utiliser la souris pour déplacer des objets qui possèdent une marque (tag en python)

image18

On peut déplacer les lettres, mais il faut rajouter une fonction dans le programme principal

deplacement(can,position )

image19

Il faut rajouter la fonction deplacement dans la fonction l_niveau

Déplacement des widgets :

  • On a des fonctions qui affichent les images et les lettres.
  • On va mettre des marques (tag) aux lettres pour les déplacer à l’aide du module souris.py
  • On va déplacer les lettres du mot DEUX

image20

image21

.

LISTES ET CHAINES DE CARACTERES : 

.

Séance n° 6 : Comment placer les lettres dans les fonds qui les attendent.

Propriétés des chaînes de caractères.

Propriétés des listes.

  • On va créer un module qui va contenir la fonction qui construit les tableaux et la fonction qui mélange les contenus des listes ;
  • Faire une fonction qui remplit le tableau des données nécessaires aux déplacement des lettres, et qui va contenir le score et le mot choisi au hasard.

Voici un tableau de 4 lignes et de 5 colonnes

  Colonne 0 Colonne 1 Colonne 2 Colonne 3 Colonne 4
Ligne 0 position[0][0] position[0][1] position[0][2] position[0][3] position[0][4]
Ligne 1 position[1][0] position[1][1] position[1][2] position[1][3] position[1][4]
Ligne 2 position[2][0] position[2][1] position[2][2] position[2][3] position[2][4]
Ligne 3 position[3][0] position[3][1] position[3][2] position[3][3] position[3][4]

Voici une partie du code que l’on veut obtenir :

ligne=4

colonne=5

position = remplir(ligne, colonne)

ligne 0 :

lettre=’‘

position[0][colonne]=[colonne,0,lettre,niveau,marque, ‘vide’,x,y]

ligne 1 :

mot=’DEBUT’

lettre=mot[colonne]

position[1][colonne]=[colonne,1,lettre,niveau,marque, ‘plein’,x,y]

ligne 2:

mot=’DEBUT’

lettre=mot[colonne]

position[2][colonne]=[colonne,2,lettre,niveau,marque, ‘plein’,x,y]

ligne 3:

position[3][0]=[score,3,’‘,niveau,marque, ‘plein’,x,y]

position[3][colonne]=[colonne,3, ‘’, niveau, marque, ‘plein’,x,y]

Le score, niveau et le mot à trouver sont stockés dans le tableau que l’on appelle position.

Voici l’emplacement des données.

position[3][0][0]=score

position[3][0][3]=niveau

position[3][1][2]=mot

position[3][1][5]=’change’

Ecrire un module tableau.py

image22

def Tableau(ligne,colonne)

def remplir(ligne,colonne)

def melange(liste)

Les fonctions : sont faites pour fabriquer un tableau de données ;

Les deux suivantes sont faites pour faire fonctionner le programme, pour éviter que les lettres s’empilent.

def emplacement(niveau,x,y)

def verifie_coords(can,position,niveau)

image23

.

Séance n°7 : Utilisation du module tableau.py

On fabrique un tableau, on mélange une liste et on peut déterminer dans quelle ligne et colonne on peut situer les données, à partir des coordonnées de la lettre.

position[ligne][colonne]=[colonne,ligne,lettre,niveau,marque,’vide’]

Les données d’un jeu sont stockées dans le tableau position.

position[3][0][0]=score

position[3][0][3]=niveau

position[3][1][2]=mot

Changement dans le programme principal :

position=remplir(4,8)

Changements dans le module souris :

image24

.

FICHIERS :

.

Séance n°8 : Comment stocker les mots et les avoir disponibles rapidement.

Utilisation des fichiers :

On utilise des fichiers texte qui contiennent des mots classés alphabétiquement par nombre de lettres.

image25

8.txt contient 20 000 mots de 8 lettres.

7.txt contient 16 000 mots de 7 lettres.

6.txt contient 10 800 mots de 6 lettres.

5.txt contient 5 600 mots de 5 lettres.

4.txt contient 2 100 mots de 4 lettres.

**Ecrire un module valide.py **

Il faut des fonctions qui ont pour objectif

  • Lire un fichier qui contient des mots d’un nombre de lettres défini.
  • Rechercher si un mot appartient à un fichier.
  • Obtenir un mot de façon aléatoire.

def lire_fichier(fichier,mot)

def choisir_mot(nombre)

def rechercher(mot)

image26

.

FINALISER LE PROGRAMME :

.

Séance n°9 : Changement des fonctions du fichier projet.py pour utiliser le module valide.

Les fonctions suivantes ne seront plus modifiées.

image27

image28

image29

image30

image31

Dans cette fonction qui affiche le mot position[3][1][5]==’change’ détermine s’il faut changer de mot .

image32

image33La fonction commandes contient la fonction valider :

Si **position[3][1][5]==’change’ **:

l_niveau change de mot, sinon l_niveau affiche le même mot car il n’a pas été validé  par la fonction valider.

La fonction **valider **:

Elle détermine si le mot proposé par l’utilisateur fait partie des fichiers txt qui contiennent les mots.

Si c’est vrai alors position[3][1][5]==’change’

Sinon position[3][1][5]==’change pas’

image34

Ne pas oublier de vérifier la fonction deplacement.

image35

.

Séance n°10 : Modifier la règle du jeu et l’apparence.

On peut modifier la couleur des lettres, l’objectif à atteindre ……

image36

Cette séance est destinée à valoriser l’imagination de chaque personne qui a suivi cette progression.