Dans cette dernière page, on présente un exemple de sujet de Bac Blanc. Celui-ci a été donné en 2016-2017 au Lycée Lacassagne. Il est fidèle à l'original, mis à part le code-source de départ donné aux élèves. Aucun exemple de correction ne sera non plus donné puisqu'un des thèmes de validation de cette formation porte sur le Jeu de la Vie.

Les élèves, regroupés en binôme ou en trinôme, ont pu travailler quatre semaines sur ce sujet. Il a été distribué au début d'une séance d'ISN à la veille des vacances de février, ils ont eu toute la séance pour étudier ce sujet puis ont dû rendre leur travail à la fin de la séance d'ISN suivant la rentrée.

Les élèves n'ayant eu que trois séances (ce qui est déjà beaucoup !) pour travailler sur les interfaces graphiques, l'évaluation est faite par paliers : de nombreux points pour l'algorithmique qui sous-tend le jeu, peu de points pour des améliorations (indépendantes les unes des autres) de «l'expérience de jeu».

Ce bac blanc est un projet à mener en groupe. Il s'agit de programmer le «jeu de la vie» inventé par le mathématicien britannique John Horton Conway.

Plusieurs paliers de réalisation sont possibles. Il faudra penser à ajouter des commentaires pertinents et à sauvegarder régulièrement les fichiers sous de nouveaux noms... Les compétences évaluées seront :

• C2.2 Structurer
  une approche fonctionnelle en réponse à un besoin...
• C2.3 Développer
  une interface logicielle, un programme...
• C3 Collaborer au sein d'une équipe dans le cadre d'un projet
  agir au sein de l'équipe, rechercher et partager

La production finale est à rendre impérativement le ...

Le «jeu de la vie» est un automate cellulaire, un modèle où chaque génération de cellules conduit mécaniquement à la génération suivante.

Dans une grille, chaque case carrée de côté d représente une cellule. Chaque cellule peut ainsi avoir jusqu'à 8 voisines. Ci-contre, la cellule grise a huit voisines (leur numérotation est arbitraire et n'est là que pour mieux visualiser ces voisines).

Une cellule naît, vit ou meurt selon l'état antérieur de ses voisines :

• une cellule morte (blanche) renaît (devient noire) si elle possède exactement trois voisines vivantes ;
• une cellule vivante (noire) reste en vie (reste noire) si elle possède exactement deux ou trois voisines vivantes.
• dans tous les autres cas, la cellule meurt ou reste morte...

Les dessins suivants ne seront pas évalués : ils sont là pour vous permettre d'appréhender le comportement des cellules.

Déterminer les étapes obtenues à partir des configurations initiales suivantes :

Le fichier Bac_Blanc_Jeu_Vie.py joint avec ce polycopié permet de générer l'interface graphique.

• cellules est un tableau (une liste de listes) contenant à chaque instant l'état de la cellule : 1 pour vivante, 0 pour morte.
• Le tableau cellules est associé au tableau grille, de mêmes dimensions lignes*colonnes. Une case est repérée par ses coordonnées [i][j].
• Dans le Canvas nommé dessin, la cellules[i][j] sera tracée sous la forme d'un carré de côté d pixels et de couleur c (c prendra la valeur 'white' si la cellule est morte, 'black' si la cellule est vivante) avec :

  
  dessin.create_rectangle(2+j*d, 2+i*d, 2+(j+1)*d, 2+(i+1)*d, outline='black', fill=c)
  						

La fonction reinit() permet de recommencer un nouveau jeu et de générer une grille vierge, remplie de cellules « mortes ». Écrire la définition de la fonction tirage_alea() qui doit remplir aléatoirement la grille de cellules vivantes :

1. Initialisez un entier aléatoire compris entre 100 et 200 qui correspondra au nombre de cellules vivantes à placer dans la grille.
2. Déterminez aléatoirement les numéros de ligne et de colonne où doit se situer cette cellule « naissante » (avant, la cellule devait être morte).
3. Modifiez la valeur de cette cellule et l'affichage de la case correspondante à l'écran. Cliquez alternativement sur les boutons [Tirage aléatoire] et [Grille vierge] pour tester cette fonction.

Comment décompter le nombre de voisines vivantes de cellules[i][j] ?

1. Complétez la définition de la fonction voisines() qui renvoie une liste des coordonnées des voisines de cellules[i][j] qu'elles soient mortes ou vivantes. Ainsi voisines(0, 0, lignes colonnes) renvoie [[0, 1], [1, 1], [1, 0]] (pas forcément dans cet ordre).
   Attention aux cases des bords et des coins du plateau...
2. Compléter la fonction compte_voisines() qui retourne le nombre de voisines de cellule[i][j] qui sont vivantes.
   Il faudra faire appel à la fonction voisines()...

Complétez les instructions de la fonction suivant() qui doit permettre l'affichage de la prochaine génération de cellule. Pour cela :

1. Identifiez les variables globales nécessaire.
2. Utilisez compte_voisines() définie à la question précédente.
3. Identifiez les cellules qui « change d'état » puis modifiez à l'écran uniquement l'apparence de ces cellules.
4. Testez enfin le bon fonctionnement du bouton [Génération suivante].

En utilisant une variable globale booléenne :

1. Complétez les définitions des fonctions automate() et suivant() pour que, lors du clic sur le bouton [Démarrer l'automate], l'affichage passe automatiquement à l'étape suivante toutes les 100 millisecondes.
2. Complétez la définition de la fonction stopper() pour que l'animation s'arrête en cas de clic sur [Arrêter l'automate].

A présent les six boutons doivent être actifs et indépendant les uns des autres.

Les trois étapes suivantes peuvent être réalisées dans n'importe quel ordre. Elles permettent d'améliorer « l'expérience de jeu » et les fonctionnalités du programme (ainsi que la note obtenue pour ce travail).

Elles sont aussi beaucoup moins guidées que les étapes précédentes...

Lorsque l'automate est stoppé, définir les fonctions permettant à l'utilisateur de « transformer » une cellule morte en vivante (et vice-versa) d'un clic de souris.

Vous pouvez tester cette fonctionnalité en partant des structures suivantes :

Entre chaque nouvelle génération, les cellules à naître doivent être de couleur verte avant de devenir noire, les cellules en fin de vie doivent être affichées en rouge avant de devenir blanche. Il y a donc deux types d'affichages en alternance :

• Un affichage noir et blanc des cellules vivantes et mortes à l'instant t
• Un affichage noir, blanc, vert et rouge pour les cellules vivantes qui resteront vivantes, les cellules mortes qui resteront mortes, les cellules mortes qui vont (re)naître et les cellules vivantes qui vont mourir à l'instant t+1

Un exemple ci-dessous :

Rajoutez plusieurs Button initialisant une figure de départ permettant de réaliser automatiquement des « Canons à planeurs », des « Puffeurs » ou encore des « Spacefillers ». Vous pouvez visiter le site suivant pour plus de renseignements :

http://t0m.free.fr/jdlv/jdlv_vivant.htm

Votre programme pourrait, par exemple, « lire » les fichiers au format .lif (qui sont des fichiers textes...) disponibles sur ce site.

Un exemple de départ pour Canon à planeurs :