Vous vous apprêtez à lire un tutoriel rédigé par un membre de ce site. Malgré tout le soin que ce membre a pu apporter au tutoriel, nous ne pouvons pas garantir que les informations contenues sur cette page sont exactes à 100%. Merci de garder cela en tête lorsque vous lirez cette page ;o)
Voilà une petite série de TPs (Travaux Pratiques) que vous devrez être en mesure de réaliser. Allons-y !
Nous y voici enfin ! Votre premier TP !
Je n'ai en ce moment, je dois dire, que très peu de temps à vous consacrer. Mais je fais de mon mieux et j'arrive donc aujourd'hui avec le TP du jeu + ou -.
Vous connaissez tous ce jeu, n'est-ce pas ?
Bah oui bien sûr, quoique, heu en fait non pas vraiment...
Le jeu consiste à faire deviner le nombre mystère choisi de manière aléatoire (oula...) par la calculatrice en un nombre limité de coups, et tout ça par le biais d'indices simples, tels que "Non c'est plus !" ou encore "Non c'est moins !", d'où le nom du jeu vous l'aurez compris ! Vous êtes prêts ? Alors allons-y !
Par où commencer ?
Par la théorie ! Eh oui, le passage obligé (même pour les petits jeux) que malheureusement beaucoup zappent ! A tort, bien sûr. C'est absolument indispensable si vous ne voulez pas vous paumer dans votre propre code, car la calculatrice impose une contrainte de plus : un faible champ de vision !
Un bon brouillon s'impose donc.
Ok cool, un brouillon, pas de problème, mais heu, faut écrire quoi dessus ?
Le brouillon s'organise en plusieurs étapes :
De prime abord
Dans un premier temps, il serait bien de recenser toutes les variables dont on aura besoin dans notre code, en signalant clairement ce que chacune signifiera.
Réfléchissons :
- on aura tout d'abord besoin d'une variable M "nombre mystère",
- puis ensuite d'une variable "nombre entré" N.
En théorie, ces deux variables nous suffiraient. Bien sûr, vous pouvez choisir la lettre que vous voulez pour les définir.
Réfléchir sur les boucles
Avant de réfléchir sur la boucle la plus appropriée, il faut d'abord réfléchir sur ce que l'on veut faire.
- 1. Le nombre mystère est choisi.
- 2. On demande d'entrer un nombre à l'utilisateur.
- 3. Une fois le nombre rentré, plusieurs possibilités s'offrent à nous :
- 4. soit N est supérieur à M, et dans ce cas on affiche "Plus petit",
- 5. soit N est inférieur à M, et on affiche "Plus grand",
- 6. soit N = M, et dans ce cas on affiche "Bravo".
- 7. Si le nombre mystère n'a pas été trouvé, on retourne à l'étape 2.
- Si le nombre mystère est trouvé, le programme s'arrête.
Voilà tout le nécessaire pour le moment.
Voici maintenant le moment où il faut réfléchir sur la boucle la plus appropriée.
Il paraît évident que la boucle
If est la seule appropriée (avec le saut conditionnel) pour les parties 4 à 6.
Vient ensuite la boucle principale. Celle qui englobera tout le programme. Bien sûr, vous pourriez choisir la facilité et utiliser des
Goto, mais inconsciemment vous choisiriez ainsi la lenteur d'exécution. Certes, pour un programme tel que celui-ci ce n'est pas très important, mais plus tard ça le sera.
Je vous conseille donc (je vous ordonne même
) d'utiliser la boucle
Do/LpWhile qui englobera tout le programme.
Concrètement celui-ci se présentera ainsi :
- 1. On crée le nombre mystère aléatoirement.
- 2. On initialise la boucle Do.
- 3. Le programme se déroule (boucle if et compagnie).
- 4. LpWhile N n'est pas égale à M.
Voilà donc pour la théorie ! Vous devriez être prêts pour la pratique !
La pratique
Ok c'est bon, je suis chaud bouillant là ! Je vais suivre les indications à la lettre ! Alors... "1. Le nombre mystère est choisi". Arg ! C'est quoi ça ? Comment on crée un nombre aléatoirement ?
Effectivement, je ne vous ai toujours pas indiqué la marche à suivre. Je vous donne la syntaxe, et j'explique ensuite :
Int(100Ran#+1)
J'en vois déjà tirer des têtes de six pieds de long ! Mais rassurez vous, c'est très très simple !
Tout d'abord le référencement :
Int : OPTN / F6 / F4 / F2
Ran# : OPTN / F6 / F3 / F4
Maintenant j'explique :
- Int permet d'arrondir un résultat.
- 100 est le nombre qui définira la zone à prendre en compte (ici les nombres de 0 à 99).
- Ran# est la commande qui choisira un nombre aléatoire (random en anglais).
- Le + 1 est très important. Sans lui, la calto choisirait un nombre entre 0 et 99. Grâce à lui, elle choisira entre 1 et 100 !
Le
Int est primordial, car la calto choisira un nombre entre 1 et 100, mais que ferez-vous si elle choisit 68.7548135 ? Le
Int arrondira le tout, et il ne sera gardé que le 68. Au final, si vous voulez stocker ce nombre dans la variable M, il faudra écrire :
Int(100Ran#+1)->M tout simplement.
A vous de jouer !
Vous avez maintenant tous les outils en mains : allez, faites-moi tous de beaux programmes (même ceux qui ont un peu d'avance
).
Posez vos caltos ! C'est l'heure de la correction !
Tout d'abord, si vous avez réussi : bravo ! Je vous félicite. Par contre, si vous avez un peu séché, je vous conseille de relire le cours et vous devriez y arriver. Si vraiment vous aviez toujours des problèmes, regardez la correction et essayez de comprendre vos erreurs.
Secret (cliquez pour afficher)Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| Int (100Ran#+1)->M #On génère le nombre mystère
Do #on initialise la boucle, elle englobera tout le programme
"NOMBRE "?->N #On garde le nombre entré dans la variable N
If N>M
Then "PLUS PETIT"
Else If N>M
Then "PLUS GRAND"
Else "BRAVO" #si N est ni inférieur ni supérieur à M, ça signifie qu'il est égal
IfEnd
IfEnd
LpWhile N!=M #La boucle se répète tant que le nombre mystère n'a pas été trouvé
Stop |
Vous trouverez le
Stop ici :
SHIFT / PRGM / F2 / F4
Il permet d'arrêter le programme si vous appuyez sur AC/ON, mais si vous appuyez sur
EXE, le programme reprendra.
Je vous invite, pour prendre un peu d'avance sur le prochain TP, à vous rendre sur le tuto de Lpu8er.
Vous voyez : ce n'était pas si compliqué.
Quelques idées d'améliorations
Vous pouvez maintenant améliorer ce programme :
- ajouter un menu (à l'aide des techniques que vous connaissez) dans lequel pourraient figurer les crédits, le choix de la difficulté, la version du programme, etc.
- Inclure un mode deux joueurs.
- Demander le choix de la difficulté (100 ; 1000 ; 10000) : il faudra alors une nouvelle variable, D par exemple, qui contiendra le nombre correspondant à la difficulté. Vous devrez donc écrire :Int(DRan#)+1
- Un compteur de coups.
- etc.
Vous avez de quoi vous amuser pour un petit moment ! Et puis, pour peu que vous arriviez à faire tout ça (et je suis sûr que vous y arriverez), le TP 2 vous attend ! N'est-ce pas merveilleux...
Abordons maintenant le second TP qui, je dois bien le dire, vous sera très utile plus tard !
Ce programme peut tenir en seulement 3 lignes de code ! Oui vous avez bien lu, par conséquent il va être très rapide pour moi de vous indiquer la marche à suivre :
- 1. On veut afficher la valeur du Getkey entrée par l'utilisateur.
- 2. Et c'est tout !
Bien sûr, ce programme nécessite au moins une boucle : celle qui englobera tout le programme.
A vous de jouer !
Derniers petits indices :
- vous n'avez pas besoin de "vraies" variables, car la valeur assignée à Getkey est stockée dans la variable Ans.
- Vous utiliserez l'instruction Locate pour afficher la valeur.
- Je vous force à utiliser la boucle Do/LpWhile pour corser un tout petit peu le programme.
Je pense avoir quand même laissé un nombre suffisant d'indices... Par conséquent, vous devriez être tous en mesure de réaliser ce mini-programme qui vous sera d'une grande aide plus tard.
Posez vos caltos, c'est l'heure de la correction !
Secret (cliquez pour afficher)Code : Autre1
2
3
4
5
| Do
Locate 9,4,Getkey #eh oui, on peut faire ça !
LpWhile 1=1 #la boucle sera répétée tant que 1=1 c'est-à-dire tout le temps. |
Le troisième TP sera plus dur... alors tenez vous prêts.
Voici maitenant le dernier TP de cette Partie concernant un jeu mondialement connu, j'ai nommé : Le "Pierre / Feuille / Ciseau" !
Autant vous le dire tout de suite, ça ne va pas être aussi simple que le jeu du "+ ou -". Pas beaucoup plus dur en fait, mais disons qu'il nécessitera plus de réfléxion de votre part. Commençons :
Si je dis théorie, vous me répondez quoi ?
"Brouillon" bien sûr. Comme d'habitude, il faut commencer par une réfléxion sur papier. Bon, étant encore dans la Partie I, je vais vous guider un peu.
Dans un premier temps
Comme pour le jeu précédent, nous allons recenser toutes les variables dont on aura besoin :
- tout d'abord, il nous faut une variable dans laquelle sera stockée un chiffre (entre 1 et 3) qui indiquera le choix de l'ordinateur. Par exemple, 1 correspondrait à la pierre, 2 à la feuille et 3 au ciseau.
- Une variable avec comme valeur le choix du joueur. On pourrait reprendre l'exemple ci-dessus.
Ce sont les deux seules variables vraiment indispensables pour réaliser ce programme.
Maintenant, préoccupons-nous du déroulement du programme.
Il faut à présent avoir une réflexion rigoureuse et linéaire sur les différentes boucles que l'on utilisera.
- 1. On génére un nombre aléatoire compris entre 1 et 3, qui correspondra au choix de la calto, dans la variable A.
- 2. On fait un menu (voir ci-dessous pour un peu d'aide) qui demande au joueur de choisir entre pierre, feuille ou ciseau.
- 3. On stocke la demande dans la variable B, par exemple.
- 4. Ensuite, plusieurs choix s'offrent à nous :
- 5. soit le joueur perd,
- 6. soit le joueur gagne.
- 7. On demande au joueur s'il veut faire une autre partie, et au besoin on retourne à l'étape 1.
Le menu
Si l'on y réfléchit bien, un menu est en fait très simple à réaliser. Il consiste juste à effectuer une action en fonction d'une touche pressée par l'utilisateur.
Vous l'aurez compris, vous allez vous servir de la fonction
Getkey couplée à la fonction conditionelle
If / Then / IfEnd. Je vous laisse vous creuser les méninges avec ça...
Normalement, vous devriez comprendre qu'il faudra utiliser une boucle qui englobera tout le programme.
Pour le reste, je pense que vous pouvez vous débrouiller avec ce que vous avez déjà.
C'est l'heure de la correction !
Alors ? Ce TP ne vous a pas posé trop de problèmes j'espère...
Voici la correction que je vous propose. Notez bien que j'ai essayé de complexifier au maximum ma correction pour que vous ayez une première idée réelle de ce que vous pourrez faire avec un peu de réfléxion, mais surtout, grâce aux connaissances que vous avez déjà...
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
| Do
ClrText
Int (3Ran#+1)->A
Locate 3,1,"Choisir u
n signe"
Locate 1,3,"1.Pierre"
Locate 1,4,"2.Feuille"
Locate 1,5,"3.Ciseaux
"
Do #Cette boucle sera expliquée après la correction
Getkey->r
LpWhile ((r=72) Or (r
=62) Or (r=52))=0
r=72=>1->B
r=62=>2->B
r=52=>3->B
ClrText
Locate 1,1,"Vous :"
8->C
1->D
Goto 1
Lbl 2
Locate 1,2,"Calto :"
9->C
2->D
Lbl 1
(D=1 And B=1) Or (D=2
And A=1)=>Locate C,D,
"Pierre"
(D=1 And B=2) Or (D=2
And A=2)=>Locate C,D,
"Feuille"
(D=1 And B=3) Or (D=2
And A=3)=>Locate C,D,
"Ciseaux"
D=1=>Goto 2
If ((B=1 And A=3) Or
(B=2 And A=1) Or (B=3
And A=2))
Then Locate 9,4,"Gagné !"
Else If B=A
Then Locate 9,4,"Egalité."
Else Locate 9,4,"Perdu..."
IfEnd
IfEnd
Locate 1,7,"Rejouer ?
1.Oui 2.Non"
Do
Getkey->r
Lpwhile ((r=72) Or (r
=62))=0
LpWhile r=72 |
Ne vous affolez pas, vous connaissez tout ce qui est écrit et vous pouvez le comprendre ! Mais bon je me sens de bonne humeur, donc je vais vous expliquer tout ça.
En détail
Bon, reprenons ligne par ligne le code.
Code : Autre
La première ligne du code. On demande ici à la calto d'initialiser la boucle, qui sera la boucle qui englobera tout notre jeu.
Code : Autre
Si le joueur demande à refaire une partie, c'est ici qu'il sera renvoyé : donc l'écran doit être effacé.
Code : Autre
Vous devriez sans problème comprendre que l'on assimile un nombre aléatoire entre un et trois à la variable A. Ce nombre correspondra aux différents signes. Respectivement :
Code : Autre1
2
3
4
5
| Do
Getkey->r
LpWhile ((r=72) Or (r=62) Or (r=52))=0 |
Cette boucle doit vous sembler un peu obscure. Je vous rassure : c'est tout à fait normal ! Je vais vous aider à la comprendre. Tout d'abord, vous devez savoir que si une condition est remplie, elle renvoie la valeur 1 ; si la condition n'est pas remplie, elle renvoie la valeur 0. Revenons-en à notre boucle. On demande dans un premier temps de stocker la valeur du
Getkey dans une variable (ici la variable
r, mais libre à vous de choisir celle que vous préférez).
Mais attends un peu là, tu ne nous avais pas dit que Getkey était déjà une variable ? Pourquoi dans ce cas stocker sa valeur dans une autre variable ?
Bonne question, il existe deux réponses.
Tout d'abord, le fait d'écrire simplement
r au lieu de
Getkey fait gagner du temps et de la place dans le programme.
D'autre part, lorsque vous ferez des programmes plus importants, il se peut que plusieurs
Getkey soient impliqués dans la même boucle, vous serez donc obligés de stocker leur valeur dans une variable.
La dernière ligne de la boucle est la plus importante, car c'est elle qui définit la condition. Concrètement, qu'est-ce que l'on veut ? On souhaiterait que le programme affiche en continu le menu, tant que le joueur n'a pas choisi un signe. Eh bien c'est exactement ce que l'on demande de faire à notre calto dans cette condition !
Regardez bien : si vous avez fait le TP sur le
Getkey, vous devriez savoir que la touche 1 correspond à 72, la touche 2 à 62, et la touche 3 à 52. Rappelez-vous aussi que lorsqu'une fonction n'est pas remplie, elle renvoie la valeur 0. Donc, ce que l'on demande à notre calto ici c'est de continuer à demander sur quelle touche appuyer tant que le joueur n'a pas appuyé sur cette touche. C'est assez difficile à expliquer, mais c'est en fait très très simple ! Comprenez bien cette boucle, elle est vraiment importante et elle vous servira pour tous vos programmes !
Code : Autre1
2
3
4
5
| r=72=>1->B
r=62=>2->B
r=52=>3->B |
Ce bout de code est lui aussi très simple. On demande juste à la calto qu'elle stocke notre choix en fonction de la touche sur laquelle on a appuyé dans la variable B.
Code : Autre1
2
3
4
5
6
7
| Locate 1,1,"vous :"
8->C
1->D
Goto 1 |
Ces variables correspondent à l'emplacement où la calto devra écrire le choix du joueur : pierre, feuille, ou ciseau. La variable C correspond à l'emplacement sur la ligne, et la variable D correspond à la ligne sur laquelle devra être écrit le signe. Donc, on pourrait conclure que si D vaut 1, alors c'est notre signe qui est concerné, et que si D vaut 2, c'est celui de la calto qui va être pris en compte.
On demande en dernier lieu à la calto de se rendre au Lbl 1.
Oula... je croyais qu'il fallait éviter d'utiliser Lbl / Goto ?
C'est exact, dans les gros programmes, car dans ce cas ils ralentissent son exécution. Dans un programme comme le nôtre, on peut tout à fait les utiliser, mais il existe une autre méthode que je vous enseignerai plus tard.
Code : Autre1
2
3
4
5
| Locate 1,2,"Calto :"
9->C
2->D |
Idem que ci-dessus.
Code : Autre1
2
3
4
5
6
7
8
9
| Lbl 1
(D=1 And B=1) Or (D=2 And A=1)=>Locate C,D,"Pierre"
(D=1 And B=2) Or (D=2 And A=2)=>Locate C,D,"Feuille"
(D=1 And B=3) Or (D=2 Ans A=3)=>Locate C,D,"Ciseaux"
D=1=Goto 2 |
Voici maintenant la partie la plus intéressante. Si vous avez fait cette technique par vous-mêmes, bravo, vous avez des prédispositions à l'optimisation
.
Concrètement, à quoi sert ce bout de code ? Eh bien tout simplement à écrire le signe de la calto et le vôtre. Comprenez ce script, il n'est pas primordial mais très important.
La dernière ligne est un peu plus subtile. Essayer de l'enlever, vous verrez bien.
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| If ((B=1 And A=3) Or
(B=2 And A=1) Or (B=3
And A=2))
Then Locate 9,4,"Gagné !"
Else If B=A
Then Locate 9,4,"Egalité."
Else Locate 9,4,"Perdu..."
IfEnd
IfEnd |
Cette boucle va permettre à la calto de savoir si vous avez gagné ou perdu, ou bien s'il y a égalité. Remarquez l'utilisation des
Else.
Code : Autre1
2
3
4
5
6
7
8
9
10
11
12
13
| Locate 1,7,"Rejouer ?
1.Oui 2.Non"
Do
Getkey->r
Lpwhile ((r=72) Or (r
=62))=0
LpWhile r=72 |
Cette fois-ci, on demande au joueur s'il veut rejouer. S'il appuie sur la touche 1, alors la variable
r qui contient la valeur du
Getkey vaut 72, et le programme retourne alors au premier
Do du script.
Et voilà ! Vous pouvez maintenant vous lancer dans la seconde Partie de ce tutoriel !
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
505 Zéros connectés |
10 requêtes |
0.0478s (0.0342s)
