LCD Hill Run v2 – Jeu de course Arduino interactif avec écran LCD 16x2 et buzzer

Composants et fournitures

Composant	Quantité	Remarques
Arduino Mega 2560	1	Ou un Arduino UNO ! Modifier DUCK_PIN dans le code à 3 et recâbler en conséquence si vous souhaitez utiliser un Uno.
Fils de connexion (génériques)	~20
Bouton poussoir 12 mm (SparkFun)	2
Résistance 10 kΩ	2
Écran LCD standard 16x2 blanc sur bleu (Adafruit)	1
Potentiomètre rotatif 10 kΩ	1	N'importe quel potentiomètre convient.
Buzzer	1	Buzzer passif de préférence ; un buzzer actif ou piézo peut fonctionner. Non indispensable, juste pour le son. N'ACHETEZ PAS le produit lié ! Il est erroné : un buzzer ne coûte pas 225 $.
Plaque d'essai (breadboard)	1	Format complet recommandé.

Applications et services en ligne

• Arduino IDE (ou l'éditeur web).

À propos du projet

Je suis encore un jeune amateur d'Arduino. Après avoir lu quelques projets sur Project Hub et appris les bases, j'ai été inspiré pour créer ce petit jeu amusant. Le débogage n'a pas été trop long et le résultat est vraiment sympa. Le code est plutôt propre à mon avis. AMUSEZ-VOUS ! Merci de respecter et de commenter.

N'oubliez pas de télécharger les bibliothèques incluses dans le programme et de les placer dans le dossier des bibliothèques. Si une erreur signale qu'une bibliothèque est introuvable, utilisez Croquis > Inclure une bibliothèque. Signalez tout problème en commentaire.

Bibliothèques disponibles ici : https://github.com/PunkyMunky64/HillRun2Libraries

Code

Code Hill Run v2 (Arduino)

Le code. Changez DUCK_PIN à 3 si vous utilisez un UNO. Le code est assez compact et propre, je trouve.

/* 
 * Copyright (c) 2020 par Miles C. Version améliorée de Hill Run avec interruptions pour un meilleur code. 
 * ATTENTION : DUCK_PIN est 18 AU LIEU DE 4 à cause des capacités d'interruption !
 * Hill Run : un jeu où vous sautez par-dessus des collines et vous accroupissez sous des corbeaux.
 * Câblage :
 * - Arduino +5V vers rail d'alimentation de la breadboard
 * - Arduino GND vers rail de masse
 * - Bouton saut avec résistance 10k pull-down vers GND, pin digital 2, autre côté vers +5V
 * - Bouton accroupi avec résistance 10k pull-down vers GND, pin digital 18, autre côté vers +5V
 * - Buzzer passif : un côté GND, l'autre sur pin PWM 5
 * - Écran LCD 16x2 16 broches : câblage standard Arduino (voir le tutoriel LCD)
 *   - K vers GND, A vers +5V
 *   - D4-D7 vers pins 9-12
 *   - E vers pin 8, RW vers GND, RS vers pin 7
 *   - V0 vers sortie potentiomètre (luminosité), potentiomètre entre +5V et GND
 *   - VDD vers +5V, VSS vers GND
 */
#include <LiquidCrystal.h>
#include "pitches.h"

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
const int JUMP_PIN = 2;
const int BUZZER_PIN = 5;
const int DUCK_PIN = 18; // changer à 3 pour UNO
const int JUMP_PITCH = 2700;
const int JUMP_PITCH_DURATION = 50;
const int DUCK_PITCH = 1350;
const int DUCK_PITCH_DURATION = 50;
const int DIE_PITCH = 200;
const int DIE_PITCH_DURATION = 500;
const int TICKSPEED = 90; // ms par tick de jeu
const int JUMP_LENGTH = 3; // caractères sautés

// Caractères personnalisés (sprites)
const byte stickStep1[8] = { B01110, B01110, B00101, B11111, B10100, B00110, B11001, B00001 };
const byte stickStep2[8] = { B01110, B01110, B00101, B11111, B10100, B00110, B01011, B01000 };
const byte stickJump[8]  = { B01110, B01110, B00100, B11111, B00100, B11111, B10001, B00000 };
const byte stickDuck[8]  = { B00000, B00000, B00000, B01110, B01110, B11111, B00100, B11111 };
const byte hill[8]       = { B00000, B00100, B01010, B01110, B11101, B10101, B11001, B11111 };
const byte crow1[8]      = { B00111, B00100, B00110, B01111, B11111, B01111, B00110, B00111 };
const byte crow2[8]      = { B00111, B00110, B01111, B11111, B01111, B00110, B00110, B00111 };

volatile int jumpPhase = JUMP_LENGTH + 1;
int gameTick = 0;
int crowX = 40;
int hillX = 25;
bool playerY = 0;
volatile bool ducking = LOW;
bool loopBreaker = 1;
bool crowGo = 0;
int score = 0;

void setup() {
  pinMode(JUMP_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  lcd.begin(16, 2);
  lcd.createChar(0, hill);
  lcd.createChar(1, stickStep1);
  lcd.createChar(2, stickStep2);
  lcd.createChar(3, stickJump);
  lcd.createChar(4, stickDuck);
  lcd.createChar(5, crow1);
  lcd.createChar(6, crow2);
  attachInterrupt(digitalPinToInterrupt(JUMP_PIN), seeJumping, RISING);
  attachInterrupt(digitalPinToInterrupt(DUCK_PIN), seeDucking, CHANGE);
}

void loop() {
  playerY = 0;
  if (jumpPhase < JUMP_LENGTH) playerY = 1;
  drawSprites();
  loopBreaker = 1;

  if (hillX < 16) {
    if (crowX < hillX) { hillX += 8; loopBreaker = 0; }
    if (loopBreaker) { lcd.setCursor(hillX, 1); lcd.write((byte)0); }
  }
  if (hillX < 1) {
    if (jumpPhase < JUMP_LENGTH) { score++; hillX = 16 + random(8); }
    else endGame();
  }
  if (crowX < 16) {
    lcd.setCursor(crowX, 0);
    lcd.write((byte)(gameTick % 8 < 4 ? 5 : 6));
  }
  if (crowX < 1) {
    if (ducking) { score++; crowX = 24 + random(16); }
    else endGame();
  }
  lcd.setCursor(0, playerY); lcd.print(" ");
  jumpPhase++;
  hillX--;
  crowGo = !crowGo;
  crowX -= crowGo;
  gameTick++;
  delay(TICKSPEED);
}

void endGame() {
  lcd.clear();
  lcd.setCursor(0, 0); lcd.print("Score: ");
  lcd.setCursor(7, 0); lcd.print(score);
  tone(BUZZER_PIN, DIE_PITCH, DIE_PITCH_DURATION);
  while (!digitalRead(JUMP_PIN)) {
    lcd.setCursor(0, 1);
    if (millis() % 500 < 250) lcd.print("Jump to Continue");
    else lcd.print("                ");
  }
  lcd.clear();
  score = 0; hillX = 25; crowX = 40;
}

void drawSprites() {
  lcd.setCursor(0, 1 - playerY);
  if (!ducking) {
    if (!playerY) lcd.write((byte)((gameTick % 4) < 2 ? 1 : 2));
    else lcd.write((byte)3);
  } else lcd.write((byte)4);
  lcd.setCursor(1, 1); lcd.print(" ");
  lcd.setCursor(1, 0); lcd.print(" ");
}

void seeJumping() {
  if (jumpPhase > (JUMP_LENGTH + 2) && !ducking) {
    jumpPhase = 0;
    tone(BUZZER_PIN, JUMP_PITCH, JUMP_PITCH_DURATION);
  }
}

void seeDucking() {
  ducking = digitalRead(DUCK_PIN);
  if (ducking) {
    jumpPhase = JUMP_LENGTH;
    tone(BUZZER_PIN, DUCK_PITCH, DUCK_PITCH_DURATION);
  }
}

README (Markdown)

"Profitez de ce jeu Hillrun ! Sautez par-dessus les collines en appuyant sur 'saut', et accroupissez-vous sous les corbeaux en maintenant 'accroupi'. NE VOUS ÉCRASEZ PAS ! Si vous perdez, appuyez sur 'saut' pour recommencer. Score = corbeaux évités + collines franchies. Plus d'infos : https://create.arduino.cc/projecthub/PunkyMunky64/lcd-hill-run-v2-runner-game-1b0523. Je n'ai que 12 ans et suis encore amateur. Le code est propre à mon avis. AMUSEZ-VOUS ! Respectez et commentez. Téléchargez les bibliothèques et mettez-les dans le dossier. En cas d'erreur, utilisez Croquis > Inclure une bibliothèque. Bibliothèques : https://github.com/PunkyMunky64/HillRun2Libraries. POUR UTILISER UN UNO : changez const int DUCK_PIN à 3 et recâblez le bouton accroupi de la pin 18 vers la pin digitale 3. Copyright (c) HillRun2.ino par Miles C. 2020 sous licence GNU GPL. Pour le schéma et la liste des composants, voir la page Arduino ci-dessus."

Schémas

Schéma de câblage (fichier Fritzing : hillrun2_zp0SI4wns3.fzz).
Pour utiliser un UNO : dans le code, changez const int DUCK_PIN à 3 et recâblez le bouton accroupi de la pin 18 vers la pin digitale 3.