Gestion du nombre aléatoire
Cette fois-ci nous n'allons pas utiliser time.h puisque ça ne fonctionnera pas avec la DS, il faut utiliser une autre fonction qui utilise l'horloge interne de la console,
sans que vous ayez besoin de connaître les éléments qui permettent de récupérer l'heure. Nous allons juste utiliser des fonctions qui nous facilitent la vie en récupérant déjà l'heure.
Tout d'abord dire à la console que nous allons lui demander un nombre aléatoire :
Code : C
Et utiliser la fonction qui renvoie le nombre:
Code : C | u32 PA_RandMax (u32 max);
|
Cette fonction renvoie un nombre en 0 et max INCLUS.
Voilà une autre fonction utile :
Code : C | u32 PA_RandMinMax (u32 min, u32 max);
|
Vous remarquerez que la fonction renvoie et demande des u32 (32 bits), nos variables pourront être de type int ou long, il n'y a pas de soucis de ce coté.
La gestion du clavier
Ne vous êtes-vous pas demandés comment diable l'utilisateur rentrera-t-il son nombre ? La solution : utiliser le clavier de la Nintendo DS bien sûr

!
Initialisation du clavier
Il faut d'abord initialiser le clavier avec :
Code : C | void PA_InitKeyboard(numero_bg);
|
Vous n'avez pas besoin de préciser l'écran puisque vous devez utiliser le stylet pour appuyer sur les touches du clavier.
Apparition du clavier
Sachez que le clavier part du bas pour venir à la position voulue. Il faut juste que vous rentriez les coordonnées idéales du clavier pour voir une belle animation.
On utilisera :
Code : C | void PA_KeyboardIn (s16 x, s16 y);
|
Mais le clavier vient du bas et un seul mouvement est possible (du bas vers le haut).
Je vais vous donner une fonction toute faite pour faire un déplacement comme vous le voulez :
Code : C 1
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 | //PROTOTYPE
void defiler_clavier(int,int,int,int,int);
//FONCTION
void defiler_clavier(int x,int y,int x1,int y1,int nvbl)
{
/*Le clavier va de (x;y) à (x1;y1) avec nvbl VBL pour chaque étape du déplacement*/
int i=0;
PA_ScrollKeyboardXY(x,y); //On met le clavier à la position (x;y)
while(1)
{
/*On se rapproche des coordonnées (x1;y1)*/
if(x<x1)
x++;
else if(x>x1)
x--;
if(y<y1)
y++;
else if(y>y1)
y--;
if(x==x1 && y==y1)
break;
PA_ScrollKeyboardXY(x,y); //On replace le clavier à la nouvelle position
/*On attend en fonction du nombre de VBL donné par la variable nvbl*/
for(i=0;i<nvbl;i++)
PA_WaitForVBL();
}
}
|
Le clavier passera de (x;y) à (x1;y1) et à chaque tour de boucle, il y aura
nvbl PA_WaitForVBL.
Traitement du clavier
Ça, c'est une toute autre histoire !
Il faut opérer en ce sens :
- créer un entier qui va contenir le nombre progressivement entré par l'utilisateur (caractère par caractère).
Mais comment allons nous ajouter des chiffres ou en retirer ?
Bonne question... A chaque fois qu'on ajoute un chiffre, il doit aller tout à droite (à la place des unités). Donc on multiplie le nombre par 10 et on y ajoute tout simplement le chiffre entré. Pour retirer le dernier chiffre (lorsqu'on appuie sur Backspace) il suffira de diviser le nombre par 10 car le résultat sera tronqué à l'unité.
- créer une variable de type int contenant le nombre de tentatives ;
- créer une variable s32 qui contiendra le nombre de lettres ;
- créer une variable char qui contiendra la lettre actuelle ;
Vous aurez sûrement besoin de <string.h>.
</puce>
- coder la boucle en reconnaissant la lettre entrée et en l'analysant :
Code : C 1
2
3
4
5
6
7
8
9
10
11
12
13 | char lettre=0;
/*INITIALISATIONS A METTRE*/
while(1)
{
lettre=PA_CheckKeyboard();
if(lettre>='0' && lettre<='9')
PA_OutputText(1,0,3,"%d",lettre-'0');
else if(lettre==PA_BACKSPACE)
//ON EFFACE LE DERNIER CARACTÈRE, PENSEZ A FAIRE UNE FONCTION
else if(lettre=='\n')
//ON VALIDE
/*RESTE DE LA BOUCLE*/
}
|
Si l'utilisateur appuie sur 0, lettre vaudra 48 ; sur 1, lettre vaudra 49 et ainsi de suite... C'est pour cela qu'il faut soustraire 48 à notre numéro de touche.
Bon, côté interface, on écrira tout sur l'écran supérieur.
En premier, la console affichera :
Code : Console | Entrez un nombre entre 1 et 100 inclus : |
Au-dessous, (ligne 3) vous écrirez l'entrée du joueur.
Si le nombre entré est plus petit que le nombre à trouver, on effacera l'écran supérieur pour écrire :
Code : Console | Le nombre %s est trop petit. Veuillez attendre 2 secondes... |
Où %s est la chaîne entrée par l'utilisateur.
Si le nombre est trop grand, on écrira :
Code : Console | Le nombre %s est trop grand. Veuillez attendre 2 secondes... |
Et si le nombre est trouvé, on écrira :
Code : Console | Bravo ! Vous avez réussi à trouver le nombre %s en %d tentative%s ! Veuillez attendre 2 secondes... |
Où %d est le nombre de tentatives et le 2
ème %s est le résultat d'une ternaire pour savoir si on met le pluriel ou pas.
N'oubliez pas de faire l'attente pour les 2 secondes.
Au passage, on effacera l'écran à chaque tour de boucle (si on efface le dernier caractère, la mise à jour sera automatique). Et si le joueur a trouvé le nombre, on quitte la boucle (utiliser
while(1)
avec un
break
lorsque l'objectif est atteint, afin d'attendre que l'utilisateur appuie sur Entrée). Et, après celle-ci, on affichera :
Code : Console | Bravo ! Vous avez réussi à trouver le nombre %s en %d tentative%s ! |
Disparition du clavier
La simple fonction
Code : C | void PA_KeyboardOut (void);
|
nous "rangera" automatiquement notre clavier

. Si vous ne voulez pas l'utiliser, vous pouvez utiliser notre fonction
defiler_clavier.
Customisation du clavier
Vous pouvez personnaliser votre clavier. Vous devez créer d'abord un fichier image qui contiendra votre clavier. Ce fichier mesurera 256*1024 pixels. Aux coordonnées (0;0) dessinez votre clavier qui doit mesurer 208x96 pixels. La contrainte est que les touches doivent être de même dimensions que le clavier par défaut (il y a un exemple ci-dessous pour que vous puissiez bien voir les dimensions). Aux coordonnées (0;512) dessinez votre clavier (quand le joueur appuiera sur la touche Shift ou Caps).
Voici un exemple de clavier :