Réalisez un jeu video tennis 1 joueur avec un Arduino et une matrice à Leds

Cette application va vous permettre de réaliser un petit jeu vidéo (type tennis 1 joueur) à l'aide d'une carte Arduino et du module Click Board Mikroe-1993 7x10 R click.­
   
  

Les modules ClickBoard™ sont de petits modules additionnels développés par la société MikroElektronika. Ils sont conçus pour s’enficher facilement sur une multitude de cartes de développement via l’interface mikroBUS™, un standard matériel et logiciel pensé pour simplifier le prototypage. Elles permettent d’ajouter rapidement une fonctionnalité sans câblage complexe. Leur format DIL vous permettra également des les utiliser sur des plaques breadboard (boite de connexions sans soudure).

La présentation du module MIKROE-1993 utilisé dans l'application qui va suivre a déjà fait l'objet d'une description complète dans notre Blog Pilotage d'une matrice 70 leds avec un Arduino. Le raccordement entre l'Arduino et le module Click Board MIKROE-1993 7x10­R­Click reste identique à celui décrit dans le blog cité ci-avant. 
      

Description du concept du jeu vidéo Tennis 1 joueur

Pour cette application on exploitera la matrice à leds du module dans le sens vertical. Vous disposez d'une petite raquette au bas de la matrice (matérialisée par 2 leds côte à côte) que vous pourrez déplacer de droite à gauche et de gauche à droite à l'aide d'une résistance ajustable.
 
Dans le même temps une petite balle (matérialisée par une led de la matrice) se déplace vers le bas de l'aire de jeu. Votre but sera de renvoyer cette balle aussi longtemps que possible afin qu'elle ne sorte pas de la matrice. A chaque fois que la balle touchera votre raquette, celle-ci remontera vers le haut de la matrice en rebondissant sur des murs virtuels et en retombant systématiquement vers le bas de la matrice. Au moment où vous raterez la balle et qu'elle descendra au delà de votre raquette, une petite animation visuelle vous signalera la fin de la partie. En sollicitant le bouton-poussoir de Reset de la platine Arduino vous relancerez une nouvelle la partie.
       

Schémas du jeu vidéo Tennis 1 joueur

Selon que vous utiliserez le module ClickBoard MIKROE-1993 seul et directement raccordé à votre carte Arduino ou que vous utiliserez une carte d'interface MIKROE-1581, réalisez un des 2 schémas ci-dessous.
 

Utilisation directe du module MIKROE-1993 avec votre carte Arduino






Utilisation du module MIKROE-1993 en association avec la carte d'interface MIKROE-1581 et votre carte Arduino
 


 

Dans tous les cas, il vous faudra avoir recours à une résistance ajustable supplémentaire. Le curseur de cette résistance ajustable sera relié sur l'entrée de conversion « analogique/numérique » A2 de la platine Arduino tandis que les 2 contacts extrêmes de la résistance ajustable sont reliés à la masse pour l'un et au 5 V pour l'autre. 
        

Etude du programme du jeu vidéo Tennis 1 joueur

Cette application met en œuvre beaucoup de compétences déjà acquises au cours des montages précédents. Le programme associé est toutefois assez conséquent (raison pour laquelle nous ne l'avons pas affiché sur cette page. Vous pourrez bien sur télécharger le code source du programme à la fin de cette page. Nous allons dans les lignes qui suivent vous expliquer son fonctionnement. Toutefois afin de vous éviter une lecture trop fastidieuse, nous n'allons pas détailler les instructions de ce dernier les unes après les autres selon le déroulement du listing, mais plutôt vous exposer les différents concepts et astuces utilisés pour parvenir à la réalisation de cette application.

Le programme débute par les habituelles déclarations et initialisations (y comprises celles liées à la gestion du module « 7x10 R click »). Pour les besoins de la gestion des éléments du jeu, nous avons également été amené à déclarer plusieurs variables :

PosRaquette qui servira à mémoriser la position horizontale de la raquette sur la matrice à led.

Decompte et Vitesse qui serviront à définir la vitesse de déplacement initiale de déplacement de la balle (avec un phénomène d'accélération au cours de la partie), Xball et Yball qui gèrent la position (X/Y) de la balle sur la matrice.

DxBall et DyBall qui gèrent la direction de déplacement de la balle sur la matrice (si DxBall = 1 alors la balle se déplace vers la droite. Si DXBall = 0 alors la balle va dans l'autre sens. De même, si DyBall = 1 alors la balle va vers le haut de la matrice et si DyBall = 0, la balle va vers le bas de la matrice).

Matrice[2][7] qui gère le « plan » mémoire de la matrice.

Mball qui est une variable permettant de savoir sur quelle matrice se trouve la balle.


Pour rappel, la matrice utilisée sur le module « 7x 10 R click » est en fait composée de 2 mini-matrices de 5 x 7 leds placées l'une à côté de l'autre (raison pour laquelle la variable destinée à définir le plan mémoire est sur 2 dimensions : Matrice[2][7]).

La difficulté majeure liée à cette application est qu'il faut afficher et gérer la position de la balle en fonction de sa position sur la matrice haute ou sur la matrice basse. La variable Mball est destinée à mémoriser cette information (Mball = 0 pour la matrice du bas et Mball = 1 pour la matrice du bas).
 
En début de programme, le plan mémoire de la matrice est complètement effacé, puis on sélectionne d'office un déplacement de la balle vers le haut à droite (DxBall = 1 et DyBall = 1) avec une position initiale verticale fixe de la balle et une position horizontale aléatoire afin qu'elle ne parte jamais du même endroit au fil des différentes parties.
 
Le déplacement de la raquette est obtenu assez simplement en récupérant la valeur de la conversion analogique/numérique de la tension présente sur le curseur de la résistance ajustable (qui nous donne un chiffre compris entre 0 et 1023) et en divisant cette valeur par 100, on obtiendra un nombre compris au final entre 0 et 10.

Nous utiliserons ce nombre pour déterminer la position de la raquette en réalisant des comparaisons avec les valeurs droite et gauche extrêmes pour que son déplacement soit limité aux dimensions de la matrice. Une fois la position de la raquette connue, on configure à zéro trous les bits présents sur la ligne sur laquelle est affichée la raquette afin d'effacer d'office les anciennes positions de la raquette. Puis on configure à 1 les bits liés à l'emplacement actuel de la raquette dans la matrice (pour allumer les leds représentant cette raquette).
 



 
Le programme principal de notre application doit donc consister a :

- Gérer le déplacement de la raquette sur la matrice
- Gérer le déplacement de la balle entre les 2 matrices
- Vérifier si la balle atteint les murs virtuels droit, gauche et haut (auquel cas, la balle devra rebondir)
- Vérifier si la balle frappe la raquette (auquel cas la balle devra rebondir)
- Vérifier si la balle passe au delà de la limite de la position horizontale de la raquette
  (auquel cas la balle devra se mettre à clignoter et une petite animation devra annoncer la fin de partie)
- Gérer une temporisation en permanence pour déterminer la vitesse de déplacement de la balle
  (avec un phénomène d'accélération progressive au cours de la partie) 
  
Il nous faudra également prévoir un rafraîchissement permanent de la matrice durant toutes ces opérations afin d'obtenir une jouabilité parfaite et maintenir l'effet de persistance rétinienne sur la matrice. En détaillant les choses, le programme va donc devoir surveiller (à chaque déplacement de la balle) les valeurs de ses coordonnées X et Y (avec les variables xBall et yBall).
  


 

La gestion de la coordonnée yBall de la balle s'effectue ainsi. yBall = 4 lorsque la balle est sur la matrice du bas juste au niveau de la raquette. YBall = 3, si la balle est juste une led au dessus de la raquette... ainsi que suite... jusqu'à yBall = 0 si la balle est sur la led la plus haute de la matrice du bas. Un des tests du programme consiste à vérifier si la balle est sur la matrice du bas et si (après la mise à jour de la position des coordonnées de la balle), yBall est inférieur a o (dans notre cas, nous testons si yBall = 255 car une variable sur 8 bits dont la valeur est égale à O passera à la valeur 255 si on la décompte). Si tel est le cas, le programme sera en mesure de déterminer que la balle est passée sur la matrice du haut.

Lorsque la balle passe sur la matrice du haut, la mémorisation en yBall reprend la valeur 4, puis 3 si elle est sur la 2ème ligne en partant du bas de la matrice haute.. et ainsi de suite jusqu'à la valeur 0 si la balle est sur la dernière ligne en haut de la matrice du haut. 

La gestion de la collision avec le mur virtuel du haut de la matrice s'effectue donc en vérifiant si on est sur la matrice du haut et si yBall = 255 (si on est inférieur à la positon 0). Dans ce cas, le programme va modifier le sens de déplacement DyBall de la balle afin de la faire rebondir vers le bas de la matrice.

Un troisième test consiste à détecter le passage de la matrice du haut vers la matrice du bas en remettant à jour la valeur de yBall.

Dans le même ordre d'esprit, le programme va vérifier la position xBall de la balle afin de vérifier si on a atteint les limites des murs virtuels droit et gauche (si Xball < 0 (soit Xball = 255) ou si Xball = 7). Si tel est le cas, le programme inverse le sens de déplacement horizontal de la balle pour gérer le rebond de celle-ci.

Le dernier test concerne la gestion de la collision avec la raquette. Pour ce faire, le programme va simplement vérifier à chaque déplacement si la balle est sur la matrice du bas et si sa prochaine position pour DyBall = 4 indique la présence d'une led allumée (celle de la raquette). Si tel est le cas, ceci signifie que la raquette est bien en dessous de la balle et qu'il faut inverser le sens de déplacement vertical de la balle (pour gérer son rebond) en mettant la variable DyBall à 1.

Si par contre le programme ne détecte pas de led allumée sur la dernière ligne lors du déplacement de la balle, celui-ci en déduit que la raquette n'est pas présente et qu'il faut faire clignoter la balle rapidement plusieurs fois de suite (afin de monter l'endroit ou elle a atterri). S'en suit alors une petite animation qui consiste à allumer successivement les différentes leds de la matrice de façon aléatoire avant que celles-ci ne s'effacent (également de façon aléatoire).

A ce stade, le programme entre dans une boucle sans fin et la partie est définitivement terminée. Il ne vous reste plus qu'à appuyer sur le bouton-poussoir Reset de la platine pour jouer à nouveau. A noter que durant toute la gestion des déplacements et des collisions, le programme utilise la variable décompte pour réaliser une temporisation entre chaque déplacement ainsi que la variable Vitesse (qui est décrémentée régulièrement) pour accélérer le déplacement de la balle au fur et a mesure que la partie se déroule (avec une valeur limite fixée à 5 afin que la partie de tennis ne devienne pas injouable).
  
 
Vous pouvez retrouver le code source de ce programme en cliquant ici : code source Arduino & modules Click Board