#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <stdlib.h>
#include <time.h>
#include <Preferences.h>
#include "images.h"

#define nombreDePixelsEnLargeur 128
#define nombreDePixelsEnHauteur 64
#define brocheResetOLED -1
#define adresseI2CecranOLED 0x3C
Adafruit_SSD1306 display(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED);

#define btnNaviguer 14  //btn naviguer
#define btnValider 27   //btn sélectioner/valider
#define btnQuitter 12   //btn revenir en arrière/quitter

Preferences preferences;

const unsigned char* cartes[] = { carteMeduse, carteCrevette, carteCrabe, carteRaie };  //Tableau des images des cartes pour le jeu de mémoire
const int nombreDeCartes = sizeof(cartes) / sizeof(cartes[0]);

const int nombreDePaires = nombreDeCartes;           //constantes pour le nombre de paires
const int nombreDeCartesTotal = nombreDePaires * 2;  //constantes pour le nombre total de cartes.

int positionsCartes[nombreDeCartesTotal];  //positions des cartes dans le jeu
bool cartesRevelees[nombreDeCartesTotal];  // État des cartes (révélées ou non)
bool cartesTrouvees[nombreDeCartesTotal];  // État des paires de cartes trouvées
int carteSelectionnee = -1;                // Carte actuellement sélectionnée (-1 si aucune)
int cartesRetournees[2] = { -1, -1 };      // Indices des deux cartes retournées

int nombreDeCartesRetournees = 0;
int pairesTrouvees = 0;
int positionCurseur = 0;
int score = 0;


int cycle = 0;           //commencement au cycle 0
bool frameEclosion = 0;  //booléen pour alterner entre les 2 images de l'animation d'éclosion

bool nomStudio = true;

int faim = 40;    //niveau de faim initiale
int salete = 50;  //niveau de salete initiale

int positionXFleche = 19;
const int positionYFleche = 3;

// Initialisation des variables booléennes pour les menus et les états du requin
bool menuAccueil = true;
bool menuNourriture = false;
bool nuit = false;

bool requinNormal = true;
bool requinFaim = false;
bool requinGros = false;
bool requinSale = false;
bool requinMalade = false;
bool requinSommeil = false;
bool requinConfus = false;

//Variables pour réinisialiser le compteur de la faim, de la salete et de la fatigue
unsigned long resetCompeurFaim = 0;
unsigned long resetCompteurSale = 0;
unsigned long resetCompteurFatigue = 0;

//Initialisation des variables pour les différentes animations
unsigned long tempsDecor = millis();  //Initialise le temps pour la gestion de l'alternance des 2 images
unsigned long resetTempsDecor = 0;    //variable pour réinisialiser le temps du decor
bool frameDecor = 1;                  //booléen pour alterner entre les 2 images de l'animation

unsigned long tempsFaim = millis();
unsigned long resetTempsFaim = 0;
bool frameFaim = 1;

unsigned long tempsFaimEtSale = millis();
unsigned long resetTempsFaimEtSale = 0;
bool frameFaimEtSale = 1;

unsigned long tempsDormir = millis();
unsigned long resetTempsDormir = 0;
bool frameDormir = 1;

bool frameLaver = 1;  //booléen pour alterner entre les 2 images de l'animation de la fonction laver()



void sauvegarde() {
  /* Fonction permettant de sauvegarder l'état actuel du Tamagotchi.
  Cela permet de reprendre la progression sans recommencer depuis l'éclosion */

  preferences.begin("tamagotchi", false);

  preferences.putInt("cycle", cycle);  //sauvegarde du cycle du Tamagotchi
  preferences.putInt("faim", faim);    //sauvegarde du niveau de faim du Tamagotchi
  preferences.putInt("salete", salete);
  preferences.putBool("requinFaim", requinFaim);  //sauvegarde de l'état de faim
  preferences.putBool("requinSale", requinSale);
  preferences.putBool("requinGros", requinGros);
  preferences.putBool("requinMalade", requinMalade);
  preferences.putBool("requinSommeil", requinSommeil);
  preferences.putBool("requinConfus", requinConfus);

  preferences.end();
}
void chargementSauvegarde() {
  // Fonction permettant d'initialiser l'état sauvegardé au démarrage du programme

  preferences.begin("tamagotchi", true);


  cycle = preferences.getInt("cycle", cycle);                  // Valeur par default du cycle
  faim = preferences.getInt("faim", 40);                       // Valeur de faim par défaut = 40
  salete = preferences.getInt("salete", 50);                   // Valeur de saleté par défaut = 50
  requinFaim = preferences.getBool("requinFaim", requinFaim);  // Etats par défault
  requinSale = preferences.getBool("requinSale", requinSale);
  requinGros = preferences.getBool("requinGros", requinGros);
  requinMalade = preferences.getBool("requinMalade", requinMalade);
  requinSommeil = preferences.getBool("requinSommeil", requinSommeil);
  requinConfus = preferences.getBool("requinConfus", requinConfus);

  preferences.end();
}


void gestionDesEtats() {
  //Gestion des différents états du requin

  if (requinMalade) {
    requinEstMalade();
  } else if (requinSommeil) {
    requinASommeil();
  } else if (requinGros) {
    requinEstGros();
  } else if (requinFaim && requinSale) {
    requinAFaimEtSale();
  } else if (requinFaim) {
    requinAFaim();
  } else if (requinSale) {
    requinEstSale();
  } else if (requinConfus) {
    requinEstConfus();
  } else {
    afficherRequinNormal();
  }

  if (faim < 80) {
    requinGros = false;
  }
}
void gestionDesMenus() {
  //Gestion des menus

  if (menuAccueil) {
    afficherMenu();
  } else if (menuNourriture) {
    afficherMenuNourriture();
  } else if (nuit) {
    afficherNuit();
  }
}
void resetDesEtatsEtMenus() {
  //Réinistialiser toutes les stats du requin

  faim = 40;
  salete = 50;
  menuAccueil = true;
  menuNourriture = false;
  nuit = false;
  requinNormal = true;
  requinFaim = false;
  requinGros = false;
  requinSale = false;
  requinMalade = false;
  requinSommeil = false;
}


void diminutionDeLaFaim() {
  //Diminution de la faim du requin

  unsigned long compteurFaim = millis();

  if (compteurFaim - resetCompeurFaim > 30000) {  //toutes les 30 secondes le requin perd 10 de faim
    resetCompeurFaim = compteurFaim;
    faim -= 10;

    if (faim <= 30) {  //si le niveau de faim est inférieur ou égal à 30, le requin a faim
      requinFaim = true;
    }
  }
  sauvegarde();  // Sauvegarder l'état après la mise à jour
}
void augmentationDeLaFatigue() {
  //augmentation de la fatigue du requin

  unsigned long compteurFatigue = millis();

  if (compteurFatigue - resetCompteurFatigue > 300000) {  //Toutes les 5 minutes le requin a besoin de dormir
    resetCompteurFatigue = compteurFatigue;
    requinSommeil = true;
  }
  sauvegarde();  // Sauvegarder l'état après la mise à jour
}
void augmentationDeLaSalete() {
  //augmentation du niveau de saleté du requin

  unsigned long compteurSale = millis();

  if (compteurSale - resetCompteurSale >= 25000) {  //Toutes les 25 secondes le requin prend 10 de salete
    resetCompteurSale = compteurSale;
    salete += 10;

    if (salete >= 70) {  //Si le niveau de salete est égal ou supérieur à 70 le requin est sale
      requinSale = true;
    }
  }
  sauvegarde();  // Sauvegarder l'état après la mise à jour
}


void navMenu() {
  //Déplacement de la flèche pour naviguer dans les menus

  display.drawBitmap(positionXFleche, positionYFleche, fleche, 6, 9, WHITE);

  if (digitalRead(btnNaviguer) == LOW) {
    display.fillRect(19, 3, 6, 9, BLACK);  //Effacer toutes les positions possible de la flèche
    display.fillRect(45, 3, 6, 9, BLACK);
    display.fillRect(71, 3, 6, 9, BLACK);
    display.fillRect(97, 3, 6, 9, BLACK);
    display.fillRect(123, 3, 6, 9, BLACK);
    positionXFleche += 26;  //nouvelle position de la flèche
    delay(200);
  }
  if (positionXFleche > 123) {  //Si la flèche dépasse la dernière position, elle revient à la première
    positionXFleche = 19;
  }
  display.display();  //Afficher la flèche
}


void afficherRequinNormal() {
  //Afficher le requin quand il est normal

  display.drawBitmap(0, 17, img_requinNormal, 128, 48, WHITE);
  display.display();
}
void afficherDecor() {
  //Animation du decor

  tempsDecor = millis();
  if (tempsDecor - resetTempsDecor > 700) {  //Toutes les 700 millisecondes on réinisialise le compteur et on change d'image
    resetTempsDecor = tempsDecor;
    if (frameDecor) {
      frameDecor = 0;
    } else {
      frameDecor = 1;
    }
  }
  display.fillRect(0, 21, 40, 48, BLACK);
  display.fillRect(88, 21, 40, 48, BLACK);                                 //effacer l'image précedente
  display.drawBitmap(0, 16, animation_decor[frameDecor], 128, 48, WHITE);  //Afficher les images de l'animation
  display.display();
}


void afficherMenu() {
  //Afficher le menu d'accueil

  //Afficher les différentes icônes du menu
  display.drawBitmap(1, 0, fish, 15, 15, WHITE);
  display.drawBitmap(27, 0, soin, 15, 15, WHITE);
  display.drawBitmap(54, 0, coeur, 15, 15, WHITE);
  display.drawBitmap(81, 0, soleil, 15, 15, WHITE);
  display.drawBitmap(107, 0, jeux, 15, 15, WHITE);
  navMenu();  //appel de la fonction navMenu() pour naviguer dans le menu
}
void afficherMenuNourriture() {
  //Afficher le menu de nourriture

  //Afficher les différentes icônes du menu
  display.drawBitmap(1, 0, poisson, 15, 15, WHITE);
  display.drawBitmap(27, 0, meduse, 15, 15, WHITE);
  display.drawBitmap(54, 0, crevette, 15, 15, WHITE);
  display.drawBitmap(81, 0, crabe, 15, 15, WHITE);
  display.drawBitmap(107, 0, raie, 15, 15, WHITE);
  navMenu();  //appel de la fonction navMenu() pour naviguer dans le menu

  if (menuNourriture && digitalRead(btnValider) == LOW) {  //Si on valide une nourriture, le requin n'a plus faim et mange
    requinFaim = false;
    manger();
  }

  if (digitalRead(btnQuitter) == LOW) {  //Quitter le menu de nourriture
    menuNourriture = false;
    transitionInverse();
    menuAccueil = true;
  }
}
void afficherNuit() {
  //Afficher la nuit

  display.invertDisplay(false);  //Inverser les couleurs pour la nuit
  display.drawBitmap(57, 0, lune, 15, 15, WHITE);

  if (!requinSommeil) {                    //si le requin n'a pas sommeil
    if (digitalRead(btnQuitter) == LOW) {  //Et si on quitte la nuit
      nuit = false;
      grandeTransition();
      display.invertDisplay(true);       //Inverser les couleurs de l'écran pour afficher le jour
      menuAccueil = true;                //Réaffiche le menu d'accueil
      requinConfus = false;              //le requin n'est plus confus
      int chance_malade = random(1, 5);  //le requin a 1 chance sur 3 de tomber malade en quittant la nuit
      if (chance_malade == 1) {
        requinMalade = true;
      }
    }
  }

  if (requinSommeil) {                     //Si le requin a sommeil pendant qu'il fait nuit
    if (digitalRead(btnQuitter) == LOW) {  //Et si on quitte la nuit
      nuit = false;
      grandeTransition();
      display.invertDisplay(true);  //Inverser les couleurs de l'écran pour afficher le jour
      menuAccueil = true;           //revenir au menu d'accueil
    }
  }
  display.display();
  sauvegarde();  // Sauvegarder l'état après la mise à jour
}


void requinAFaim() {
  //Animation du requin quand il a faim

  tempsFaim = millis();
  if (tempsFaim - resetTempsFaim > 500) {  //toutes le 500 millisecondes on réinisialise le compteur et on change d'image
    resetTempsFaim = tempsFaim;
    if (frameFaim) {
      frameFaim = 0;
    } else {
      frameFaim = 1;
    }
  }
  display.fillRect(43, 23, 45, 43, BLACK);                                      //effacer l'image précedente
  display.drawBitmap(0, 17, animation_RequinAFaim[frameFaim], 128, 48, WHITE);  //Afficher les images de l'animation
  display.display();
}
void manger() {
  //Animation pour manger

  display.fillRect(43, 23, 39, 48, BLACK);
  display.drawBitmap(0, 17, img_manger, 128, 48, WHITE);

  if (positionXFleche == 19) {  //en fonction de la nourriture choisi dans le menu de nourriture, on l'affiche dans sa main
    display.drawBitmap(35, 37, poisson, 15, 15, WHITE);
  } else if (positionXFleche == 45) {
    display.drawBitmap(35, 37, meduse, 15, 15, WHITE);
  } else if (positionXFleche == 71) {
    display.drawBitmap(35, 37, crevette, 15, 15, WHITE);
  } else if (positionXFleche == 97) {
    display.drawBitmap(35, 37, crabe, 15, 15, WHITE);
  } else if (positionXFleche == 123) {
    display.drawBitmap(35, 37, raie, 15, 15, WHITE);
  }
  display.display();
  delay(500);
  display.fillRect(43, 23, 39, 48, BLACK);
  display.fillRect(33, 34, 20, 19, BLACK);            //effacer l'image précedente
  display.drawBitmap(0, 17, avaler, 128, 48, WHITE);  //image du requin qui mange sa nourriture
  display.display();
  delay(500);
  display.fillRect(43, 23, 42, 48, BLACK);
  if (faim > 30 && faim < 80) {                          //Si le requin a assez manger
    display.drawBitmap(0, 17, content, 128, 48, WHITE);  //Le requin est content
    display.display();
    delay(500);
    display.fillRect(41, 23, 46, 48, BLACK);
    requinNormal = true;  //Le requin redevient normal
  }
  faim += 20;

  if (faim > 70) {      //Si le requin mange trop
    requinGros = true;  //Le requin devient gros
  }
}
void requinEstGros() {
  //Afficher le requin quand il est gros

  display.fillRect(43, 23, 45, 43, BLACK);
  display.drawBitmap(0, 17, img_requinEstGros, 128, 48, WHITE);
  display.display();
}

void requinEstSale() {
  //Afficher le requin quand il est sale

  display.fillRect(43, 23, 45, 43, BLACK);
  display.drawBitmap(0, 17, img_requinEstSale, 128, 48, WHITE);
  display.display();
}
void laver() {
  //Animation pour laver le requin

  for (int i = 0; i < 40; i++) {
    display.fillRect(42, 23, 45, 48, BLACK);                                 //effacer l'image précedente
    display.drawBitmap(0, 17, animation_laver[frameLaver], 128, 48, WHITE);  //Afficher les images de l'animation
    display.display();
    delay(500);  //Toutes les 500 millisecondes on change d'image
    if (frameLaver) {
      frameLaver = 0;
    } else {
      frameLaver = 1;
    }
  }

  salete -= 40;
  display.fillRect(42, 23, 46, 48, BLACK);  //Efface la dernière image de l'animation
  requinNormal = true;                      //le requin redevient normal
}
void requinAFaimEtSale() {
  //Animation du requin quand il a faim et est sale

  tempsFaimEtSale = millis();
  if (tempsFaimEtSale - resetTempsFaimEtSale > 500) {  //toutes le 500 millisecondes on réinisialise le compteur et on change d'image
    resetTempsFaimEtSale = tempsFaimEtSale;
    if (frameFaimEtSale) {
      frameFaimEtSale = 0;
    } else {
      frameFaimEtSale = 1;
    }
  }
  display.fillRect(43, 23, 45, 43, BLACK);                                                  //effacer les image précedente
  display.drawBitmap(0, 17, animation_requinAFaimEtSale[frameFaimEtSale], 128, 48, WHITE);  //Afficher les images de l'animation
  display.display();
}

void requinEstMalade() {
  //Afficher le requin qaund il est malade

  display.fillRect(43, 23, 45, 43, BLACK);
  display.drawBitmap(0, 17, img_requinEstMalade, 128, 48, WHITE);
  display.display();
}
void soigner() {
  //Animation pour soigner le requin

  for (int i = 0; i < 6; i++) {
    display.drawBitmap(0, 17, animation_soigner[i], 128, 48, WHITE);  //Afficher les images de l'animation
    display.display();
    delay(500);
    display.fillRect(41, 23, 47, 43, BLACK);  //effacer l'image précedente
  }
  requinMalade = false;  //Le requin n'est plus malade
  requinNormal = true;   //Le requin redevient normal
}

void requinASommeil() {
  //Afficher le requin quand il a sommeil

  display.fillRect(43, 23, 45, 43, BLACK);
  display.drawBitmap(0, 17, img_requinASommeil, 128, 48, WHITE);
  display.display();
}
void dormir() {
  //Animation pour dormir du requin

  tempsDormir = millis();
  if (tempsDormir - resetTempsDormir > 700) {  //toutes le 700 millisecondes on réinisialise le compteur et on change d'image
    resetTempsDormir = tempsDormir;
    if (frameDormir) {
      frameDormir = 0;
    } else {
      frameDormir = 1;
    }
  }
  display.fillRect(43, 23, 45, 43, BLACK);                                   //effacer les image précedente
  display.drawBitmap(0, 17, animation_dormir[frameDormir], 128, 48, WHITE);  //Afficher les images de l'animation
  display.display();
}
void requinEstConfus() {
  //Afficher le requin quand il est confus

  display.fillRect(43, 23, 45, 43, BLACK);
  display.drawBitmap(0, 17, img_requinEstConfus, 128, 48, WHITE);
  display.display();
}


void transition() {
  //Animation de transitions pour entrer dans un menu

  for (int i = 1; i < 17; i++) {
    display.fillRect(0, 0, 8 * i, 15, BLACK);
    display.display();
    delay(10);
  }
  delay(70);
}
void transitionInverse() {
  //Animation de transitions pour sortir d'un menu

  for (int i = 1; i < 17; i++) {
    display.fillRect(136 - 8 * (i + 1), 0, 8, 15, BLACK);
    display.display();
    delay(10);
  }
  delay(70);
}
void grandeTransition() {
  //Animation de transition pour passer du jour à la nuit, ou inversement

  for (int i = 1; i < 17; i++) {
    display.fillRect(0, 0, 128, 8 * i, BLACK);
    display.display();
    delay(5);
  }
  delay(50);
}

void conditionsDeMort() {
  //Si une de ces conditions est rempli le requin meurt

  if (faim == 0 || faim >= 100 || salete == 100 || salete <= 10) {
    cycle = 4;
  }
}


//Fonctions servant au jeu de mémoire
void afficherNomDuJeu() {
  // afficher le nom du jeu avant d'entrer dans le jeu

  display.invertDisplay(false);  //Inverser les couleurs de l'écran
  display.clearDisplay();
  display.drawBitmap(0, 0, memoryGame, 128, 64, WHITE);
  display.display();
  delay(1000);
}
void melangerLesCartes() {
  //Mélange les cartes du jeu de memoire

  //Initialiser les cartes
  for (int i = 0; i < nombreDeCartesTotal; i++) {
    positionsCartes[i] = i % nombreDePaires;  //Assigner les positions
    cartesRevelees[i] = false;                //Initialiser comme non révélées
    cartesTrouvees[i] = false;                //Initialiser comme non trouvées
  }

  // Mélanger les cartes
  for (int i = 0; i < nombreDeCartesTotal; i++) {
    int j = random(0, nombreDeCartesTotal);  //Générer un index aléatoire
    int temp = positionsCartes[i];           //Permuter les positions des cartes
    positionsCartes[i] = positionsCartes[j];
    positionsCartes[j] = temp;
  }
}
void afficherLesCartes() {
  //afficher les cartes du jeu

  display.clearDisplay();

  // Affichage du score en haut de l'écran
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.print("Score: ");
  display.print(score);

  // Boucle pour afficher toutes les cartes
  for (int i = 0; i < nombreDeCartesTotal; i++) {
    int x = (i % 4) * 32;       //Position x des cartes
    int y = (i / 4) * 28 + 16;  //Position y des cartes

    // Vérifier si la carte est révélée ou trouvée
    if (cartesRevelees[i] || cartesTrouvees[i]) {
      display.drawBitmap(x, y, cartes[positionsCartes[i]], 30, 20, WHITE);  //Afficher la carte retourner
    } else {
      display.drawBitmap(x, y, turn_card, 32, 32, WHITE);  //laisser la carte face cachée
    }

    //coordonnées du centre de la carte
    int centre_x = x + 16;
    int centre_y = y + 16;

    //Taille et position du curseur
    int tailleCurseur = 18;
    int curseurX = centre_x - (tailleCurseur / 1.8);
    int curseurY = centre_y - (tailleCurseur / 1.2);

    // Vérifier si le curseur est sur la carte courante
    if (i == positionCurseur) {
      display.drawRect(curseurX, curseurY, tailleCurseur, tailleCurseur, WHITE);  //dessine un rectangle pour indiquer le curseur
    }
  }

  display.display();
}
void verifierLesCartes() {

  //Vérifie si deux cartes ont été retournées
  if (cartesRetournees[0] != -1 && cartesRetournees[1] != -1) {

    //Si 2 cartes retournées sont identique
    if (positionsCartes[cartesRetournees[0]] == positionsCartes[cartesRetournees[1]]) {

      // Marquer les 2 cartes comme trouvées
      cartesTrouvees[cartesRetournees[0]] = true;
      cartesTrouvees[cartesRetournees[1]] = true;
      pairesTrouvees++;

      // Afficher "+2" pour indiquer que le score a augmenté
      display.setTextSize(1);
      display.setTextColor(WHITE);
      display.setCursor(55, 0);
      display.print("+2");
      display.display();
      delay(400);
      display.fillRect(15, 0, 5, 5, BLACK);

      score += 2;  // Augmenter le score pour chaque paire trouvée

    } else {
      // Si les cartes retournées ne forment pas une paire, les retourner à nouveau
      cartesRevelees[cartesRetournees[0]] = false;
      cartesRevelees[cartesRetournees[1]] = false;
    }
    // Réinitialiser les indices des cartes retournées
    cartesRetournees[0] = -1;
    cartesRetournees[1] = -1;
    nombreDeCartesRetournees = 0;
  }
}

//Fonction servant à l'éclosion
void afficherNomStudio() {
  // Afficher  le nom du studio fictif au lancement du Tamagotchi pour la première fois
  
  display.drawBitmap(0, 0, sharkStudio, 128, 64, WHITE);
  display.display();
  delay(1000);
  display.clearDisplay();
  nomStudio = false;
}
void animationEclosion() {
  //Animation de l'éclosion de l'oeuf du requin

  //Première animation de s'intillement de l'oeuf
  for (int i = 0; i < 20; i++) {
    display.fillRect(50, 30, 26, 28, BLACK);                                   //Effacer l'image précedente
    display.drawBitmap(50, 30, animation_oeuf[frameEclosion], 26, 28, WHITE);  //Afficher les images de l'animation
    display.display();
    delay(700);  //Toutes les 700 millisecondes on change d'image
    if (frameEclosion) {
      frameEclosion = 0;
    } else {
      frameEclosion = 1;
    }
  }

  delay(1000);

  //Puis animation de l'éclosion
  for (int i = 0; i < 6; i++) {
    display.drawBitmap(50, 24, oeuf_casse[i], 26, 34, WHITE);  //Afficher les images de l'animation
    display.display();
    delay(700);
    display.fillRect(50, 24, 26, 34, BLACK);  //effacer l'image précedente
  }
  grandeTransition();
  resetDesEtatsEtMenus();
  cycle = 1;  //Passage au cycle 1
}


void setup() {

  Serial.begin(9600);
  display.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED);

  display.clearDisplay();
  display.display();

  pinMode(btnNaviguer, INPUT_PULLUP);  //définir les boutons comme étant des entrées
  pinMode(btnValider, INPUT_PULLUP);
  pinMode(btnQuitter, INPUT_PULLUP);

  chargementSauvegarde();  //Chargement des données sauvegardées au démarrage

  melangerLesCartes();  //Mélanger les cartes pour la première fois au démarrage du programme
}




/* Dans la loop principale :
 - le cycle 0 correspond à l'éclosion de l'oeuf.
 - le cycle 1 correspond à tout le jeu du Tamagotchi.
 - le cycle 2 correspond au jeu bonus de mémoire.
 - le cycle 3 correspond au Requin qui dort.
 - et le cycle 4 correspond à la mort du Requin.
 */
void loop() {

  if (cycle == 0) {
    //cycle de l'éclosion de l'oeuf
    display.invertDisplay(true);

    if (nomStudio) {
      afficherNomStudio();
    }

    afficherDecor();
    display.drawBitmap(55, 0, soleil, 15, 15, WHITE);  //afficher le soleil
    display.drawBitmap(50, 30, oeuf, 26, 28, WHITE);   //afficher l'oeuf
    display.display();

    //Déclencher l'animation d'éclosion
    if (digitalRead(btnValider) == LOW) {
      animationEclosion();
    }

  } else if (cycle == 1) {
    // Cycle de jeu principal : gestion des états et des menus

    if (!nuit) {
      display.invertDisplay(true);
    }
    afficherDecor();
    diminutionDeLaFaim();
    augmentationDeLaFatigue();
    augmentationDeLaSalete();
    gestionDesEtats();   // Gère les différents états du personnage
    gestionDesMenus();   // Gère les menus du jeu
    conditionsDeMort();  // Vérifie les conditions de mort du personnage


    //Navigation Menus
    if (menuAccueil && !requinSommeil && positionXFleche == 19 && digitalRead(btnValider) == LOW) {  //Entrer dans le menu de nourriture
      menuAccueil = false;
      transition();
      menuNourriture = true;
    } else if (menuAccueil && !requinSommeil && positionXFleche == 45 && digitalRead(btnValider) == LOW) {  //Déclencher l'animation pour laver le requin
      requinSale = false;
      laver();
    } else if (menuAccueil && !requinSommeil && requinMalade && positionXFleche == 71 && digitalRead(btnValider) == LOW) {  //Déclencher l'animation pour soigner le requin
      requinMalade = false;
      soigner();
    } else if (menuAccueil && requinSommeil && positionXFleche == 97 && digitalRead(btnValider) == LOW) {  //Faire dormir le requin quand il a sommeil
      grandeTransition();
      cycle = 3;
    } else if (menuAccueil && !requinSommeil && !requinMalade && positionXFleche == 97 && digitalRead(btnValider) == LOW) {  //Passer à la nuit mais le requin n'a pas sommeil
      menuAccueil = false;
      requinNormal = false;
      grandeTransition();
      nuit = true;
      requinConfus = true;
    } else if (menuAccueil && !requinSommeil && positionXFleche == 123 && digitalRead(btnValider) == LOW) {  //Entrer dans le jeu de mémoire
      menuAccueil = false;
      afficherNomDuJeu();
      cycle = 2;
      display.clearDisplay();
    }

  } else if (cycle == 2) {
    // Cycle du jeu de mémoire

    // Déplacement du curseur sur les cartes si le bntNaviguer est pressé
    if (digitalRead(btnNaviguer) == LOW) {
      positionCurseur = (positionCurseur + 1) % nombreDeCartesTotal;  // Déplacer le curseur à la carte suivante
      delay(200);
    }

    // Révéler une carte si le btnValider est pressé
    if (digitalRead(btnValider) == LOW && !cartesRevelees[positionCurseur] && !cartesTrouvees[positionCurseur]) {
      cartesRevelees[positionCurseur] = true;                        // Marquer la carte comme révélée
      cartesRetournees[nombreDeCartesRetournees] = positionCurseur;  // Ajouter la carte aux cartes retournées
      nombreDeCartesRetournees++;                                    // Incrémenter le nombre de cartes retournées
      delay(200);
    }

    // Afficher les cartes
    afficherLesCartes();

    // Vérifier les cartes retournées si deux cartes ont été retournées
    if (nombreDeCartesRetournees == 2) {
      delay(500);           // Attendre pour que le joueur puisse voir la deuxième carte
      verifierLesCartes();  // Vérifier si les cartes retournées forment une paire
    }

    // Vérifier si toutes les paires ont été trouvées
    if (pairesTrouvees == nombreDePaires) {
      // Afficher le message de victoire et réinitialiser le jeu
      display.setTextSize(1);
      display.setTextColor(WHITE);
      display.setCursor(80, 0);
      display.print("You win!");
      display.display();
      delay(500);           // Attendre avant de réinitialiser
      pairesTrouvees = 0;   // Réinitialiser le nombre de paires trouvées
      melangerLesCartes();  // Mélanger les cartes pour une nouvelle partie
    }

    // Quitter le jeu de mémoire et revenir au menu principal si le btnQuitter est pressé
    if (digitalRead(btnQuitter) == LOW) {
      display.clearDisplay();
      menuAccueil = true;           // Retourner au menu principal
      display.invertDisplay(true);  // Inverser les couleurs de l'écran
      cycle = 1;                    // Revenir au cycle 1 (jeu principal)
      delay(200);
    }


  } else if (cycle == 3) {
    // Cycle de nuit : le requin dort

    afficherNuit();  // Afficher la scène de nuit
    dormir();        // Animation du requin qui dort
    afficherDecor();

    // Quitter la nuit et revenir au cycle 1 si le btnQuitter est pressé
    if (digitalRead(btnQuitter) == LOW) {
      grandeTransition();
      resetDesEtatsEtMenus();       // Réinitialiser les états et les menus
      display.invertDisplay(true);  // Inverser les couleurs pour repasser au jour

      // Déterminer aléatoirement si le requin tombe malade après le sommeil
      int chance_malade = random(1, 4);
      if (chance_malade == 1) {
        requinMalade = true;  // Si le nombre est 1, le requin tombe malade
      }

      requinSommeil = false;  // Le requin n'a plus sommeil
      requinNormal = true;    // Le requin revient à son état normal
      cycle = 1;              // Revenir au cycle 1 (jeu principal)
      delay(100);
    }

  } else if (cycle == 4) {
    // Cycle de mort du requin

    display.invertDisplay(false);  //Inverser les couleurs de l'écran en sombre
    display.clearDisplay();
    display.drawBitmap(0, 0, mort, 128, 64, WHITE);  //Afficher "vous êtes mort" à l'écran
    display.display();

    // Réinitialiser le jeu si le btnValider est pressé
    if (digitalRead(btnValider) == LOW) {
      resetDesEtatsEtMenus();  // Réinitialiser les états et les menus
      display.clearDisplay();
      display.invertDisplay(true);
      cycle = 0;  // Revenir au cycle initial (cycle 0)
      delay(200);
    }
  }
  sauvegarde();  // Sauvegarder l'état après la mise à jour
}