Voir la source de Tutoriel:Listes, Séquence, scripts pour créer un jeu.

[[category:Tutoriel]]
Je commence un nouveau tutoriel pour montrer comment, avec quelques listes créées avec la commande ''Séquence'' et quelques scripts on peut créer facilement un petit jeu où l'on affronte l'ordinateur. 
Du point de vue didactique, l'intérêt est de faire trouver aux élèves la stratégie gagnante : en quelque sorte un petit problème ouvert et ludique pour élèves de 6ème. 

Le jeu est inspiré de l'émission Fort Boyard. Dans l'émission, il y a une séquence de mini-jeux dans la "salle du conseil". Dans ce jeu sont disposées un certain nombre de baguettes, tiré au sort comme le joueur qui commence. Chaque joueur peut tour à tour enlever une, deux ou trois baguettes. Celui qui tire la dernière baguette a perdu. Ce jeu possède une stratégie gagnante qui fonctionne très exactement les trois quarts des cas. Pas de spoiler, c'est à vous de la trouver! (niveau 6ème).

[http://www.geogebra.org/student/m52695 Voici le produit fini].


== Mise en place des objets ==

C'est la partie où l'on décide du graphisme. A dessiner sur papier, ou sous GeoGebra avec axes et grille pour les essais. J'ai fait les choix suivants: 
* créer quelques nombres entiers, réglables par curseurs, qui aideront à la mise en place: <code>n</code>, de 1 à 21, nombre de baguettes de la banque; <code>n1</code>, de 1 à 21, nombre de baguettes prises par l'ordinateur (Moi); <code>n2</code>, de 1 à 21, nombre de baguettes prises par le joueur (Joueur); <code>prisemoi</code>, de 0 à 3, nombre de baguettes que l'ordinateur va enlever; <code>prisejoueur</code>, de 0 à 3, nombre de baguettes que le joueur va enlever.
 
* Les n baguettes qu'on peut enlever: elles seront verticales, au centre de l'écran. Ce sont des segments dont le ième est le segment : [ (i/2,-2) ,  (i/2,2) ]. On crée les segments par : <br/><code>listeBanque=Séquence[Segment[(i/2, -2), (i/2, 2)], i, 1, n]</code><br/>

* Les n1 baguettes enlevées par l'ordinateur : elles seront horizontales, par paquets de 5, en haut de l'écran : <br/><code>listeMoi=Séquence[Segment[(5floor((i-1)/5), 4 - Reste[i-1, 5]/5), (5floor((i-1)/5) + 4, 4 - Reste[i-1, 5]/5)], i, 1, n1]</code><br/>

* Les n2 baguettes enlevées par le joueur : horizontales, par paquets de 5, en bas de l'écran : <br/><code>listeJoueur=Séquence[Segment[(5floor((i-1)/5), -3.5 + Reste[i-1, 5]/5), (5floor((i-1)/5) + 4, -3.5 + Reste[i-1, 5]/5)], i, 1, n2]</code><br/>

* des points placés en haut des baguettes de la banque, pour indiquer combien l'ordinateur va enlever de baguettes : <br/><code>listeSelMoi=Séquence[(i/2, 2.2), i, n, n - prisemoi + 1, -1]</code><br/>

* des points placés en bas des baguettes de la banque, pour indiquer combien le joueur va enlever de baguettes : <br/><code>listeSelJoueur=Séquence[(i/2, -2.2), i, n, n - prisejoueur + 1, -1]</code><br/>

Vous pouvez alors passer un peu de temps à colorier, épaissir, etc. Allez-y franchement, il faut que ça soit plaisant à regarder. 

== Les variables à définir ==
* <code>player</code> (entier) indique à qui c'est de joueur: 0 pour l'ordinateur, 1 pour le joueur. <code>player=1-player</code> permet de changer de joueur.
* <code>msg</code> (booléen) indique que l'ordinateur a calculé son coup, qu'il faut donc afficher ce qu'il va enlever, et faire apparaître un bouton "ok" pour effectuer le coup.
* <code>ajouer</code> (entier): calcule, en fonction du nombre de baguettes restant dans la banque, ce que l'ordinateur doit jouer. Pas de ''spoiler'', je ne donne pas sa définition!  Un exemple absurde: si on suppose que la stratégie gagnante est d'enlever 1 baguette s'il en reste un nombre pair, 2 sinon, on taperait: <code>ajouer=Si[Reste[n,2]==0,1,2]</code>. Si on veut que l'ordinateur joue au hasard, on taperait: <code>SoitValeur[ajouer,AléaEntreBornes[1,3]]</code>.
*<code>fini</code> (booléen): indique si la partie est finie ou non.

== Mise en place des interactions ==
Je prévois : 
* un bouton "nouvelle partie" qui tire au sort n, met n1 et n2 à zéro et décide de qui commence;
* un script 'par clic' sur la liste des baguettes, qui permet de sélectionner le nombre de baguettes que le joueur va prendre.
* une zone avec un texte et un bouton "OK": l'ordinateur calcule son coup, annonce "je prends 1 (ou 2, ou 3)", et le coup n'est exécuté que quand on a cliqué sur "OK": ça donne ainsi le temps de voir le coup de l'ordinateur, qui serait immédiat sans le bouton "OK".
* Un texte qui affiche le nombre de baguettes restant dans la banque.
* un bouton "joueur", avec comme légende une flèche vers le bas (ou logique dans la liste des symboles), qui permet à l'utilisateur d'enlever ses baguettes.

=== Bouton "nouvelle partie" ===
Mettre dans son script (Par Clic):

:<code>SoitValeur[n,AléaEntreBornes[6,21]]
:n1=0
:n2=0
:SoitValeur[prisemoi,ajouer]
:prisejoueur=0
:SoitValeur[player,AléaEntreBornes[0,1]]
:SoitValeur[msg,Si[player==0,true,false]]</code>


{{note|1=Pourquoi <code>SoitValeur[n,AléaEntreBornes[6,21]]</code> et non <code>n=AléaEntreBornes[6,21]</code> ? Dans le deuxième cas, on change la définition de l'objet n, initialement nombre libre, éventuellement limité par la définition de son curseur. A chaque fois qu'on appuie sur la touche F9, même en cours de partie, n sera changé. Dans le premier cas, on se contente de modifier la valeur de n, tout en le laissant libre.
}}

{{note|Explication: le script tire au hasard entre 6 et 21 le nombre de baguettes initialement dans la banque, met à 0 les baguettes prises par les opposants, calcule ce que doit jouer l'ordinateur (même si ce n'est pas à lui de jouer), décide à qui est-ce de jouer, et selon la valeur de cette dernière variable, affiche ou non le message de l'ordinateur.}}



=== Saisie du nombre de baguettes enlevées par le joueur ===
Le joueur choisit le nombre de baguettes qu'il enlève en cliquant sur la banque. On rajoute un script 'par clic' sur listeBanque: 

:<code>prisejoueur=Reste[prisejoueur+1,4]</code>


=== Bouton joueur ===
C'est le bouton, avec une flèche vers le bas, qui permet au joueur de jouer son coup. Son script est: 

:<code>n=n-prisejoueur
:n2=n2+prisejoueur
:player=0 
:SoitValeur[prisemoi,ajouer]
:msg=true</code> 


{{note|1=Le script effectué : la banque est diminuée de <code>prisejoueur</code> baguettes; le tas du joueur est augmenté d'autant; c'est à l'ordinateur de jouer; il joue <code>ajouer</code> baguettes; le message est affiché.}}

=== bouton OK ===
Ce bouton est affiché quand l'ordinateur a affiché son coup. Son but est de laisser le temps au joueur de réfléchir au coup de l'ordinateur avant que celui-ci ne soit joué. Quand le bouton est pressé, l'ordinateur joue son coup, le joueur est changé. Voici son script: 

:<code>n=n-prisemoi
:n1=n1+prisemoi
:player=1
:prisejoueur=0</code> 

== Synchroniser les affichages ==
Il s'agit de faire en sorte que les différents boutons et messages s'affichent uniquement quand c'est à la bonne personne de jouer.
* Quand c'est à l'humain de jouer : dès qu'il a cliqué sur les baguettes, et que le nombre de baguettes sélectionnées est 1, 2 ou 3, le bouton "joueur" (flèche vers le bas) s'affiche. On lui met donc comme condition d'affichage :<br/><code>player ≟ 1 ∧ (prisejoueur > 0) ∧ (¬fini)</code>

Ce bouton s'affiche donc si les trois conditions suivantes sont réunies: (1) c'est à l'humain de jouer, (2) il a sélectionné au moins une baguette, (3) la partie n'est pas finie.
* Quand c'est à l'ordinateur de jouer (son coup est calculé dans la variable <code>ajouer</code>) : un message est affiché. On peut se contenter d'une zone texte affichant la variable <code>ajouer</code>, avec comme condition d'affichage : <br/><code>player ≟ 0 ∧ msg ∧ (¬fini)</code>

On met la même condition d'affichage au bouton OK.

Enfin les deux listes de baguettes sélectionnées ne s'affichent que quand c'est à la bonne personne de jouer, donc :
* la condition d'affichage de <code>listeSelMoi</code> est <code>player==0</code>
* la condition d'affichage de <code>listeSelJoueur</code> est <code>player==1</code>.

== Fin de partie ==
Il reste à détecter la fin de partie. C'est simple, c'est quand n=1 (il ne reste plus qu'une baguette à la banque). Si joueur=0, l'ordinateur a perdu, sinon l'inverse.

On définit donc 
* <code>joueurgagnant = player ≟ 0 ∧ n ≟ 1</code>
* <code>moigagnant = player ≟ 1 ∧ n ≟ 1</code>
* <code>fini = joueurgagnant ∨ moigagnant</code>
* Un message "tu as gagné" avec comme condition d'affichage: <code>joueurgagnant</code>.
* Un message "tu as perdu (c'est bien fait)" avec comme condition d'affichage: <code>moigagnant</code>.

C'est tout ! Il est assez facile de coder des mini-jeux sur ce principe (morpion, etc) : le tout est de trouver comment calculer la variable <code>ajouer</code>!
[[es:Tutorial:Listas, Secuencias y Guiones para Jugar]]