Un marcheur est prisonnier d'un labyrinthe. On souhaite l'amener à la sortie. On préférerait donner une méthode qui fonctionne quelque soit le labyrinthe.

Dans cet exercice, on se concentre sur la partie algorithmique.

Pour rendre l'exercice plus agréable, on fournit une interface graphique qui permet de voir le personnage parcourir le labyrinthe.

À la fin vous devrez donc avoir un programme qui affiche le parcours du marcheur à travers le labyrinthe, jusqu'à la sortie.

Le module exploite Tkinter. Vous pouvez le télécharger : laby_tk.py

Ce module permet de créer facilement un labyrinthe, de l'afficher à l'écran, d'afficher le marcheur qui parcours le labyrinthe et enfin de manipuler le marcheur.

Vous allez un créer un fichier python, par exemple sortir_laby.py. Il devra être placer dans le même dossier que laby_tk.py et commencer par :

from laby_tk import Laby

Vous pouvez créer un labyrinthe en donnant une grille :

grille = [
"********************",
"D   *     *    * * *",
"*** * *** * ** * * A",
"*   * * * * *  * * *",
"* *** *   * * ** * *",
"*     * * * * *    *",
"*********   * * ****",
"*         *        *",
"********************"
]

Il s'agit d'une grille composée de lignes de texte. Chaque caractère correspond à une case du labyrinthe. Les * sont des murs, D est le point de départ qui doit être unique et A est l'arrivée. Il peut y avoir plusieurs arrivées.

Ensuite cette commande crée le labyrinthe :

laby = Laby(grille)

Toute la suite consistera à manipuler laby.

Au lieu d'écrire le texte représentant le labyrinthe à l'intérieur du fichier programme, vous pouvez écrire le labyrinthe dans un fichier à part. Par exemple : laby_exemple.txt

Vous pourrez alors créer votre objet labyrinthe directement en le chargeant :

laby = Laby.load('exemple_laby.txt')

Maintenant que laby est créé, vous pouvez donner des commandes de mouvement au marcheur qui parcours le labyrinthe.

laby.avancer()        # avance d'un pas
laby.tourner_gauche() # tourne d'un quart de tour à gauche
laby.tourner_droite() # tourne d'un quart de tour à droite

Attention : si vous avancez contre un mur, vous aurez une erreur.

Vous pouvez aussi tester les cases voisines du marcheur pour savoir ce qu'il peut faire :

laby.mur_devant()   # renvoie True s'il y a un mur devant le marcheur
laby.mur_a_gauche() # renvoie True s'il y a un mur à gauche
laby.mur_a_droite() # renvoie True s'il y a un mur à droite

Chaque fois que vous donnerez une consigne de mouvement, l'affichage se rafraîchira. Mais à la fin, quand il n'y aura plus de mouvements, la fenêtre graphique disparaîtra. Pour l'empêcher de disparaître, vous disposez de la commande :

laby.fin()

À n'utiliser qu'à la toute fin !

Selon la puissance des machines, il n'est pas toujours évident de régler la vitesse d'affichage. Si vous trouvez l'animation trop lente, vous pouvez accélérer un peu ne utilisant :

laby.faster()

Vous pouvez l'utiliser plusieurs fois pour accélérer davantage.

Prenant en compte ce que j'ai dit plus haut, voici un programme qui vous affichera un labyrinthe et fera faire quelques pas au marcheur.

# fichier à placer dans le même dossier que laby_tk.py

from laby_tk import Laby

grille = [
"********************",
"D   *     *    * * *",
"*** * *** * ** * * A",
"*   * * * * *  * * *",
"* *** *   * * ** * *",
"*     * * * * *    *",
"*********   * * ****",
"*         *        *",
"********************"
]

laby = Laby(grille)

laby.avancer()
laby.avancer()
laby.avancer()
laby.tourner_droite()
laby.avancer()
laby.avancer()

laby.fin() # fin du programme, maintien de la fenêtre