#include <EEPROM.h>
#include "structuresObjets.h"
#include "son.h" 
#include "prototypesFonctions.h"
#include "fonctionsObjets.h"
#include "routines.h"

void setup()
{
  initialise();
  pagePresentationJeu();
  menuJeu();
}

void loop() {

  /* CONTROLE DES MOUVEMENTS SUR LES AXES DU JOYSTICK */
routineJoystickControle();

  /*CONTROLE DU TIMING DU DEPLACEMENT DU MECHANT */
  routineDeplacementMechant();

  /* CONTROLE DU TIR DECLENCHE PAR LE SWITCH DU JOYSTICK */
 routineTirDeclenchement();

  /* CONTROLE DU DEPLACEMENT DU TIR SI LE TIR A ETE DECLENCHE   */
 routineTirControle();

  /*CONTROLE DES EVENTUELLES COLLISIONS ENTRE LES OBJETS DU JEU*/
 collisions();

  /*AFFICHAGE DES OBJETS ENCORE VIVANTS SUR L'ECRAN LCD*/
  actualisationObjetsVivants();

  affichageScores();

}

sketch.ino

diagram.json

/*-------------------------LIBRAIRIES NECESSAIRES------------------------------*/
#include <LiquidCrystal_I2C.h>
#include "graphiquesObjets.h"
#include "pagesPresentations.h"
#include "niveaux.h"
#include "comportementMechants.h"

/*----------------------------------------FONCTION D'ATTENTE--------------------------------------*/

void attente()
{
  BP1 = digitalRead(2);
  while (BP1 == 1) {
    BP1 = digitalRead(2);
  }
  delay(300);
}

/*----------------------------------------RECUPERATION DES INDEXS ET DES SCORES DANS L'EEEPROM------------------------*/
void recuperationMeilleurScore()
{
EEPROM.get(0,classement_lu);

/*---------------------------------------- CONVERSION DES INDEX EN STRING------------------------------*/
char Alpha[27] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
classement_lu.nom += {Alpha[classement_lu.indexlettre.Unchoisie]};delay(50);
classement_lu.nom += {Alpha[classement_lu.indexlettre.Deuxchoisie]};delay(50);
classement_lu.nom += {Alpha[classement_lu.indexlettre.Troischoisie]};delay(50);

return classement_lu;
}

/*--------------------------------------AFFICHAGE DES HIGH SCORES--------------------------------*/
void highScoreMenu()
{
   lcd.clear();
  lcd.setCursor(0,0); lcd.print(F("**MEILLEUR SCORE**")); 
  lcd.setCursor(0,1); lcd.print(classement_lu.nom); 
    lcd.setCursor(10,1); lcd.print(classement_lu.score); 

  attente();
  lcd.clear();
}
IndexLettre menuNomJoueur () 
{
  lcd.clear() ;
  char Alphab[27] = {"ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
  int index = 0;
  byte selection = 0;

  while (selection < 3) {
    J1 = analogRead(A0);
    BP1 = digitalRead(2);
    lcd.setCursor(0, 0);
    lcd.print(F("Entre ton nom"));
    lcd.setCursor(8 + selection, 1);
    lcd.print(Alphab[index]);

    if (J1 > seuilActionHaut) {
      delay(200);
      index++;
    }
    if (J1 < seuilActionBas) {
      delay(200);
      index--;
    }
    if (index < 0) {
      delay(100);
      index = 25;
    }
    if (index > 25) {
      delay(100);
      index = 0;
    }
    if (BP1 == LOW) {
    switch (selection) {
      case 0:
      delay(500);
      perso.indexLettre.Unchoisie = index;
      selection = 1;
      perso.nom += {Alphab[index]};
      break;

      case 1:
      delay(500);
      perso.indexLettre.Deuxchoisie = index;
      selection = 2;
      perso.nom += {Alphab[index]};
      break; 

      case 2:
      delay(500);
      perso.indexLettre.Troischoisie = index;
      selection = 3;
      perso.nom += {Alphab[index]};
      selection = 3;
      break;
      }
    }
  }
  lcd.setCursor(0, 3);
  lcd.print(F("BONNE CHANCE!!!"));
  attente();
  return perso.indexLettre;
}

void creationPersonnage()
{
  perso.Position = {0, 0}; //position de départ du personnage, en haut à droite
  lcd.setCursor(perso.Position.colonne, perso.Position.ligne);
  lcd.write(0);//affiche le personnage
  perso.estVivant = 1;
}

void creationVie()
{
  vie.Position = {random(2, 17), random(1, 2)}; //une vie est positionnee au hasard
  lcd.setCursor(vie.Position.colonne, vie.Position.ligne);
  lcd.write(1);//affiche la vie
  vie.estVivant = 1;
}

void creationPorte()
{
  porte.Position = {17, 3}; //une vie est positionnee au hasard
  lcd.setCursor(porte.Position.colonne, porte.Position.ligne);
  lcd.write(5);//affiche la vie
  porte.estVivant = 1;
}

void creationClefs()
{
  for (int i = 0; i < niveau.nombreClefs; i++) // pour chaque clef
  {
    clef[i].Position = {random(2, 16), random(1, 2)}; //les clefs sont positionnees au hasard
    lcd.setCursor(clef[i].Position.colonne, clef[i].Position.ligne);
    lcd.write(3);//affiche la clef
    clef[i].estVivant = 1;
  }
}

void creationMechants()
{
  for (int i = 0; i < niveau.nombreMechants; i++) // pour chaque mechant
  {
    mechant[i].Position = {clef[i].Position.colonne, clef[i].Position.ligne - 1}; //la position des mechants depend de la position des clefs qu'ils protegent
    lcd.setCursor(mechant[i].Position.colonne, mechant[i].Position.ligne);
    lcd.write(2);//affiche le mechant
    mechant[i].estVivant = 1;
  }
}

/*----------------------------------------------------SAUVEGARDE DU SCORE DU JOUEUR DANS LE CLASSEMENT ET ECRITURE DANS l'EEPROM DU NOUVEAU CLASSEMENT----*/
void sauvegardeScoreFinal()
{

  classement_ecriture.score =  perso.score;
  classement_ecriture.indexlettre = perso.indexLettre;
  EEPROM.put(0,classement_ecriture); 
}

void effacerCase()
{
  lcd.print(F(" "));
}

bool estCollusionne(Coordonnees objet1Position, Coordonnees objet2Position)//int objet1CoordonneeColonne, int objet1CoordonneeLigne, int objet2CoordonneeColonne, int objet2CoordonneeLigne)
{
  if (objet1Position.colonne + 20 * objet1Position.ligne == objet2Position.colonne + 20 * objet2Position.ligne)
  {
    return estCollusionne;
  }
  else
  {
    return 0;
  }
}

/*-------------GESTION DES CONSEQUENCES DES COLLISIONS ENTRE OBJETS-*/
void collisions()
{
  /*---------------COLLISION ENTRE LE PERSO ET UN MECHANT--------------------*/
  for (int i = 0; i < niveau.nombreMechants; i++) // on verifie les collisions avec chaque mechant
  {
    if (estCollusionne(perso.Position, mechant[i].Position) and mechant[i].estVivant)
    {
      perso.Position = {0, 0}; //retour à la case départ
      perso.vie --;// le personnage perd une vie
      sonMechantToucheHeros();
      if (perso.vie == 0) { // plus de vie, c'est "game over"
       gameOver();
      }
    }
  }
  /*----------------COLLISION ENTRE LE PERSO ET UNE CLEF--------------------*/
  for (int i = 0; i < niveau.nombreClefs; i++) // on verifie les collisions avec chaque clef
  {
    if (estCollusionne(perso.Position, clef[i].Position) and clef[i].estVivant)
    {
      clef[i].estVivant = 0;
      perso.clefs ++;
      perso.score += 2;
    }
  }

  if (estCollusionne(perso.Position, vie.Position) and vie.estVivant)
  {
    vie.estVivant = 0;
    perso.vie ++; // le perso gagne une vie
    perso.score +=1;
  }

  /*----------------COLLISION ENTRE LE PERSO ET LA PORTE----*/
  if (estCollusionne(porte.Position, perso.Position) and perso.clefs == niveau.nombreClefs)//il faut avoir ramasse toutes les cles du niveau pour passer au suivant
  {
    niveau.numero++; // on passe au niveau suivant
    sonFinNiveau();
    perso.score += 10;
    creationNiveau();
  }
  if (estCollusionne(porte.Position, perso.Position) and perso.clefs != niveau.nombreClefs)// le perso n'a pas toutes les cles
  {
    perso.Position = {0, 0}; //retour à la case départ
  }


  /*----------------COLLISION ENTRE UN TIR ET UN MECHANT--------------------*/
  for (int i = 0; i < niveau.nombreMechants; i++) // on verifie les collisions avec chaque mechant
  {
    if (estCollusionne(mechant[i].Position, munition.Position))
    { 
      mechant[i].Vitesse += 500; // le mechant est ralenti dans son deplacement
      // si il est touché par un tir.
      //ATTENTION : la variable mechant.Vitesse augmente
      // mais la vitesse de son déplacement ralentit
      // autre conséquence possible :  {mechant.CompteurPosition = 9; mechant.estVivant=0;} // le mechant disparait

      munition.estTire = 0; // on arrête le tir
      munition.Position = {perso.Position.colonne, perso.Position.colonne};
      // la munition a atteint son objectif, elle revient dans la "poche du perso"
      perso.score ++; //le perso gagne un point de score pour avoir touché un mechant
    }
  }
}

/*------------RAFRAICHISSEMENT DE L'AFFICHAGE DES OBJETS VIVANTS SUR L'ECRAN--------------------*/
void actualisationObjetsVivants()
{
  if (perso.estVivant)
  {
    lcd.setCursor(perso.Position.colonne, perso.Position.ligne);
    lcd.write(0);
  }

  for (int i = 0; i < niveau.nombreClefs; i++) // pour chaque clef
  {
    if (clef[i].estVivant)
    {
      lcd.setCursor(clef[i].Position.colonne, clef[i].Position.ligne);
      lcd.write(3);
    }
  }
  if (niveau.numero <4) 
  {
    for (int i = 0; i < niveau.nombreMechants; i++) // pour chaque mechant
    {
      if (mechant[i].estVivant)
      {
        lcd.setCursor(mechant[i].Position.colonne, mechant[i].Position.ligne);
        lcd.write(2);//on affiche le mechant
      }
    }
  }
  if (niveau.numero ==4) // il y a un boss, son graphisme est different
 {
    for (int i = 0; i < niveau.nombreMechants; i++) // pour chaque mechant
    {
      if (mechant[i].estVivant)
      {
        lcd.setCursor(mechant[i].Position.colonne, mechant[i].Position.ligne);
        lcd.write(6);//on affiche le boss
      }
    }
  }
  if (vie.estVivant)
  {
    lcd.setCursor(vie.Position.colonne, vie.Position.ligne);
    lcd.write(1);
  }

  if (porte.estVivant)
  {
    lcd.setCursor(porte.Position.colonne, porte.Position.ligne);
    lcd.write(5);
  }

}

/*------------DIRECTION DE DEPLACEMENTS DU PERSONNAGE ET DES MECHANTS----------------*/
void persoDroite()
{
  perso.Position.colonne++;
   if (perso.Position.colonne > 17) {
    perso.Position.colonne = 17; //on n'accepte le déplacement que dans les limites de l'écran
  }
  lcd.setCursor(perso.Position.colonne - 1, perso.Position.ligne);
  effacerCase();
}
void mechantDroite(byte index)
{
  mechant[index].Position.colonne++;
  lcd.setCursor(mechant[index].Position.colonne - 1, mechant[index].Position.ligne);
  effacerCase();
}

void persoGauche()
{
  perso.Position.colonne--;
  if (perso.Position.colonne < 0) {
    perso.Position.colonne = 0;
  }
  lcd.setCursor(perso.Position.colonne + 1, perso.Position.ligne);
  effacerCase();
}
void mechantGauche(byte index)
{
  mechant[index].Position.colonne--;
  lcd.setCursor(mechant[index].Position.colonne + 1, mechant[index].Position.ligne);
  effacerCase();
}
void persoBas()
{
  perso.Position.ligne++;
  if (perso.Position.ligne > 3) {
    perso.Position.ligne = 3;
  }
  lcd.setCursor(perso.Position.colonne, perso.Position.ligne - 1);
  effacerCase();
}
void mechantBas(byte index)
{
  mechant[index].Position.ligne++;
  lcd.setCursor(mechant[index].Position.colonne, mechant[index].Position.ligne-1);
  effacerCase();
}

void persoHaut()
{
  perso.Position.ligne--;
  if (perso.Position.ligne < 0) {
    perso.Position.ligne = 0;
  }
  lcd.setCursor(perso.Position.colonne, perso.Position.ligne + 1);
  effacerCase();
}
void mechantHaut(byte index){
  mechant[index].Position.ligne--;
  lcd.setCursor(mechant[index].Position.colonne, mechant[index].Position.ligne+1);
  effacerCase();
}

/*----DEMARRAGE DE L'ECRAN LCD ET DU RETROECLAIRAGE-------------*/
/*----AFFECTATION D'UNE ETIQUETTE A CHAQUE GRAPHISME-----*/
void initialise()
{
  lcd.init();
  lcd.backlight();
    pinMode(2, INPUT_PULLUP);//LE SWITCH DU JOYSTICK
    pinMode(8, OUTPUT);//LE BUZZER
randomSeed(analogRead(A6)); //indispensable pour une vraie randomisation

  lcd.createChar(0, persoGraphique);
  lcd.createChar(1, vieGraphique);
  lcd.createChar(2, mechantGraphique);
  lcd.createChar(3, clefGraphique);
  lcd.createChar(5, porteGraphique);
  lcd.createChar(6, bossGraphique);
}


/*------------CONSEQUENCES MOUVEMENT JOYSTICK JOUEUR-----------*/
void deplacementJoystick()
{
  J1 = analogRead(0); J2 = analogRead(1); // lecture des valeurs analogiques renvoyées par le joystick

  if (J1 < seuilActionBas) {
    persoBas();
    perso.CompteurVitesse = millis();
  }
  if (J1 > seuilActionHaut) {
    persoHaut();
    perso.CompteurVitesse = millis();
  }
  if (J2 < seuilActionBas) {
    persoDroite();
    perso.CompteurVitesse = millis();
  }
  if (J2 > seuilActionHaut) {
    persoGauche();
    perso.CompteurVitesse = millis();
  }
}


/*--------GESTION DU DECLENCHEMENT D'UN TIR--------------------*/
void declenchementTir()
{
  munition.Position = perso.Position;
  // les coordonnées de la munition sont, au moment du tir,les mêmes que celle du personnage
  // il faut donc bien les actualiser à chaque déclenchement
  // car le personnage ne tire jamais du même endroit!
  munition.estTire = 1; // le coup est parti!
  perso.munition --; //le personnage perd une munition

}

/*----------GESTION DU DEPLACEMENT AUTOMATIQUE DU TIR DECLENCHE-------------*/
void TirEncours()
{
  if (munition.Position.colonne < 17) //tant que la position actuelle du bullette est inférieure à la coordonnée "bord droit" du tableau
  {
    munition.Position.colonne ++;  // on continue d'augmenter de 1 la coordonnée y (la loop principale redéclenche cette augmentation
    // en comparant le munition.Compteur + la munition.Vitesse avec millis())
    lcd.setCursor(munition.Position.colonne, munition.Position.ligne);
    lcd.print(F("-")); // on affiche la munition
    lcd.setCursor(munition.Position.colonne - 1, munition.Position.ligne);
    effacerCase();
  }
  if (munition.Position.colonne == 17)
  {
    lcd.setCursor(munition.Position.colonne, munition.Position.ligne);
    effacerCase();
    munition.estTire = 0;
  } // arrivée du tir en fin de ligne sans avoir rien touche, elle disparait

  munition.compteurVitesse = millis() ; //compteur remis au temps actuel

}

void affichageScores()
{
  lcd.setCursor(18, 1);
  lcd.print(perso.score);
  lcd.setCursor(19, 2);
  lcd.print(perso.munition);
  lcd.setCursor(19, 3);
  lcd.print(perso.vie);
}

void menuJeu()
{ 
  Coordonnees selecteurCoordonnees{4,1};

  while (1) { 
  lcd.setCursor(5,1); lcd.print(F("JOUER!"));
  lcd.setCursor(5,2); lcd.print(F("REGLES"));
  lcd.setCursor(5,3);lcd.print(F("MEILLEUR SCORE"));
  BP1 = digitalRead(2);
   J1 = analogRead(0);

  if (J1 < seuilActionBas) {
    delay(300);selecteurCoordonnees.ligne ++; sonDeplacementMenu();
    if (selecteurCoordonnees.ligne >3){
      selecteurCoordonnees.ligne = 3;
      }  
    lcd.setCursor(selecteurCoordonnees.colonne,selecteurCoordonnees.ligne-1); 
    effacerCase();
  }
  if (J1 > seuilActionHaut) {
    delay(300);selecteurCoordonnees.ligne --;  sonDeplacementMenu();
    if (selecteurCoordonnees.ligne <1){
      selecteurCoordonnees.ligne = 1;
      } 
    lcd.setCursor(selecteurCoordonnees.colonne,selecteurCoordonnees.ligne+1); 
    effacerCase();
  }

  lcd.setCursor(selecteurCoordonnees.colonne,selecteurCoordonnees.ligne);
  lcd.print(F(">")); // on affiche le selecteur
  
  if (BP1 == LOW and selecteurCoordonnees.ligne ==1){
    delay(300);menuNomJoueur();creationNiveau();break;
   }
  if (BP1 == LOW and selecteurCoordonnees.ligne ==2){
    delay(300);pagePresentationRegles();
    }
  if (BP1 == LOW and selecteurCoordonnees.ligne ==3){
    delay(300);recuperationMeilleurScore();highScoreMenu();
    }

  }
}

fonctionsObjets.h


const byte persoGraphique[] = {
  B01100,
  B01100,
  B10010,
  B11011,
  B01100,
  B01100,
  B01100,
  B00000
};
byte vieGraphique[] = {
  B00000,
  B01010,
  B10101,
  B10001,
  B10001,
  B01010,
  B00100,
  B00000
};

const byte mechantGraphique[] = {
  B00100,
  B01010,
  B11111,
  B01010,
  B10101,
  B01010,
  B00100,
  B00000
};
const byte clefGraphique[] = {
  B00000,
  B01100,
  B00100,
  B00100,
  B01110,
  B01110,
  B00000,
  B00000
};

const byte porteGraphique[]
{
  B11111,
  B10001,
  B10001,
  B10001,
  B10101,
  B10001,
  B10001,
  B10001
};

const byte bossGraphique[]{
  B00000,
  B10101,
  B11111,
  B01110,
  B00100,
  B11111,
  B10101,
  B10101

};

graphiquesObjets.h

#include <LiquidCrystal_I2C.h>

bool flagSon =0;
struct IndexLettre
{
int Unchoisie;
int Deuxchoisie;
int Troischoisie;
};

struct Classement
{
  String nom = "";
  int score;
  IndexLettre indexlettre;
};

struct Coordonnees
{ 
int colonne;  
int ligne;  
};

struct Perso
{
  String nom;
IndexLettre indexLettre;
Coordonnees Position;
int Vitesse = 100;
unsigned long CompteurVitesse=0;
bool estVivant = 0;
byte clefs;
byte munition;
byte score = 0;
byte vie = 3;
};

struct Mechant
{
Coordonnees Position;
int Vitesse;
unsigned long CompteurVitesse=0;
byte CompteurPosition = 1;
bool estVivant = 0;

};

struct ObjetFixe
{
Coordonnees Position;
bool estVivant = 0;

};

struct Munition
{
 Coordonnees Position;
 byte vitesse= 80;
 unsigned long compteurVitesse=0;
bool estTire = 0;
};

struct Niveau
{ 
byte numero = 1;
byte nombreClefs;
byte nombreMechants; 
byte nombreMunitions = 9;
};


/*------------------------INSTANCIATION DES OBJETS------------------------------*/
LiquidCrystal_I2C lcd(0x27, 20, 4);

Perso perso;
ObjetFixe clef[3]; // on crée trois objets "clefs", il n'y aura pas plus de 3 dans le jeu
Mechant mechant[3]; // On crée 3 objets "mechants", il n'y aura pas plus de 3 mechants vivants dans le jeu
ObjetFixe vie;// On crée un objet "vie"
ObjetFixe porte;// on crée un objet "porte"
Munition munition;// on crée un objet "munition" à partir de la structure "Munition"
Niveau niveau;//On crée un objet "niveau"
Classement classement_ecriture;
Classement classement_lu;

/*-----------------DECLARATION DES VARIABLES GLOBALES--------- */
int seuilActionBas = 15; //seuil atteint par les valeurs du joystick
int seuilActionHaut = 1000; 
int J1, J2; // valeurs des axes du Joystick de 0 à 1025
bool BP1; // valeurs du bouton SWITCH du Joystick soit 0 (pas appuyé) soit 1 (appuyé)


structuresObjets.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:
LiquidCrystal I2C

Tone

libraries.txt

  void sonMechantToucheHeros(){

  tone(8,250, 250);
  delay(1000);
  tone(8,200, 250);
  delay(1000);
  tone(8,150, 250);
  delay(2000);
  }

void sonDebutNiveau(){}

void sonFinNiveau(){}

void sonDebutJeu(){}

void sonDeplacementMenu(){}






son.h

// === Présentation et Affichage ===

// Page de présentation du jeu
void pagePresentationJeu();

// Page de présentation des règles du jeu
void pagePresentationRegles();

// Menu principal du jeu
void menuJeu();
void gameOver();
void victoire();

// === Gestion des Scores ===

// Récupération du meilleur score
void recuperationMeilleurScore();

// Menu du high score
void highScoreMenu();

// Affichage des scores en cours de partie
void affichageScoresEncours();

// Affichage du score final
void affichageScoreFinal();

// Sauvegarde du score final
void sauvegardeScoreFinal();

// Affichage de tous les scores
void affichageScores();


// === Initialisation et Création d'Éléments ===

// Fonction d'attente
void attente();
void(* resetFunc) (void) = 0;
// Initialisation du jeu
void initialise();

// Création du personnage du joueur
void creationPersonnage();

// Création de la barre de vie
void creationVie();

// Création des portes dans le jeu
void creationPorte();

// Création des clés dans le jeu
void creationClefs();

// Création des ennemis dans le jeu
void creationMechants();

// Création d'un nouveau niveau
void creationNiveau();


// === Gestion du Jeu ===

// Effacement d'une case dans le jeu
void effacerCase();

// Actualisation des objets vivants dans le jeu
void actualisationObjetsVivants();

// Gestion des collisions dans le jeu
void collisions();

// Déplacement du personnage vers la droite
void persoDroite();

// Déplacement d'un ennemi vers la droite
void mechantDroite(byte index);

// Déplacement du personnage vers la gauche
void persoGauche();

// Déplacement d'un ennemi vers la gauche
void mechantGauche(byte index);

// Déplacement du personnage vers le bas
void persoBas();

// Déplacement d'un ennemi vers le bas
void mechantBas(byte index);

// Déplacement du personnage vers le haut
void persoHaut();

// Déplacement d'un ennemi vers le haut
void mechantHaut(byte index);

// Déplacement d'un ennemi (général)
void mechantDeplacement(byte index);

// Attaque d'un ennemi
void mechantAttaque(byte index);

// Déclenchement du tir du personnage
void declenchementTir();

// Gestion du tir en cours
void TirEncours();


// Routines de vérification dans la boucle principale
void routineDeplacementMechant();
void routineJoystickControle();
void routineTirControle();
void routineTirDeclenchement();

// Les différents sons du jeu
void sonTir();
void sonDeplacementPersonnage();
void sonDeplacementMechant();
void sonMechantToucheHeros();
void sonHerosPrendClef();
void sonHerosPrendVie();
void sonFinNiveau();
void sonMechantToucheParTirHeros();
void sonDebutJeu();
void sonDeplacementMenu();


prototypesFonctions.h

void pagePresentationJeu()
{ lcd.clear();
  lcd.setCursor(0, 0); lcd.print(F("*****L'AVENTURE*****"));
  lcd.setCursor(0, 1); lcd.print(F("****-----de-----****"));
  lcd.setCursor(0, 2); lcd.print(F("----shinobi---"));
  lcd.setCursor(0, 3); lcd.print(F("********************"));
  sonDebutJeu();
  attente();
  lcd.clear();
}
void pagePresentationRegles()
{
  lcd.clear() ;
  lcd.setCursor(0, 0); lcd.print(F("*******PROUVE*******"));
  lcd.setCursor(0, 1); lcd.print(F("******TA VALEUR*****"));
  lcd.setCursor(0, 2); lcd.print(F("****EN TRAVERSANT***"));
  lcd.setCursor(0, 3); lcd.print(F("L'ANTRE SQUELETTES!!"));
  attente();

  lcd.clear() ;
  lcd.setCursor(0, 0); lcd.print(F("  PRENDS LES CLEFS  "));
  lcd.setCursor(0, 1); lcd.print(F("POUR OUVRIR LA PORTE"));
  lcd.setCursor(0, 2); lcd.print(F("   TOUTES LES CLEFS "));
  lcd.setCursor(0, 3); lcd.print(F("!!!!!!!!!!!!!!!!!!!!"));
  attente();

  lcd.clear() ;
  lcd.setCursor(0, 0); lcd.print(F("    TIRE SUR LES    "));
  lcd.setCursor(0, 1); lcd.print(F("     SQUELETTES     "));
  lcd.setCursor(0, 2); lcd.print(F(" POUR LES RALENTIR  "));
  lcd.setCursor(0, 3); lcd.print(F("ATTENTION CA PIQUE!!"));
  attente();

  lcd.clear() ;
  lcd.setCursor(0, 0); lcd.print(F("RAMASSE LES COEURS  "));
  lcd.setCursor(0, 1); lcd.print(F("POUR GAGNER DES VIES"));
  lcd.setCursor(0, 2); lcd.print(F("TIRE  POUR          "));
  lcd.setCursor(0, 3); lcd.print(F("OBTENIR DES POINTS  "));
  attente();
  lcd.clear();
}


void affichageScoresEncours()
{
  /* AFFICHAGE DES SCORES EN COURS */
  lcd.setCursor(18, 2);
  lcd.print(F("-")); // le nombre de munitions

  lcd.setCursor(18, 3);
  lcd.write(1); // le nombre de vies

  lcd.setCursor(18, 0);
  lcd.print(F("$$")); // le nombre de points
}
/*------------------------------------------------AFFICHAGE DU SCORE DU JOUEUR ------------------------*/
void affichageScoreFinal()
{
lcd.clear();
lcd.setCursor(0,0); lcd.print(F("TON SCORE:")); 
lcd.setCursor(0,1); lcd.print(perso.score); 
lcd.setCursor(0,2); lcd.print(F("BRAVO")); 
lcd.setCursor(7,3); lcd.print(perso.nom); 
attente();
}

void victoire(){
  lcd.clear(); 
  lcd.print(F("Victoire!"));
   attente(); 
   affichageScoreFinal();
   sauvegardeScoreFinal();
   delay(2000); 
   resetFunc();
     }
     
void gameOver(){
      
        perso.estVivant = 0;
        lcd.clear();
        lcd.print(F("GAME OVER!"));
        attente();
        affichageScoreFinal();sauvegardeScoreFinal();delay(2000);
        resetFunc();}

pagesPresentations.h

  void routineTirDeclenchement(){
  BP1 = digitalRead(2);
  if ((BP1 == LOW) and !munition.estTire and perso.munition > 0)
  {
    declenchementTir();
  }
  }

   void routineTirControle(){
  if ((millis() > munition.compteurVitesse + munition.vitesse) and munition.estTire)
  {
    TirEncours();
  }
 }

  void routineJoystickControle(){
  if (millis() > (perso.CompteurVitesse + perso.Vitesse))
  {
    deplacementJoystick();
  }
}

routines.h

// On peut changer le nombre de mechants et le nombres de clefs à trouver selon le niveau. 
// Attention, chaque clef est associée à un garde.
// Par contre, un boss a un déplacement indépendant de la clef
// dans le fichier comportementMechants, on peut changer ces différents comportements, en créer de nouveaux
// Si on change le nombre de méchants dans un niveau, il faut penser à ajuster cela dans le fichier structuresObjets, pour le moment prévu pour max 3 clefs et 3 méchants par niveaux. 
//On peut changer la vitesse des mechants. 
// on peut changer le nombre de niveaux
// on peut changer le type de méchants selon le niveau
// on peut changer le nombre de munitions de départ.

void creationNiveau()
{
  lcd.clear();
  perso.clefs = 0; // le personnage démarre chaque niveau sans clefs
  perso.munition = 5; //le personnage démarre chaque niveau avec 5 munitions

  switch (niveau.numero) {

    case 1 : niveau.nombreMechants = 1; niveau.nombreClefs = 1; for (int i = 0; i < niveau.nombreMechants; i++) {
        mechant[i].Vitesse = 500;
        mechant[i].CompteurPosition = 1;
      }
      break;

    case 2 : niveau.nombreMechants = 2; niveau.nombreClefs = 2;  for (int i = 0; i < niveau.nombreMechants; i++) {
        mechant[i].Vitesse = 400;
        mechant[i].CompteurPosition = 1;
      }
      break;

    case 3 : niveau.nombreMechants = 3; niveau.nombreClefs = 3;  for (int i = 0; i < niveau.nombreMechants; i++) {
        mechant[i].Vitesse = 300;
        mechant[i].CompteurPosition = 1;
      }
      break;

    case 4 : niveau.nombreMechants = 1; niveau.nombreClefs = 0; for (int i = 0; i < niveau.nombreMechants; i++) {
        mechant[i].Vitesse = 700;mechant[i].Position = {17,2};    
      }
      break;

    case 5 : victoire(); break;

  }
  creationPersonnage();
  creationVie();
  creationPorte();
  creationClefs();
  creationMechants();
  affichageScoresEncours();
}


   void routineDeplacementMechant(){
  for (int i = 0; i < niveau.nombreMechants ; i++)
  {
    if (millis() > (mechant[i].CompteurVitesse + mechant[i].Vitesse))
    { switch (niveau.numero)  {
        case 1: 
        case 2:
        case 3:
          mechantDeplacement(i);
          break;
        case 4: //BOSS de fin
          mechantAttaque(i);
          break;
      }
    }
  }
  }

  

niveaux.h


/*-----------GESTION DU DEPLACEMENT AUTOMATIQUE DU MECHANT-----------*/

void mechantDeplacement(byte index) // l'index indique quel mechant on deplace
{/*

  switch (mechant[index].CompteurPosition) { // chaque mechant a sa position indépendante de l'autre
    //le mechant se deplace en carré autour de la clef
    //il a donc 8 déplacements à faire
    //droite, bas, bas, gauche, gauche, haut, haut, droite
    // TODO : faire un tableau des déplacements du méchant
    case 1:
    mechantDroite(index);    mechantBas(index);
      break;

    case 2:
    mechantGauche(index); mechantBas(index);
      break;

    case 3:
     mechantGauche(index);mechantHaut(index);
      break;

    case 4:
     mechantDroite(index);    mechantHaut(index);
      break;

    case 5:
    mechantDroite(index);    mechantBas(index);
      break;

    case 6:
    mechantGauche(index); mechantBas(index);
      break;

    case 7:
     mechantGauche(index);mechantHaut(index);
      break;

    case 8:
     mechantDroite(index);    mechantHaut(index);
      break;

    case 9: //si on veut faire mourir le mechant, on mettra mechant.CompteurPosition à 9;
      // si on ne veut pas, ce "case9" ne sera pas utilisé car au "case8", on remet le
      //mechant.CompteurPosition à 0;
        lcd.setCursor(mechant[index].Position.colonne, mechant[index].Position.ligne);
        effacerCase();
        mechant[index].estVivant=0;
        break;
  }
  mechant[index].CompteurVitesse = millis();
  mechant[index].CompteurPosition ++;*/
 
  switch (mechant[index].CompteurPosition) { // chaque mechant a sa position indépendante de l'autre
    //le mechant se deplace en carré autour de la clef
    //il a donc 8 déplacements à faire
    //droite, bas, bas, gauche, gauche, haut, haut, droite
    // TODO : faire un tableau des déplacements du méchant
    case 1:
    mechantDroite(index);
      break;

    case 2:
    mechantBas(index);
      break;

    case 3:
     mechantBas(index);
      break;

    case 4:
     mechantGauche(index);
      break;

    case 5:
     mechantGauche(index);
      break;

    case 6:
    mechantHaut(index);
      break;

    case 7:
     mechantHaut(index);
      break;

    case 8:
     mechantDroite(index);
      mechant[index].CompteurPosition = 0;
      break;

    case 9: //si on veut faire mourir le mechant, on mettra mechant.CompteurPosition à 9;
      // si on ne veut pas, ce "case9" ne sera pas utilisé car au "case8", on remet le
      //mechant.CompteurPosition à 0;
        lcd.setCursor(mechant[index].Position.colonne, mechant[index].Position.ligne);
        effacerCase();
        mechant[index].estVivant=0;
        break;
  }
  mechant[index].CompteurVitesse = millis();
  mechant[index].CompteurPosition ++;
 
}

/*-----------------------------ATTAQUE DE CRABE! LE DEPLACEMENT DU CRABE EST FONCTION DE CELUI DU JOUEUR----------------------------*/
void mechantAttaque(byte index)
{

  if (mechant[index].Position.colonne > perso.Position.colonne)
  {
  mechantGauche(index);}

 if (mechant[index].Position.colonne < perso.Position.colonne)
  {
  mechantDroite(index);}

if (mechant[index].Position.ligne > perso.Position.ligne)
  {
  mechantHaut(index);}

if (mechant[index].Position.ligne < perso.Position.ligne)
  {
  mechantBas(index);}

  mechant[index].CompteurVitesse = millis() ;
}