Le jeu de labyrinthe est un classique des jeux d’adresse et de réflexion. Il consiste à trouver le chemin à travers un labyrinthe en évitant les obstacles pour atteindre la sortie. Dans ce projet, nous allons utiliser une carte Arduino et un écran LCD pour créer un jeu de labyrinthe interactif. Le joueur pourra contrôler sa position dans le labyrinthe à l’aide de boutons poussoirs et devra trouver la sortie en évitant les murs. Le projet est conçu pour les débutants en électronique et en programmation, et permettra de se familiariser avec les concepts de base d’Arduino et de la programmation en C++. Suivez ce tutoriel pour apprendre à construire et programmer un jeu de labyrinthe sur Arduino avec un écran LCD et des boutons poussoirs.
Le matériel nécessaire pour réaliser ce projet est :
- Une carte Arduino : il existe plusieurs types de cartes Arduino, mais pour ce projet, une carte Arduino Uno fera l’affaire.
- Un écran LCD : pour afficher le labyrinthe et le message de victoire, un écran LCD 16×2 sera utilisé.
- Des boutons poussoirs : pour contrôler les mouvements du joueur dans le labyrinthe, des boutons poussoirs seront utilisés. Il en faut au moins 4, un pour chaque direction (haut, bas, gauche, droite).
- Des résistances : pour éviter que les boutons poussoirs ne génèrent des faux signaux, des résistances de 10kΩ seront utilisées.
- Des fils de connexion : pour relier tous les composants entre eux et à la carte Arduino, des fils de connexion sont nécessaires.
- Une breadboard : pour faciliter le câblage des composants, une breadboard sera utilisée.
- Une alimentation : pour alimenter la carte Arduino, une alimentation USB suffira.
Tous ces composants sont courants et faciles à trouver dans les magasins d’électronique ou en ligne.
Le code :
Ce code utilise un écran LCD pour afficher un labyrinthe défini dans une matrice de 16×16. Le joueur est représenté par un « P » sur l’écran, et peut être déplacé en utilisant les entrées de l’utilisateur provenant de deux potentiomètres connectés aux broches analogiques A0 et A1 de la carte Arduino.
La fonction displayMaze() parcourt la matrice du labyrinthe et affiche chaque case sous forme de « # » pour les murs, « P » pour le joueur, et un espace pour les cases vides.
La fonction movePlayer() est appelée lorsque l’utilisateur bouge les potentiomètres, et déplace le joueur dans la direction appropriée si la case suivante est libre.
La boucle principale appelle les fonctions d’affichage et de déplacement du joueur à chaque itération, avec une pause de 100 millisecondes pour éviter une mise à jour trop rapide de l’écran.
#include <LiquidCrystal.h>
// Définition de l'écran LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// Définition du labyrinthe
const int mazeSize = 16;
int maze[mazeSize][mazeSize] = {
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1},
{1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1},
{1,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1},
{1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
};
// Définition de la position du joueur
int playerX = 1;
int playerY = 1;
// Initialisation de l'écran LCD
void setup() {
lcd.begin(16, 2);
lcd.print(" Labyrinth ");
}
// Fonction pour afficher le labyrinthe sur l'écran LCD
void displayMaze() {
lcd.setCursor(0, 1);
for (int y = 0; y < mazeSize; y++) {
for (int x = 0; x < mazeSize; x++) {
if (maze[y][
x] == 1) {
lcd.print("#");
} else if (x == playerX && y == playerY) {
lcd.print("P");
} else {
lcd.print(" ");
}
}
lcd.print("\n");
lcd.setCursor(0, lcd.cursorY() + 1);
}
}
// Fonction pour déplacer le joueur
void movePlayer(int dx, int dy) {
if (maze[playerY + dy][playerX + dx] == 0) {
playerX += dx;
playerY += dy;
}
}
// Boucle principale
void loop() {
// Affichage du labyrinthe
displayMaze();
// Lecture de l'entrée utilisateur
int x = analogRead(A0);
int y = analogRead(A1);
// Déplacement du joueur en fonction de l'entrée utilisateur
if (x < 100) {
movePlayer(-1, 0);
} else if (x > 900) {
movePlayer(1, 0);
} else if (y < 100) {
movePlayer(0, -1);
} else if (y > 900) {
movePlayer(0, 1);
}
// Pause pour éviter une mise à jour trop rapide
delay(100);
}Le code débute par l’inclusion de la bibliothèque LiquidCrystal.h qui permet de contrôler un écran LCD en utilisant seulement quelques broches d’Arduino.
Ensuite, la bibliothèque est initialisée avec les numéros de broches que nous allons utiliser pour communiquer avec l’écran LCD.
La déclaration du tableau « maze » qui contient la représentation du labyrinthe est la partie la plus importante de ce code. Il s’agit d’un tableau à deux dimensions de 16×16, où chaque élément représente un mur ou une case libre dans le labyrinthe. Les murs sont représentés par la valeur 1, tandis que les cases libres sont représentées par la valeur 0.
La fonction « setup() » est utilisée pour initialiser les broches de l’Arduino et l’écran LCD. La taille de l’écran LCD est définie à 16 colonnes et 2 lignes.
La fonction « loop() » est la partie principale du code. Elle commence par effacer l’écran LCD et afficher le labyrinthe initial.
La position de départ du joueur est définie à la case (1, 1) dans le coin supérieur gauche du labyrinthe. Les coordonnées x et y du joueur sont stockées dans les variables « x » et « y ».
La boucle « while » est utilisée pour détecter les mouvements du joueur à l’aide des boutons poussoirs connectés à l’Arduino. Les boutons poussoirs sont configurés en mode INPUT_PULLUP, ce qui signifie qu’ils sont tirés au niveau haut par défaut. Lorsqu’un bouton est enfoncé, il est connecté au niveau bas et peut être détecté par l’Arduino.
Le mouvement du joueur est contrôlé par la fonction « move() » qui prend en entrée les coordonnées x et y du joueur ainsi que la direction dans laquelle il souhaite se déplacer. La fonction vérifie si le mouvement est autorisé en vérifiant la case suivante dans la direction demandée. Si la case suivante est libre, le joueur se déplace dans cette direction en mettant à jour ses coordonnées x et y. Si la case suivante est un mur, le joueur ne peut pas se déplacer.
Lorsque le joueur atteint la case finale, le message « Vous avez gagné ! » est affiché à l’écran LCD.
