---
# System prepended metadata

title: Untitled

---

###### tags: jeu_jusqua_exercice6d
###==================================================================
### GESTION DES DONNEES UTILISATEUR
###==================================================================
rm(list=ls())
library(beepr)
setwd('C:/Users/marie/AOBox/S8 Conduite de projet innovant/code/version_finale_1')


###==========================================
###FONCTION : register.user
#
#Usage : enregistrement de l'utilisateur
#Argument : utilisateur, pvJoueur, dernierAxe, niveau, exercicesReussis, nbPotions, epee, armure
#Value : aucune
###===========================================

register.user<-function(utilisateur, pvJoueur, dernierAxe, niveau, exercicesReussis, nbPotions, epee, armure){
  
  data<-read.csv(file= 'sauvegarde_utilisateur.csv',
                 header=T,
                 dec=".", sep=",") 
  #on ajoute les données du nouvel utilisateur dans le dataframe data sous une nouvelle variable
  newdata<-rbind(data,data.frame(utilisateur = utilisateur, pvJoueur = pvJoueur, dernierAxe = dernierAxe, niveau = niveau, exercicesReussis = exercicesReussis, nbPotions = nbPotions, epee = epee, armure = armure))
  #on écrase l'ancien data avec newdata
  data <- newdata
  #on sauvegarde le nouveau fichier sous le fichier lu (on écrase l'ancien fichier)
  write.csv(data,"sauvegarde_utilisateur.csv",quote=F, row.names=F)
}


###==========================================
###FONCTION : utilisateur
#
#Usage : arrivée de l'utilisateur
#Argument : pseudo
#Value : un dataframe
###===========================================

utilisateur<-function(pseudo){
  data<-read.csv(file= 'sauvegarde_utilisateur.csv',
                 header=T,
                 dec=".", sep=",")
  if (pseudo %in% data$utilisateur){
    donneesUtilisateur<-subset(data,utilisateur == pseudo)
    return(donneesUtilisateur)
  }else{
    
    return("utilisateur inconnu")
  }
}


###==========================================
###FONCTION : choix.axe
#
#Usage : choix de l'axe, début de la partie
#Argument : dataframe donneesUtilisateur
#Value : l'axe choisi, ou un message d'erreur
###===========================================

#prend en argument un dataframe d'une ligne correspondant aux données utilisateur pour un utilisateur choisi
choix.axe<- function(donneesUtilisateur){
  dernierAxe <- donneesUtilisateur$dernierAxe[1]
  axe <- "choix impossible réessayez"
  while (axe == "choix impossible réessayez"){
    if (dernierAxe == 1){
      axe <- dernierAxe
      return(dernierAxe)
    }else{
      print(paste("Vous avez atteint l'axe", dernierAxe))
      print("0 : pour refaire un axe deja fait, 1 : pour faire un nouvel axe")
      choix1 <- as.integer(readline("Que choisi-tu de faire?"))
  
      if (choix1 == 1){
        axe <- dernierAxe + 1
        if (axe > 6){
          axe <- "choix impossible réessayez"
          return ("choix impossible réessayez")
        }else{
          return(axe)
        }
        
      }else if (choix1 == 0){
        choix2<- as.integer(readline("Choisir le numero d'axe a étudier parmi les axes deja faits"))
        if ((choix2 > dernierAxe) | (choix2 == 0)){
          axe <- "choix impossible réessayez"
          print("choix impossible réessayez")
        }else{
          axe <- choix2
          return(axe)
        }
      }else{
        axe <- "choix impossible réessayez" 
        return("choix impossible réessayez")
      }
    }
  }
}

###==========================================
###FONCTION : choix.difficulte
#
#Usage : choix de la difficulté, début de la partie
#Argument : aucun
#Value : la difficulté choisie ou un message d'erreur
###===========================================

choix.difficulte <- function(){
  print("Quelle difficulté veux-tu pour cet axe? ")
  niveauDifficulte <- 0
  while (niveauDifficulte != 1|2|3|4|5){
    niveauDifficulte <- readline("1 (très difficile), 2 (difficile), 3 (modéré), 4 (facile) ou 5 (très facile) ")
    if (niveauDifficulte == 1){
      return(nbEssai <- 1)
    }
    if (niveauDifficulte == 2){
      return(nbEssai <- 2)
    }
    if (niveauDifficulte == 3){
      return(nbEssai <- 3)
    }
    if (niveauDifficulte == 4){
      return(nbEssai <- 4)
    }
    if (niveauDifficulte == 5){
      return(nbEssai <- 5)
    }
    else{
      print("Le niveau de difficulté choisi n'existe pas, recommence")
    }
  }
}

###==========================================
###FONCTION : modif.sauvegarde
#
#Usage : permet de modifier le fichier sauvegarde_utilisateur
#Argument : utilisateur, newPvJoueur, dernierAxe, newNiveau, exercicesReussis, newNbPotions, epee, armure
#Value : aucune
###===========================================

modif.sauvegarde<-function(utilisateur, newPvJoueur, dernierAxe, newNiveau, exercicesReussis, newNbPotions, epee, armure){
  data<-read.csv(file= 'sauvegarde_utilisateur.csv',
                 header=T,
                 dec=".", sep=",")
  
  #recup indice ligne utilisateur
  i=1
  while (data$utilisateur[i]!= utilisateur){
    i=i+1
  }
  
  data$pvJoueur[i]<- newPvJoueur
  data$dernierAxe[i]<-dernierAxe
  data$niveau[i]<-newNiveau
  data$exercicesReussis[i]<-exercicesReussis
  data$nbPotions[i]<- newNbPotions
  data$epee[i]<-epee
  data$armure[i]<-armure
  
  
  write.csv(data,"sauvegarde_utilisateur.csv",quote=F, row.names=F)
  
}

###==========================================
###FONCTION : modif.sauvegarde
#
#Usage : principale sauvegarde
#Argument : aucun
#Value : 
###===========================================

choix.partie<-function(){
  
  #intialisation paramètres
  initPvJoueur<-100
  initDernierAxe<-1
  initNiveau<-1
  initExercicesReussis<-0
  initNbPotions<-1
  initEpee<-10
  initArmure<-5
  
  reponse<-readline ("As-tu une partie en cours ? (oui/non)  ")
  if ((reponse == "oui") || (reponse=="Oui") || (reponse=="OUI")){
    votreUtilisateur <- readline ("Entre ton pseudo  ")
    donneesUtilisateur <- utilisateur(votreUtilisateur)
    
    if (class(donneesUtilisateur) != "data.frame"){
      print("Tu n'es pas enregistré")
      register.user(votreUtilisateur, initPvJoueur, initDernierAxe, initNiveau, initExercicesReussis, initNbPotions, initEpee, initArmure)
      donneesUtilisateur <- utilisateur(votreUtilisateur)
      #axe<-initDernierAxe
    }
    #else{
    #   axe<-choix.axe(donneesUtilisateur)
    #   while (axe == "choix impossible réessaye"){
    #     axe<-choix.axe(donneesUtilisateur)
    #   }
    #   if (axe >= donneesUtilisateur$dernier_axe[1]){
    #     modif.sauvegarde(user, donneesUtilisateur$pv_joueur[1], axe, donneesUtilisateur$niveau[1], donneesUtilisateur$exercices_reussis[1], donneesUtilisateur$nb_potions[1], donneesUtilisateur$epee[1], donneesUtilisateur$armure[1])
    #   }else{
    #     modif.sauvegarde(user, donneesUtilisateur$pv_joueur[1], donneesUtilisateur$dernier_axe[1], donneesUtilisateur$niveau[1], donneesUtilisateur$exercices_reussis[1], donneesUtilisateur$nb_potions[1], donneesUtilisateur$epee[1], donneesUtilisateur$armure[1])
    #   }
    # }
  }else if ((reponse == "non") || (reponse=="NON") || (reponse=="Non")){
    votreUtilisateur<-readline("Choisis ton pseudo ")
    donneesUtilisateur <- utilisateur(votreUtilisateur)
    if (class(donneesUtilisateur)!= "data.frame"){
      register.user(votreUtilisateur, initPvJoueur, initDernierAxe, initNiveau, initExercicesReussis, initNbPotions, initEpee, initArmure)
      #axe<-initDernierAxe
      donneesUtilisateur <- utilisateur(votreUtilisateur)
    }else{
      print("Tu as déjà une partie en cours ou le pseudo est déjà pris, si c'est le cas, appuye sur la touche Entrer")
      # axe<-choix.axe(donneesUtilisateur)
      # while (axe == "Choix impossible réessaye"){
      #   axe<-choix.axe(donneesUtilisateur)
      # }
      # if (axe >= donneesUtilisateur$dernier_axe[1]){
      #   modif.sauvegarde(user, donneesUtilisateur$pv_joueur[1], axe, donneesUtilisateur$niveau[1], donneesUtilisateur$exercices_reussis[1], donneesUtilisateur$nb_potions[1], donneesUtilisateur$epee[1], donneesUtilisateur$armure[1])
      # }else{
      #   modif.sauvegarde(user, donneesUtilisateur$pv_joueur[1], donneesUtilisateur$dernier_axe[1], donneesUtilisateur$niveau[1], donneesUtilisateur$exercices_reussis[1], donneesUtilisateur$nb_potions[1], donneesUtilisateur$epee[1], donneesUtilisateur$armure[1])
      # }
    }
  }else{
    print ("Choix impossible, réessaye")
    choix.partie()
  }
  
  print ("C'est parti !")
  return (donneesUtilisateur)
}

###==========================================
###FONCTION : scenario
#
#Usage : squelette principal du jeu
#Argument : aucun
#Value : aucun
###===========================================
scenario <- function(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau){
  
  ### Si on a fini un nouveau Axe on l'ajoute dans dernierAxe
  if (niveau > dernierAxe){
    dernierAxe <- niveau
  }
  
  ### On remet les pv a 100 + on remet bien en ordre les variables
  donneesUtilisateur$pvJoueur[1] <- 100
  pvJoueur <- 100
  donneesUtilisateur$dernierAxe[1] <- dernierAxe
  donneesUtilisateur$epee[1] <- derniereEpee
  donneesUtilisateur$armure[1] <- derniereArmure
  donneesUtilisateur$nbPotions[1] <- dernieresPotions
  
  ### Choix de l'axe par l'utilisateur = axeChoisi = niveau
  axeChoisi<-choix.axe(donneesUtilisateur)
  
  if ((axeChoisi != 1)&&(axeChoisi != 2)&&(axeChoisi != 3)&&(axeChoisi != 4)&&(axeChoisi != 5)&&(axeChoisi != 6)){
  print(paste("vous devez mettre un chiffre compris entre 1 et ",dernierAxe," merci de reessayer"))
  axeChoisi<-choix.axe(donneesUtilisateur)
  }
  
  if (axeChoisi != 1){
    ### On demande si l'axe choisi convient à l'utilisateur
    print(paste("Tu as choisi l'axe ",axeChoisi,", le thème est ",jeu$theme[axeChoisi],
              "avec le boss",jeu$Boss[axeChoisi],". Les notions à voir ici sont ",jeu$notion[axeChoisi]))
    print("Es-tu sûr de vouloir choisir cet axe? -> Mettre OUI ou NON")
    choisirAxeOuPas <- readLines(n=1)
    ### Si le scénario ne convient pas, on laisse l'utilisateur choisir à nouveau
    if ((choisirAxeOuPas == "NON") || (choisirAxeOuPas == "Non") || (choisirAxeOuPas == "non")){
      modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau,
                       donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
      scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau)
    }
  }else{
    print(paste("Tu es dans l'axe ",axeChoisi,", le thème est ",jeu$theme[axeChoisi],
                "avec le boss",jeu$Boss[axeChoisi],". Les notions à voir ici sont ",jeu$notion[axeChoisi]))
  }
  
  niveau <- axeChoisi
  
  ### Difficulté du jeu à choisir = nb de coup d'essai :
  
   nbEssai <- choix.difficulte()

  ### On enchaîne les différents exos du scénario, pas de pv perdu là dedans, juste des essais
  ### si on n'arrive pas avec essais, on refait le scenario
  resultatChemin <- chemin(axeChoisi, nbEssai)
  
  ### EXERCICES CHEMIN RATES
  ### Si les exercices du chemin n ont pas ete reussis :
  if (resultatChemin == FALSE){
    ### Le joueur perd tous ses pv
    donneesUtilisateur$pvJoueur[1] <- 0
    ### Après avoir raté, on s'arrete ou pas ? (sans oublier de faire la sauvegarde)
    print("Veux-tu continuer? -> mettre OUI ou NON")
    continuerOuPas = readLines(n=1)
    if ((continuerOuPas == "OUI") || (continuerOuPas == "Oui") || (continuerOuPas == "oui")){
      modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau,
                       donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
      scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau)
    }
    if ((continuerOuPas == "NON") || (continuerOuPas == "Non") || (continuerOuPas == "non")){
      modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau,
                       donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
      return("A bientôt !")
    }
    scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau)
  }
  
  ### EXERCICES CHEMIN REUSSIS
  ### Si axe 1, pas de boss : 
  if (axeChoisi == 1){
    print("Felicitation, tu as réussi tous les exercices qui étaient placés sur ton chemin !")
  }
  
  # print(paste("dernierAxenum7",dernierAxe))
  
  ### Si axe 2, 3, 4, 5 ou 6, place au boss :
  if (axeChoisi != 1){
    ### On arrive ensuite au boss, possibilité de mort donc on refait l'axe
    print("Félicitation, tu as réussi tous les exercices qui étaient placés sur ton chemin ! Maintenant, place au Boss !")
    resultatFinal <- combat.boss(axeChoisi,derniereEpee,derniereArmure,dernieresPotions)
    dernieresPotions <- donneesUtilisateur$nbPotions[1] ### On remet la variable au cas où des potions ont ete utilisees
    ### SI BOSS PAS VAINCU :
    ### Si on meurt on retourne au choix de scénario + on remet pv
    if (resultatFinal != TRUE){ 
      jeu$pvMonstre[axeChoisi] <- 100
      ### Après avoir raté, on s'arrete ou pas
      print("Veux-tu continuer? -> mettre OUI ou NON")
      continuerOuPas = readLines(n=1)
      if ((continuerOuPas == "OUI") || (continuerOuPas == "Oui") || (continuerOuPas == "oui")){
        modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau,
                         donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
        scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau)
      }
      if ((continuerOuPas == "NON") || (continuerOuPas == "Non") || (continuerOuPas == "non")){
        modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau,
                         donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
        return("A bientôt !")
      }
      scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau)
    }
    ### SI BOSS VAINCU : 
    ### Message si le boss est vaincu
    message.boss.mort(axeChoisi)
    ### Si réussi, on choisit un nouveau axe + on remet les pv + on choisit arme et armure
    ### On change d'arme
    print("Félicitation, tu as vaincu le boss, tu as gagné une épée, une armure et une potion ! :) ")
    print(paste("L'épée a ",jeu$epee[axeChoisi], "d'attaque, et la tienne ",donneesUtilisateur$epee[1]))
    print("Veux-tu équiper l'épée? -> mettre OUI ou NON")
    epeeOuPas = readLines(n=1)
    if ((epeeOuPas == "OUI") || (epeeOuPas == "Oui") || (epeeOuPas == "oui")){
      donneesUtilisateur$epee[1] <- jeu$epee[axeChoisi]
      derniereEpee <- jeu$epee[axeChoisi]
    }
    ### On change d'armure
    print(paste("L'armure a ",jeu$armure[axeChoisi], "de défense, et la tienne ",donneesUtilisateur$armure[1]))
    print("Veux-tu équiper l'armure? -> mettre OUI ou NON")
    armureOuPas = readLines(n=1)
    if ((armureOuPas == "OUI") || (armureOuPas == "Oui") || (armureOuPas == "oui")){
      donneesUtilisateur$armure[1] <- jeu$armure[axeChoisi]
      derniereArmure <- jeu$armure[axeChoisi]
    }
    ### On gagne une potion
    print(paste("Il te reste ",dernieresPotions, "potions"))
    print("Veux-tu ramasser la potion? -> mettre OUI ou NON")
    potionOuPas = readLines(n=1)
    if ((potionOuPas == "OUI") || (potionOuPas == "Oui") || (potionOuPas == "oui")){
      donneesUtilisateur$nbPotions[1] <- donneesUtilisateur$nbPotions[1] + 1
      dernieresPotions <- dernieresPotions + 1
    }
    ### On reprend les pv
    jeu$pvMonstre[axeChoisi] <- 100
  }
  
  # print(paste("dernierAxenum9",dernierAxe))
  
  ### On choisit un autre axe ou on arrête 
  print("Veux-tu continuer? -> mettre OUI ou NON")
  continuerOuPas = readLines(n=1)
  if ((continuerOuPas == "OUI") || (continuerOuPas == "Oui") || (continuerOuPas == "oui")){
    modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau+1,
                     donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
    scenario(dernierAxe,pseudo,donneesUtilisateur,derniereEpee,derniereArmure,dernieresPotions,niveau+1)
  }
  if ((continuerOuPas == "NON") || (continuerOuPas == "Non") || (continuerOuPas == "non")){
    modif.sauvegarde(pseudo, donneesUtilisateur$pvJoueur[1],dernierAxe, niveau+1,
                     donneesUtilisateur$exercicesReussis[1], dernieresPotions, derniereEpee, derniereArmure)
    return("Bravo, tu as fini l'axe ! A bientôt !")
  }
}


###==========================================
###FONCTION : chemin
#
#Usage : squelette des exercices du chemin de l'axe choisi
#Argument : axeChoisi, nbEssai
#Value : TRUE ou FALSE
###===========================================

chemin <- function(axeChoisi, nbEssai){
  i <- 1
  resultatPtitExo = TRUE
  
  ### Tant que le perso réussit + qu'il n'a pas fait tous les exos
  while ((resultatPtitExo == TRUE) && (i <= jeu$nbExoChemin[axeChoisi])){ 
    resultatPtitExo <- exercice.chemin(axeChoisi, i, nbEssai) ### on appelle l'exercice
    i <- i + 1
  }

  ### On vérifie si le dernier exo était réussi = tous réussis
  if (resultatPtitExo == TRUE){
    return (TRUE)
  }else{
    return (FALSE)
  }
}

###==========================================
###FONCTION : exercice.chemin
#
#Usage : regroupe tous les exercices de chemin
#Argument : axe de l'exercice, numéro de l'exercice,nombre d'essai
#Value : TRUE ou FALSE
###===========================================

exercice.chemin <- function(axe, num, nbEssai){
  if (axe == 1){
    if (num == 1){
      resultatChemin <- exercice1a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice1b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice1c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice1d(nbEssai)
    }
    if (num == 5){
      resultatChemin <- exercice1e(nbEssai)
      premierAxeReussi <- resultatChemin
    }
  }
  if (axe == 2){
    if (num == 1){
      resultatChemin <- exercice2a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice2b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice2c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice2d(nbEssai)
    }
    if (num == 5){
      resultatChemin <- exercice2e(nbEssai)
    }
    if (num == 6){
      resultatChemin <- exercice2f(nbEssai)
    }
    if (num == 7){
      resultatChemin <- exercice2g(nbEssai)
    }
    if (num == 8){
      resultatChemin <- exercice2h(nbEssai)
    }
    if (num == 9){
      resultatChemin <- exercice2i(nbEssai)
    }
    if (num == 10){
      resultatChemin <- exercice2j(nbEssai)
    }
    if (num == 11){
      resultatChemin <- exercice2k(nbEssai)
    }
    if (num == 12){
      resultatChemin <- exercice2l(nbEssai)
    }
    if (num == 13){
      resultatChemin <- exercice2m(nbEssai)
    }
    if (num == 14){
      resultatChemin <- exercice2n(nbEssai)
    }
  }
  if (axe == 3){
    if (num == 1){
      resultatChemin <- exercice3a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice3b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice3c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice3d(nbEssai)
    }
    if (num == 5){
      resultatChemin <- exercice3e(nbEssai)
    }
    if (num == 6){
      resultatChemin <- exercice3f(nbEssai)
    }
    if (num == 7){
      resultatChemin <- exercice3g(nbEssai)
    }
    if (num == 8){
      resultatChemin <- exercice3h(nbEssai)
    }
    if (num == 9){
      resultatChemin <- exercice3i(nbEssai)
    }
    if (num == 10){
      resultatChemin <- exercice3j(nbEssai)
    }
    if (num == 11){
      resultatChemin <- exercice3k(nbEssai)
    }
    if (num == 12){
      resultatChemin <- exercice3l(nbEssai)
    }
    if (num == 13){
      resultatChemin <- exercice3m(nbEssai)
    }
  }
  if (axe == 4){
    if (num == 1){
      resultatChemin <- exercice4a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice4b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice4c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice4d(nbEssai)
    }
    if (num == 5){
      resultatChemin <- exercice4e(nbEssai)
    }
    if (num == 6){
      resultatChemin <- exercice4f(nbEssai)
    }
    if (num == 7){
      resultatChemin <- exercice4g(nbEssai)
    }
    if (num == 8){
      resultatChemin <- exercice4h(nbEssai)
    }
    if (num == 9){
      resultatChemin <- exercice4i(nbEssai)
    }
  }
  if (axe == 5){
    if (num == 1){
      resultatChemin <- exercice5a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice5b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice5c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice5d(nbEssai)
    }
    if (num == 5){
      resultatChemin <- exercice5e(nbEssai)
    }
    if (num == 6){
      resultatChemin <- exercice5f(nbEssai)
    }
    if (num == 7){
      resultatChemin <- exercice5g(nbEssai)
    }
    if (num == 8){
      resultatChemin <- exercice5h(nbEssai)
    }
  }
  if (axe == 6){
    if (num == 1){
      resultatChemin <- exercice6a(nbEssai)
    }
    if (num == 2){
      resultatChemin <- exercice6b(nbEssai)
    }
    if (num == 3){
      resultatChemin <- exercice6c(nbEssai)
    }
    if (num == 4){
      resultatChemin <- exercice6d(nbEssai)
    }
  }
  return (resultatChemin)
}

  


###==========================================
###EXERCICES DES CHEMIN DE L'AXE 1
###==========================================
## Exercice  maitriser l'environnement: 


exercice1a<-function(vie){
  cat("Tu ouvres doucement les yeux et tu vois la lumière du soleil qui passe à travers les feuilles des arbres au-dessus de ta tête. Tu ne comprends pas vraiment où tu es mais tu es allongé dans l'herbe.
Tu as l'impression d'être dans un monde qui n'est pas le tien, un jeu vidéo ou quelque chose comme ça.
Tu fouilles dans ta poche et n'en sort pas ton téléphone mais des objets qui te paraissent familier du jeu Pokémon ... Un pokédex et un pokébip !

Le pokébip se met à énoncer un message vocal : 'Avant de commencer votre aventure, dresseur, la première étape est de maîtriser votre environnement, nous allons donc tester votre connaissance'.
Où se trouvent les éléments suivants: console, éditeur de commande, les objets créés et les graphiques ?
Sachant que 1: gauche-haut, 2:gauche-bas, 3:droite-haut, 4:droite-bas.

Entre une séquence de nombre en respectant l'ordre des éléments (ex: 1234)")
  reponse <- readline("Quelle est votre réponse ? ")
  while(vie > 0){
    if (reponse == 2134){
      beep(5)
      cat("'Bravo ! C'était la bonne réponse ! tu es maintenant prêt à commencer ton aventure !'. Tu décides donc
  d'avancer dans ce monde nouveau.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu as échoué dans la maîtrise de l'environnement, le pokébip s'éteint, impossible de
  le rallumer et donc de se guider dans ce monde.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: la séquence commence par 2.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

# type d'exercice: l'utilisateur doit entrer une réponse (le nom d'une fonction); si bonne réponse retour d'un son de victoire 

exercice1b <- function(vie){
  cat("Tu continues ta route quand soudain, tu croises un petit pokémon rond et rose, 
remplis la fonction de ton pokédex qui peut t'aider à connaître son nom :
???(name)")
  reponse <- readline(prompt="Entre ta réponse: ")
  while (vie > 0) {
    if ((reponse == "help") | (reponse == "?")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! c'est un rondoudou, pokémon de type normal et fée, tu décides de prendre au sérieux cette aventure dans laquelle tu t'es réveillé et que ça te changera de ta routine habituelle !
Tu commences à prendre la route 4.")
      return(TRUE)
    }
    vie <- vie-1
    beep(9)
    if (vie == 0){
      cat("Tu n'as pas réussi à te servir de ton pokédex, le pokémon s'est enfui !")
      return (FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: tu peux utiliser une ponctuation. ")
    reponse<-readline("Quelle est ta nouvelle réponse ? ")
  }
}

# type d'exercice :l'utilisateur doit entrer sa réponse (saisir du code); si bonne réponse retour d'un son de victoire ; sinon retour d'un son de défaite ; nombre d'essai pour l'exo = 3)

exercice1c <- function(vie){
  cat("Tu tombes face à 2 pokémons se battant l'un contre l'autre sur la route 4, il te faut commenter
le combat sans te faire repérer sous peine d'interrompre leur combat.
Quelle commande de ton pokébip utilises-tu ?
'#' , 'comment()' ou '/' ? ")
  reponse1 <- readline(prompt="Entre ta réponse: ")
  while (vie >= 0){
    if (reponse1 == "#"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu ne rates pas une miette du combat, un pokémon commence à prendre l'ascendant mais le second utilise l'attaque et le met K.O en un seul coup !")
      break
    }else{
      vie <- vie - 1
      beep(9)
      if (vie == 0){
        cat("Il te fallait utiliser la taper  # sur ton pokebip. Les pokémons te repèrent et s'enfuient.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : Il sert aussi en musique ")
      reponse1 <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
  cat("
Il te faut afficher un graphique des statistiques du vainqueur sur ton pokédex, complète la fonction de ton pokédex,
tu ne sais pas comment te servir de cette fonction, comment découvrir comment s'en servir ? 
Complète la fonction suivante :
???(boxplot)")
  reponse2 <- readline(prompt="Entre ta réponse: ")
  while (vie >= 0){
    if ((reponse2 == "?") | (reponse2 == "help")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Ce pokémon a de très bonnes statistiques d'attaque et d'attaque spé, mais de mauvaises statistiques 
de défense et défense spé, ce qui explique le KO qu'il a pu faire en un coup. Tu profites qu'il soit affaibli pour lui
lancer une pokéball qui se trouvait dans ton sac. 1 . 2 . et 3 ! Tu as capturé le pokémon qui est un Carapuce !")
      return(TRUE)
    }else{
      vie <- vie - 1
      beep(9)
      if (vie == 0){
        cat("La fonction du pokédex à utiliser était ?boxplot ou help(boxplot).")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !  INDICE: tu peux utiliser une ponctuation. ")
      reponse2 <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice1d <- function(vie) {
  cat("Afin de découvrir ce monde, tu décides d'apprendre 
à ton Carapuce la CS Surf. Remplis le code suivant pour installer la CS03 Surf :
???.packages('CS03'')")
  reponse <- readline(prompt="Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "install") {
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as réussi à apprendre Surf à ton carapuce, tu vas désormais pouvoir explorer ce monde !")
      return (TRUE)
    }else{
      vie <- vie - 1
      beep(9)
      if (vie == 0){
        cat("Tu n'as pas réussi à apprendre Surf à ton carapuce, ce dernier pense que c'est sa faute
et s'enfuit de honte. Tu n'as plus de pokémon, tu ne peux pas continuer l'aventure.")
        return (FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : il s'agit bien d'INSTALLER")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## Question working directory
# type d'exercice: l'utilisateur doit entrer une réponse ; si bonne réponse retour d'un son de victoire

exercice1e <- function(vie){
  cat("Tu décides d'utiliser Surf avec ton carapuce pour aller dans ton dossier par défaut, malheureusement tu ne te rappelles
plus de son emplacement dans ton pokébip. Quelle commande utiliser pour retrouver son emplacement ?")
  reponse <- readline("Entre ta réponse: ")
  while (vie > 0){ # L'exercice se termine quand le joueur n'a plus de vie
    if (reponse == "getwd()"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Carapuce a pu retrouver le dossier par défaut. Tu continues ta route et arrive
dans un petit village, tu aperçois un vieux sage au loin.")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Tu n'as pas réussi à trouver le dossier défaut.. Carapuce s'est perdu en chemin et t'a quitté pour toujours.
Tu n'as plus de pokémon, tu ne peux pas continuer l'aventure.")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : Il s'agit d'une fonction")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


###==========================================
###EXERCICES DES CHEMIN DE L'AXE 2
###==========================================
# type d'exercice: l'utilisateur doit entrer une réponse ; si bonne réponse retour d'un son de victoire

exercice2a <- function(vie){
  cat("Dresseur, Dresseur. Oui c'est bien à toi que je m'adresse.
Approche, approche.
Nous avons besoin d'un aventurier pour nous aider à stopper Kirby.
Il s'agit du pokémon légendaire de notre cité.
Mais mais.... depuis 2 mois maintenant Kirby a un comportement étrange..
Il souffle sur nos maisons et attaque notre cité...
Aide-nous à comprendre ce qui ne va pas et nous vous récompenserons.
Le comportement de Kirby est liée à l'objet légendaire: kirbybox (un dataframe).
Il vous faudra d'abord le créer en suivant les instructions suivantes: il doit contenir 4 compartiment (colonnes).
Les compartiments devront s'appeler energie, bonheur,colere,faim et contenir 4 cases dont la valeur doit être 10.

Complète la ligne de code suivante en séparant tes réponses par une virgule : 
???(???=rep(10,4),???=rep(10,4),???=rep(10,4),???=rep(10,4))")
  reponse <- readline("Entre ta réponse :  ")
  while (vie > 0){
    if (reponse=="data.frame,energie,bonheur,colere,faim"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Mais ne te réjouis pas trop rapidement ....")
      return (TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à créer le dataframe, tu ne pourras donc pas y accéder, kirby te souffle très loin.")
        return (FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: voici le début : data.frame,...")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

# manipulation de dataframe

exercice2b <- function(vie){
  cat("Il faut maintenant regarder le contenu du compartiment bonheur de la 'kirbybox', comment y accéder ?")
  reponse <- readline("Entre ta réponse : ") 
  while (vie > 0) {
    if ((reponse=="kirbybox$bonheur")|(reponse=="kirbybox[,2]")|(reponse=="kirbybox[,'bonheur']")|(reponse=='kirbybox[,"bonheur""]')){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Le compartiment bonheur était corrompu, tu fais ton possible pour le rétablir à la normale....")
      return (TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à accéder au bonheur de Kirby, tu ne comprends pas le problème, Kirby t'aspire et t'avale.")
        return (FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: voici le début d'une réponse possible : kirbybox$....")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

# manipulation de dataframe

exercice2c <- function(vie){
  cat("Tu te rends compte que la 4e ligne pose problème pour cela tu vas maintenant supprimer la 4ème case (ligne) ") 
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "kirbybox[-4,]"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Après avoir supprimé la 4e ligne, Kirby reprend ses esprits. Il te remercie et t'explique que le roi Dadidou
  lui a lancé une malédiction, et c'est ce pourquoi il était incontrôlable. Il décide de mettre fin au danger que 
  ce dernier représente et te demande de l'accompagner dans son aventure et t'emmène dans une autre dimension.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à soigner Kirby, ce dernier t'aspire et t'avale avant que tu ne puisses réagir.")
        return (FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: voici la formulation: kirbybox<-kirbybox[-?,]")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur affectation de variable
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2d <- function(vie){
  cat("Te voici maintenant dans l'univers de Kirby ! LA première tâche que Kirby te demande est de lui préparer à manger et de lui faire une pizza.
Pour lui donner à manger, tu dois affecter à la variable 'Repas' la nourriture 'Pizza'.
Que dois-tu écrire pour que Kirby puisse manger de la Pizza ?")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == 'Repas <- "Pizza"' | reponse == 'Repas = "Pizza"' | reponse == "Repas <- 'Pizza'" | reponse == "Repas = 'Pizza'"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Kirby a pu déguster la merveilleuse pizza que tu lui as préparé. Tu peux continuer ta route.")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Faux ! Ce n'est pas cette commande qu'il faut rentrer dans la console..
Tu n'as plus de points de vie.. Kirby n'est pas content, t'avale, et te recrache très loin..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: fais attention à la classe de 'Pizza' et au signe à utiliser..")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## Question sur la gestion de variable
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2e <- function(vie){
  cat("Sur le chemin tu croises Metal Knight qui te défie au combat ! Kirby a besoin de toi ! Il doit savoir quelle est la classe d'arme de Metal Knight afin de le battre.
Pour l'aider, tu dois deviner la classe de la variable 'Arme'.")
  reponse1 <- readline("Quelle commande dois-tu rentrer ? ")
  while (vie > 0){
    if (reponse1 == "class(Arme)"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Kirby a pu deviner la classe de l'arme de Metal Knight.
Maintenant Kirby aimerait changer la classe de l'arme de Metal Knight afin de la rendre inoffensive, il veut que la classe devienne 'numeric'.")
      break
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Kirby n'est pas content, t'avale, et te recrache très loin..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : C'est une fonction qu'il faut utiliser..")
      reponse1<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
  reponse2 <- readline("Quelle commande dois-tu rentrer pour changer la classe de la variable 'Arme' en 'numeric'? ")
  while (vie>0){
    if (reponse2 == "as.numeric(Arme)"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Kirby a pu changer la classe de l'arme de Metal Knight.
Metal Knight est vaincu, tu peux continuer ton aventure.")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Kirby n'est pas content, t'avale, et te recrache très loin..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : c'est une fonction de conversion qu'il faut utiliser..")
      reponse2<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur les vecteurs
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2f <- function(vie){
  cat("Kirby a encore faim et aimerait commander à manger, pour se faire il prépare une liste de courses.
Kirby te demande combien d'éléments y a-t-il dans le vecteur 'Courses'.")
  reponse <- readline("Quelle commande dois-tu rentrer ? ")
  while(vie > 0){
    if (reponse == "length(Courses)"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Kirby sait maintenant combien de choses il va acheter.
Voici le vecteur 'Courses' : c('A1', 'A2', 'A3'). Kirby aimerait maintenant que ce vecteur devienne : c('Aliment1', 'Aliment2', 'Aliment3').")
      break
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Kirby n'est pas content, t'avale, et te recrache très loin..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : c'est une fonction à 3 arguments qu'il faut utiliser..")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
  reponse2 <- readline("Quelle commande dois-tu rentrer pour modifier le vecteur 'Courses' ? ")
  while(vie>0){
    if (reponse2 == "gsub('A','Aliment',Courses)" | reponse2 == 'gsub("A","Aliment",Courses)'){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Kirby a pu changer sa liste de courses.
La liste de courses est finie, maintenant Kirby va pouvoir aller s'acheter de quoi se remplir le ventre !")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Kirby n'est pas content, t'avale, et te recrache très loin..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : c'est une fonction de remplacement qu'il faut utiliser..")
      reponse2<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur les listes
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2g<-function(vie){
  cat("Kirby doit se remémorer tout ce qu'il a mangé de ses courses. 
Il faut que tu l'aides à s'en souvenir en faisant une liste.
Devant toi il avale : une 'banane', une 'tortue', une 'PrincesseRose' qui 
passait par là, le chiffre '2', la réponse 'D'.")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "list('banane','tortue','PrincesseRose',2,'D')" | reponse == 'list("banane","tortue","PrincesseRose",2,"D")'){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi, 
Kirby se souvient de ce qu'il a pu avaler ... il est pris d'un remord soudain.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby n'arrive pas à 
se souvenir de ce qu'il a mangé, il est tellement énervé qu'il t'avale.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : Pense à utiliser des guillemets autour de certains éléments de la liste.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur les factors
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2h<- function(vie){
  cat("Kirby a encore besoin de toi, il a noté dans un facteur 'miam' le nombre de gâteaux et le nombre de tortues
qu'il a mangé. Le problème c'est que pour que sa digestion se passe bien, il doit toujours manger plus de 
gâteaux que de tortues.
Quelle fonction te permettrait de savoir combien de chaque il a mangé dans le facteur 'miam'?")
  reponse <- readline(prompt="Entre ta réponse : ")
  while(vie>0){
    if (reponse == "summary(miam)"){
      beep(5)
      cat("18 tortues et 1729 gâteaux .... Je crois que le compte est bon !")
      return(TRUE)
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Kirby commence à avoir des troubles d'estomac, et te mange pour calmer ses maux.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! 
INDICE : Il faut utiliser une fonction qui te renvoie des informations sur un dataframe")
    reponse <- readline("Quelle est ta nouvelle réponse ? ")
  }
}

## Nombre de dimensions d'une matrice
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire

exercice2i <- function(vie){
  cat("Kirby à l'habitude de voyager à travers les dimensions, mais un objet lui pose problème : 
Kirby se demande combien de dimensions contient une matrice 'matrix' ? ")
  reponse <- readline(prompt="Entre ta réponse : ")
  while(vie >= 0){
    if (reponse == 2){
      beep(5)
      cat("Kirby se rappelle grâce à toi qu'il y a 2 dimensions, il trouve ça vraiment léger.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Kirby s'énerve et décide de t'engloutir dans une dimension annexe.")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE : Le chiffre n'est pas très élevé.")
        reponse <- readline("Quelle est ta nouvelle réponse ? ")
      }
    }
  }
}


## Contraintes de mode pour les éléments d'une matrice
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire

exercice2j<-function(vie){
  cat("Kirby a avalé Julien Leperse, c'est l'heure du 'Qui veut gagner des repas' !!!
Kirby Leperse te demande : Quelle est la principale différence entre les matrices et les dataframes ?
	      1 : Les matrices contiennent uniquement des éléments de même mode, les dataframes pas forcément
        2 : Les dataframes contiennent uniquement des éléments de même mode, les matrices pas forcément")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == 1){
      beep(5)
      cat("'Ah oui oui oui oui oui !' 
Tu gagnes une fraise.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby Leperse n'est pas content, 
il décide que tu ne l'accompagneras pas pour la suite de l'aventure.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## Remplissage d'une matrice
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire

exercice2k<-function(vie){
  cat("2e étape du 'Qui veut gagner des repas' !
Kirby Leperse te demande : En tapant mat<-matrix(c(1:6), nrow=3, byrow=T), j'obtiens une matrice :
                 1 : de 3 lignes, 2 colonnes et la première ligne contient 1 et 4
                 2 : de 3 colonnes, 2 lignes et la première ligne contient 1, 3 et 5
                 3 : de 3 lignes, 2 colonnes et la première ligne contient 1 et 2
                 4 : de 3 colonnes, 2 lignes et la première ligne contient 1,2 et 3")
  reponse <- readline(prompt="Entre ta réponse : ")
  while(vie >= 0){
    if (reponse == 3){
      beep(5)
      cat("Ah oui oui oui oui oui ! Tu gagnes un raisin.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby Leperse n'est pas content, 
il décide que tu ne l'accompagneras pas pour la suite de l'aventure.")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE : Réfléchis à l'utilité de 'byrow=T'")
        reponse <- readline("Quelle est ta nouvelle réponse ? ")
      }
    }
  }
}



## Création d'une matrice vide
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire

exercice2l<-function(vie){
  cat("3e étape du 'Qui veut gagner des repas' !
Kirby Leperse te demande : Quelle proposition code une matrice vide de 6 lignes et 2 colonnes ?
  1 : mat0=matrix(c(1:10), ncol=2, nrow=6)
  2 : mat0=matrix(ncol=6, nrow=2)
  3 : mat0=matrix(ncol=2, nrow=6)")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == 3){
      beep(5)
      cat("'Ah oui oui oui oui oui !' 
Tu gagnes une boulette de riz.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby Leperse n'est pas content, 
il décide que tu ne l'accompagneras pas pour la suite de l'aventure.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Renommer les lignes et colonnes d'une matrice
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire

exercice2m<- function(vie){
  cat("4e étape du 'Qui veut gagner des repas' !
Quelle proposition permet de renommer les colonnes en Nom et Age, et les lignes en Individu 1, Individu 2 et Individu 3 ? 
       1 : colnames(mat1)<-c('Nom', 'Age') rownames(mat1)<-c('Individu1', 'Individu2', 'Individu3')
       2 : colnames<-'Nom', 'Age' rownames(mat1)<-'Individu1', 'Individu2', 'Individu3'")
  reponse <- readline(prompt="Entre ta réponse : ")
  while(vie >= 0){
    if (reponse == 1){
      beep(5)
      cat("Ah oui oui oui oui oui ! Tu gagnes un plateau de sushis.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby Leperse n'est pas content, 
il décide que tu ne l'accompagneras pas pour la suite de l'aventure.")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas !")
        reponse<-readline("Quelle est ta nouvelle réponse ? ")
      }
    }
  }
}

## Dimensions et manipulations de matrice
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire

exercice2n<-function(vie){
  cat("5e et ultime étape du 'Qui veut gagner des repas' !!
Comment sélectionner : la troisième ligne, puis la colonne b, puis l'élément situé dans la première ligne, cinquième colonne de la matrice mat ?
  1 : mat[,3] puis mat['b',] puis mat[1,5]
  2 : mat[,3] puis mat['b',] puis mat[5,1]
  3 : mat[3,] puis mat[,'b'] puis mat[5,1]
  4 : mat[3,] puis mat[,'b'] puis mat[1,5]")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == 4){
      beep(5)
      cat("'Ah oui oui oui oui oui !' Tu gagnes une cuisse de poulet, 
tu es dorénavant prêt à l'aider pour le combat final contre le roi Dadidou.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Kirby Leperse n'est pas content, 
il décide que tu ne l'accompagneras pas pour la suite de l'aventure.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

###==========================================
###EXERCICES DES CHEMIN DE L'AXE 3
###==========================================

# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3a <- function(vie){
  cat("Tu arrives dans la dimension où Kirby t'a envoyé et est projeté très vite, la tête la première dans un tuyau vert.
Tu comprends très vite ce qu'il se passe : Kirby n'a fait que t'envoyer dans un autre jeu-vidéo qui
n'est autre que Mario. Tu entends des bruits sourds derrière toi, tu te retournes et aperçois
2 goombas. Ils commencent à te poursuivre, tu te mets à courir et tu arrives
face à 2 tuyaux, tu dois choisir si tu veux emprunter l'un ou l'autre.")
  cat("Complète la fonction suivante : ")
  while(vie > 0){
    cat("if ((chemin == tuyau1) ??? (chemin == tuyau2)){
              return(TRUE)
}")
    reponse <- readline(prompt = "Entre ta réponse : ")
    if ((reponse == "|") | (reponse == "||")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu sautes dans l'un des tuyaux, et te retrouves dans un passage secret, rempli de pièces ! Tu croises Mario en train de les récupérer donc tu l'interpelles.")
      return(TRUE)
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Tu n'arrives pas à choisir quel tuyau emprunter, les goombas te rattrapent et te font tomber dans les néants du jeu Mario.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense aux opérateurs logiques possibles !")
  }
}

# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3b <- function(vie){
  cat("Mario t'explique qu'il souhaite récupérer la princesse au plus vite, il ne souhaite pas s'encombrer avec des champignons et des fleurs de feu qu'il a pu trouver dans ce passage secret.")
  cat("Le problème c'est que pour vaincre Bowser, il aura besoin de cet équipement, il faut qu'il emporte les 2, tu dois le convaincre")
  cat("Complète la fonction suivante : ")
  while(vie > 0){
    cat("while((FleursMario == 0)  ??? (ChampignonsMario == 0)){
              depart <- NA
}")
    reponse <- readline(prompt="Entre ta réponse : ")
    if ((reponse == "&") | (reponse == "&&")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu n'as pas réellement convaincu Mario, mais sur un petit creux il mange le champignon, grandit, emporte la fleur de feu et sort du passage secret.")
      return(TRUE)
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Tu n'arrives pas à convaincre Mario, il s'énerve et part sans toi.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense aux opérateurs logiques possibles!")
  }
}

# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3c <- function(vie){
  cat("A la sortie du passage, il y a un Koopa déguisé en yoshi, le fidèle destrier de Mario, celui-ci est sur le point de tomber dans le piège.
Tu peux sauver Mario en analysant le suspect, et en l'attaquant avant que Mario ne le chevauche.
Complète la fonction suivante : ")
  while(vie > 0){
    cat("if (suspect ???? 'yoshi'){
              attack()
}")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == "!="){
      beep(5)
      break
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Tu n'arrives pas à sauver Mario, il monte sur le Koopa, perd sa dernière vie et tombe.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense aux opérateurs logiques possibles ! ")
  }
  cat("Bravo ! C'était la bonne réponse ! Tu arrives à sauver Mario de justesse en assommant le Koopa avant qu'il ne monte dessus. 
Il souhaite te remercier pour cela et t'offre de nombreux champignons, mais tu ne peux en porter que 3. 
Mario commence à partir, tu ne pourras pas le suivre avec trop de champignons !")
  cat("Complète la fonction suivante : ")
  while(vie>0){
    cat("if (champignons ??? 3){
              depart <- NA
}")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == ">"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu n'emportes pas plus de 3 champignons et tu arrives à suivre Mario dans la suite du niveau;")
      return(TRUE)
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Tu n'arrives pas à suivre Mario avec tous ces champignons, il part sans se retourner.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense aux opérateurs logiques possibles ! ")
  }
}

# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3d <- function(vie){
  cat("Mario souhaite obtenir les 35 pièces du niveau avant de partir de celui-ci")
  cat("Tu dois donc l'aider à les récupérer et vérifier qu'il a bien le bon nombre de pièces")
  while(vie > 0){
    cat("if (NombreDePieces ??? 35){
          return(TRUE)
}")
    reponse <- readline(prompt = "Entre ta réponse : ")
    if (reponse == "=="){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as récupéré toutes les pièces du niveau, bien joué ! Tu finis donc le niveau et revenez dans le château, dans lequel se trouvent de nombreux tableaux.")
      return (TRUE)
    }
    vie <- vie - 1
    beep(9)
    if (vie == 0){
      cat("Tu n'arrives pas à récupérer toutes les pièces du niveau, Mario n'arrivera jamais à vaincre bowser à temps.")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense aux opérateurs logiques possibles ! ")
  }
}

## Sauvegarde tableau sur ordi
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3e <- function(vie){
  cat("Mario a tendance à égarer ses affaires... Pour être sûr de ne pas perdre la progression du précieux tableau 'tab' du niveau réalisé, il te demande de l'enregistrer")
  while(vie >= 0){
    print("Pour cela complète le code suivant :  write.table(???, 'tableau precieux', sep='\t', row.names=FALSE, quote=FALSE)")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == "tab"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi le tableau est bien conservé ! Tu décides donc de passer au prochain niveau/tableau")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Eh mince! Mario a perdu la progression du tableau avant que tu puisses le sauvegarder en lieu sûr.")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Le premier argument est le nom du tableau d'origine.")
      }
    }
  }
}

## Import tableau
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); s    i bonne réponse retour d'un son de victoire
exercice3f <- function(vie){
  cat("Mario ne trouve pas le tableau correspondant au prochain niveau dans le château. 
Il te demande de le retrouver, sachant que le niveau s'appelle 'Lave Fatale'")
  while(vie >= 0){
    print("Complète le code read.table('???',header=TRUE, sep='\t')")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == "Lave Fatale"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi Mario va pouvoir avancer !")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Eh mince! Mario ne peut plus avancer sans ce tableau. Il ne pourra donc pas sauver la princesse")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Le premier argument est le nom du tableau.")
      }
    }
  }
}


## Tableau de contingence
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3g <-function(vie){
  cat("Mario a besoin de s'organiser avant son départ dans le nouveau niveau, pour ça il veut construire un tableau de contingence au sein de son inventaire, quelle fonction utiliser?")
  while(vie >= 0){
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == "table()"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi Mario va pouvoir s'organiser ! ")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Eh mince! Mario va rester dans le désordre ! ")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Pense à quelle fonction permet de faire un tableau de contingence.")
      }
    }
  }
}

## Modalités d'un facteur
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire
exercice3h <- function(vie){
  cat("Toujours dans un souci d'organisation, Mario veut classer le contenu de sa sacoche en trois parties: 'équipement', 'nourriture' et 'détente'
  De plus, il avait déjà rangé ses photos en deux classes, mais il ne se souvient plus lesquelles...")
  while(vie >= 0){
    cat("Quelle fonction utiliser pour s'y retrouver dans le rangement ?
    1 : levels(ContenuSacoche)<-c('équipement', 'nourriture', 'détente') et levels(photos)
    2 : levels(ContenuSacoche)<-('équipement', 'nourriture' et 'détente') et levels(photos)
    3 : levels(ContenuSacoche)<-c('équipement', 'nourriture', 'détente') et ?levels(photos)")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == 1){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi Mario va pouvoir organiser sa sacoche et comprendre le classement de ses photos ! Il décide donc d'enfin entrer dans le niveau 'Lave Fatale' ")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Eh mince! Mario va rester dans le désordre ! ")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Attention à la forme des arguments")
      }
    }
  }
}

## Noms colonnes et lignes
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire
exercice3i <- function(vie){
  while(vie >= 0){
    cat("Le tableau qui permet à Mario de retourner dans le château est tellement usé qu'il n'est plus très lisible, si bien qu'il ne voit plus les noms des colonnes ni des lignes...
  C'est là que tu peux l'aider, quelles fonctions utiliser pour retrouver les différents noms effacés du tableau tab ?
  1 : colname(tab) et rowname(tab)
  2 : colnames(tab) et rownames(tab)
  3 : col(tab) et row(tab)")
    reponse <- readline(prompt="Entre ta réponse : ")
    if (reponse == 2){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi Mario pourra revenir dans le château à la suite de ce niveau.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Eh mince! Mario risque de se perdre... ")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Le moindre détail compte. ")
      }
    }
  }
}

## Question sur boucle for / while
# type d'exercice: CHOIX : l'utilisateur doit entrer une réponse qui correspond aux propositions (possibilité d'un menu déroulant); si bonne réponse retour d'un son de victoire
exercice3j <- function(vie){
  cat("Wario débarque et veut prendre la place de Mario,
Pour le vaincre, Mario a besoin de manger 3 champignons à la suite.
Pour se faire, 2 possibilités s'offrent à toi (on considère que Mario est un vecteur) : 
1 : for (i in 1:3){ Mario <- c(Mario, 'champi') }
2 : while (length(Mario) < 3){ Mario <- c(Mario, 'champi')
3 : les propositions 1 et 2 sont toutes les deux justes}")
  while (vie > 0){ # L'exercice se termine quand le joueur n'a plus de vie
    reponse <- readline("Quelle solution faut-il utiliser ? Entre ta réponse : ")
    if (reponse == "3"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Mario a grandi et a pu battre Wario. Il continue donc le niveau")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Ce n'est pas la bonne réponse. Ce n'est pas cette commande qu'il faut rentrer dans la console..
Tu n'as plus de point de vie.. Wario a battu Mario, le royaume est désormais en danger..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: Réfléchis à ce que fait chaque proposition.")
    }
  }
}

## Exercice: Fonction usuelle
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3k <- function(vie){
  cat("Pour aider Mario dans la suite du niveau, ta mission sera d'analyser le rapport de surveillance des ennemis. Il en a besoin afin de pouvoir les vaincre et continuer le niveau")
  rapport<-data.frame(ennemi=c("champignon", "champignon", "plante piranha", "koopa tropaa", "plante piranha", "champignon", "champignon", "boo"),position=c("avant", "arrière", "avant", "avant", "arrière", "avant", "arrière", "arrière"),niveau=c("faible", "faible", "fort", "moyen", "fort", "faible", "faible", "fort"),points=c(10, 10, 50, 25, 50, 10, 10, 50))
  while (vie > 0){
    reponse <-readline("Quelle ligne de code permet d'afficher les statistiques? Entre ta réponse : ")
    if (reponse == "summary(rapport)"){
      beep(5)
      print(summary(rapport))
      cat("Bravo ! C'était la bonne réponse ! Mario a le rapport des ennemis.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Ce n'est pas la bonne réponse. L'analyse n'a pas été concluante. Mario n'a pas pu réussir le niveau, tu te fais éjecter.")        
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: Voici un exemple d'application de summary : summary(dataframe) ")
      }
    }
  }
}

## Exercice fonction usuelle 2: 
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3l <- function(vie){
  cat("En effet, en regardant plus en détail le rapport, il y a des informations manquantes 
sous forme de NA au sein de ce dernier.
Mario te demande de confirmer leur présence afin d'avancer dans le niveau!
      ")
  rapport<-data.frame(ennemi=c("champignon", "champignon", "plante piranha", "koaopa tropaa", "plante piranha", "champignon", "champignon", "boo"),position=c("avant", "arrière", "avant", "avant", "arrière", "avant", "arrière", "arrière"),niveau=c(NA, "faible", NA, "moyen", "fort", "faible", "faible", NA),points=c(10, 10, 50, 25, 50, 10, 10, 50))
  while(vie >= 0){
    print(rapport)
    cat("Quelle ligne de code permet de faire cela?")
    answer<-readline(prompt="Entre ta réponse : ")
    if ((answer == "is.na(rapport$niveau)") | (answer == "is.na(rapport[,'niveau']") | (answer=='is.na(rapport[,"niveau"]') | (answer=="is.na(rapport[,3]")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Grâce à toi Mario a pu vaincre ces ennemis !")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Ce n'est pas la bonne réponse. L'analyse n'a pas été concluante. Mario n'a pas pu réussir le niveau, toi et Mario vous faites éjecter.")
        return(FALSE)
      }else{
        cat("Mauvaise réponse, ne te décourages pas ! INDICE: is.na(colonne) .
            ")
      }
    }
  }
}

## Question sur if / else / else if
# type d'exercice: l'utilisateur doit entrer une réponse (saisir du code); si bonne réponse retour d'un son de victoire
exercice3m <- function(vie){
  cat("Mario rencontre son frère Luigi dans le niveau, celui-ci lui demande s'il n'aurait pas une fleur de feu à lui donner car Waluigi est à ses trousses.
Mario te demande alors de vérifier dans son sac (considéré comme un vecteur) pour voir s'il a une fleur de feu en réserve.
  Voici une proposition de code : 
    
    if ('fleur' in sac){ return(TRUE) 
    }??{ return(FALSE) }
  ")
  while (vie > 0){ # L'exercice se termine quand le joueur n'a plus de vie
    reponse <- readline("que doit-on écrire à la place des '??' ?")
    if (reponse == "else"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Luigi est maintenant en mesure de battre Waluigi. Il t'aide donc à conclure le niveau 'Lave Fatale' et vous rentrez au château. Mais juste avant de parvenir au tableau, Bowser tombe du ciel et vous barre le chemin.")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }else{
      beep(9) # Son de la défaite
      message (" Ce n'est pas la bonne réponse")
      vie <- vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Faux ! Ce n'est pas cette commande qu'il faut rentrer dans la console..
Tu n'as plus de point de vie.. Luigi est désespéré et voit sa dernière heure arriver..")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Ce n'est pas la bonne réponse, essaye encore. Et fais attention, tu ne dois rentrer qu'un seul mot en minuscule.")
    }
  }
}

###==========================================
###EXERCICES DES CHEMIN DE L'AXE 4
###==========================================

## Manipulation dataframe

exercice4a <- function(vie){
  cat("Là où tu arrives après être entré dans la tableau, un grand soleil t'éblouit.
Le temps est bon, le ciel est bleu, mais tu n'as pas deux amis qui sont aussi tes amoureux.
Tu finis par t'habituer à la luminosité ambiante, et tu reconnais de grandes étendues d'eau
et des chemins herbeux les traversant, tu reconnais un élément qui te fait comprendre le monde
dans lequel tu as atterri. Des anneaux dorés : tu es dans le monde de Sonic !
D'un coup, quelque chose, ou plutôt quelqu'un, passe très vite près de toi, à la vitesse d'un
véhicule motorisé. Il s'arrête, se retourne et vient vers toi, tu reconnais Sonic, ce fameux
personnage. Il s'adresse à toi : 'Salut, je ne te connais pas, tu n'as pas l'air de venir d'ici.
Je parie que c'est encore une des manigances du docteur Eggman, mon pauvre ! 
Tu peux m'accompagner si tu le souhaites,on pourra peut-être te ramener là d'où tu viens.'

Il se retourne, puis a l'air de ne pas très bien savoir où il est, tu te rends vite compte que
Sonic est perdu, et tu sais qu'il doit récupérer un maximum d'anneaux. Il sort une carte qui est
un tableau de répartition des anneaux sur le niveau.
      
Voici ce à quoi ressemble le tableau 'chemins' :
    A B C D
    
1   1 3 9 8
2   4 9 9 2
3   8 6 7 5
4   2 2 8 7
5   5 1 6 5
6   7 9 5 2

Tu dois sélectionner le chemin A,B,C ou D qui contient le plus d'anneaux dans le tableau 'chemins'.
Quelle ligne de code te permettrait de sélectionner le bon chemin ?")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if ((reponse == "chemins[,3]") | (reponse == "chemins[,'C']") | (reponse == 'chemins[,"C"]') | (reponse == "chemins$C")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Avec tous ces anneaux Sonic peut avancer dans sa quête.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre aux attentes de Sonic et à trouver le bon chemin. 
Sonic n'arrive pas à avoir assez d'anneaux, cela le ralentit énormément, 
vous n'arriverez pas à temps pour vaincre le docteur Eggman..")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : tu peux utiliser le symbole '$'.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


exercice4b<-function(vie){
  df <- data.frame(A = c('Anneau','Shadow','Knuckles','Anneau'),B = c('Rouge','Blaze','Anneau','Anneau'),C = c('Anneau','Chaos','Sonic','Amy'),D = c('Silver','Cream','Anneau','Sticks'))
  cat("Sonic s'est mis à courir si vite que tu n'as pu le rattraper, même avec un vélo de course.
Heureusement que tu as la géolocalisation de ce dernier sur ton téléphone, mais il y a aussi d'autres personnes et objets.
Choisis la bonne case du tableau de coordonnées 'Emplacement'.

Voici ce à quoi ressemble le tableau 'Emplacement' : 
      
")
  print(df)
  cat("
Sélectionne la case où se trouve Sonic dans le tableau 'Emplacement'.")
  reponse<-readline("Entre ta réponse : ")
  while(vie > 0){
    if ((reponse == "Emplacement[3,3]") | (reponse == "Emplacement[3,'C']") | (reponse == 'Emplacement[3,"C"]') | 
        (reponse == "Emplacement['3','C']") | (reponse == 'Emplacement["3","C"]')){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as pu retrouver Sonic.
Il faisait du hula hoop avec un anneau ... Tu lui dis de se ressaisir et continuez votre quête.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à retrouver Sonic. 
Tu ne croises que ses ennemis qui te pourchassent.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : fais attention aux guillemets.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


exercice4c<-function(vie){
  df <- data.frame(A = rep('Anneau',4),B = rep('Anneau',4),C = rep('Anneau',4),D = c('Anneau','MAYDAY','Anneau','Anneau'),row.names = c('Route1','Route2','Route3','Route4'))
  cat("MAYDAY ! MAYDAY ! Tu reçois un appel à l'aide sur ton téléphone.
Sonic décide d'agir et fonce tête baissée. Tu dois le guider jusqu'au signal.

Voici ce à quoi ressemble le tableau 'Secours' : 
      
")
  print(df)
  cat("
Sélectionne la route à emprunter pour porter secours.")
  reponse<-readline("Entre ta réponse : ")
  while(vie > 0){
    if ((reponse == "Secours[2,]") | (reponse == "Secours['Route2',]") | (reponse == 'Secours["Route2",]')){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as pu guider Sonic.
Il arrive à sauver une princesse avant qu'un enfant vêtu tout de vert vienne lui faire du mal.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à trouver la personne en détresse. 
Le signal a disparu... Une victime de plus d'Eggman.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : on ne demande pas une case mais une ligne !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


exercice4d<-function(vie){
  df <- data.frame(Ennemis = c(27,34,42,36,24,21),
                   Anneaux = c(32,45,21,64,38,29),
                   Allies = c('Sonic','Miles','Sonic','Amy','Amy','Sonic'),
                   row.names = c('Niveau1','Niveau2','Niveau3','Niveau4','Niveau5','Niveau6'))
  cat("Tu rencontres Knuckles sur ton chemin, un ami de Sonic,
il se trouve qu'il souhaite s'entraîner pour combattre le docteur Eggman. Il te demande donc de choisir
parmi cette liste de niveaux, lesquels contiennent le plus d'ennemis.

Voici ce à quoi ressemble le tableau 'Niveaux' affichant les différentes caractéristiques des niveaux : 
      
")
  print(df)
  cat("
Tu dois sélectionner les niveaux contenant plus de 35 ennemis,
remplis la fonction suivante en séparant les mots d'une virgule :      
      niveaux[????(Niveaux$???>35),]")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "which,Ennemis"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! 
Grâce à toi Knuckles s'est bien entraîné et est prêt à en découdre avec Eggman.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre aux attentes de Knuckles.
Knucles ne sait pas où aller, il décide de s'entraîner sur toi ... Aïe !")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : le premier mot commence par 'wh'.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


exercice4e<-function(vie){
  df <- data.frame(Ennemis = c(27,34,42,36,24,21),
                   Anneaux = c(32,45,21,64,38,29),
                   Allies = c('Sonic','Miles','Sonic','Amy','Amy','Sonic'),
                   row.names = c('Niveau1','Niveau2','Niveau3','Niveau4','Niveau5','Niveau6'))
  cat("Knuckles souhaiterait, dans le même tableau 'Niveaux', faire ressortir les niveaux avec Sonic
afin de s'entraîner avec lui.
Tu dois donc sélectionner les niveaux avec Sonic, 
complète la fonction suivante en séparant les mots d'une virgule :
      ????['Sonic',????(Niveaux$????),]

")
  print(df)
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "Niveaux,grep,Allies"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! 
Grâce à toi Sonic a pu bien s'entraîner aussi, Sonic décide de continuer sa route et tu le suis.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre aux attentes de Knuckles.
Knuckles et Sonic n'ont pas pu s'entraîner ensemble, ils n'arriveront pas à vaincre Eggman.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : le deuxième mot commence par 'gr'.")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Tri d'un  vecteur

exercice4f<-function(vie){
  cat("Sonic doit ouvrir un passage secret pour continuer son chemin, une énigme
du logiciel de docteur Eggman s'affiche à vous :
Que font les commandes sort(x, decreasing=T) et order(x, decreasing=T) ?
  1 : elles trient les données du vecteur x par ordre décroissant
  2 : elles créent un vecteur x avec des données aléatoires classées par ordre croissant
  3 : elles trient les données du vecteur x par ordre croissant
  4 : elles créent un vecteur x avec des données aléatoires classées par ordre croissant")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == 1){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! 
Le passage s'ouvre, Sonic se roule en boule et continue rapidement son chemin.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à ouvrir la passage secret à temps, une porte se 
referme derrière vous . Vous voilà coincés.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## Exercice FUSION de tableau : 

exercice4g<-function(vie){
  cat("Sonic tombe en chemin sur deux messages comprenant des mots, il n'arrive pas à les comprendre.
Aide Sonic à décrypter le message en assemblant les deux bouts du message (rapport1) et (rapport2) par colonne.")
  rapport1<-data.frame(Mot1=c("Egoiste", "gardien", "nom"), Mot2=c("et", "de", "est :"),Mot3=c("inflexible,", "la", "Knuckles,"))
  rapport2<-data.frame(Suite1=c("il", "Master", "rival"), Suite2=c("est", "Emerauld", "de"),Suite3=c("le", ".Son", "sonic"))
  print(rapport1)
  print(rapport2)
  reponse<-readline("Entre la ligne de code qui permet de faire fusionner les deux bouts du message par colonne : ")
  while(vie > 0){
    if (reponse == "cbind(rapport1,rapport2)"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! 
Sonic peut maintenant lire le message suivant :
          
")
      rapport<-cbind(rapport1,rapport2)
      print(rapport)
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à décrypter le message. Sonic abandonne, et vous ne saurez jamais
qui a écrit ce message..")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : utilise la fonction cbind().")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

exercice4h<-function(vie){
  cat("Sonic ne comprend pas trop d'où peut sortir un tel message sur lui. Il se retourne et te demande :
'Si la fusion des deux bouts de message devait se faire par ligne, quelle est la condition que cette fusion 
doit respecter?'  
1 : même nombre de colonnes  
2 : même nombre de lignes  
3 : Aucune condition.")
  reponse<-readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "1"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Sonic te remercie, il se fait peut-être une idée 
de qui a rédigé ce message, il se roule en boule et part à toute vitesse et tu le suis.")
      rapport <- cbind(rapport1,rapport2)
      print(rapport)
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement à Sonic. Celui-ci désespère et
t'abandonne à ton triste sort..")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur la modification des éléments

exercice4i<-function(vie){
  cat("Sonic a besoin de ton aide, Shadow son plus grand rival va arriver d'une minute à l'autre pour le combattre.
Afin de gagner, Sonic doit se transformer en SuperSonic. Il possède 9 anneaux d'or mais il
en a besoin d'un 10ème pour se transformer.

Les anneaux sont contenus dans le vecteur 'sac' :
sac <- c('A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9').
Pour récupérer le 10ème anneau, voici 3 propositions de code : 

  1 : sac[1:9] <- sac[1:9] + 'A10'
  2 : sac[10] <- 'A10'
  3 : sac[1:9] <- c('A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9', 'A10')

Quelle est la bonne réponse ? Répondez par 1, 2 ou 3. 
")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "2"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Sonic se transforme en SuperSonic, défie Shadow et le vainc.
Maintenant que le bras droit d'Eggman est KO, vous allez pouvoir affronter Eggman.
Sonic s'adresse à toi 'Merci, ce message était de la part d'Eggman, je pense qu'il a capturé Knuckles,
je vais aller le comba...'
Une énorme machine surgit du ciel, pilotée par Eggman, prêt à en découdre maintenant que Sonic
est épuisé de son combat contre Shadow.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement. Tu n'as plus de point de vie.. 
Sonic est désespéré et la défaite pointe son nez..")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

###==========================================
###EXERCICES DES CHEMIN DE L'AXE 5
###==========================================

exercice5a<-function(vie){
  cat("Le portail te jette au milieu d'une plaine, tu es encore abasourdi par la projection
du voyage interdimensionnel que tu remarques au loin un château corrompu par un esprit maléfique.
Tu regardes autour de toi et reconnais un grand arbre et un volcan qui te rappellent le monde de Zelda.
Tout à coup, un enfant vêtu de vert, que tu as cru voir auparavant saute sur le dos d'un cheval et finit
par réussir à en faire son fidèle destrier. Il te regarde, tu comprends tout de suite que c'est Link, et
qu'en le suivant tu l'aideras à sauver la princesse Zelda du maléfique Ganondorf.

Il te fait monter sur son cheval et vous commencez votre aventure ensemble en direction du domaine Goron.

Non loin du volcan Goron, qui dégage une chaleur insoutenable, vous
trouvez un parchemin sheikah. Il mentionne leur technologie avancée, vous le lisez : 
Quelles sont les bonnes pratiques dans R ? Sépare tes réponses par une virgule.
        	1 : ne pas mettre d'espace ni d'accent dans le nom des variables et appliquer le CamelCase
        	2 : utiliser des variables globales
        	3 : préférer les boucles aux arrays
        	4 : créer un tableau à la bonne taille si on connaît à l'avance nos besoins")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "1,4" | reponse == "4,1"){
      beep(5)
      cat("Bien joué ! Un coffre se dévoile à vous, il contient deux armures de pierre,
lourdes mais résistantes à la chaleur, elles vous permettent d'accéder au village Goron.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre à l'énigme, le parchemin part en fumée sous la chaleur intense.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: il y a 2 bonnes réponses.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Question sur les fonctions avec apply

exercice5b<-function(vie){
  cat("Tu arrives au village Goron avec Link. Ces bons vivants vous proposent un jeu.
Voici le dataframe 'Fruits' résumant le nombre de fruits par Goron dans le village : 
      
      ")
  print(data.frame(row.names = c('Goron 1', 'Goron 2', 'Goron 3', 'Goron 4', 'Petit Goron', 'Doyen Goron'), 
                   Pommmes = c(5,4,2,4,1,7), Poires = c(3,3,2,1,1,5), Bananes = c(4,6,2,1,5,5)))
  
  cat("
Le Doyen Goron souhaite compter le nombre de pommes, de poires et de bananes au sein du village.
Il te demande, grâce à la fonction sum(), de compter le nombre de bananes en utilisant la méthode apply.
Quelle commande dois-tu rentrer dans la console ? (ne pas mettre d'espaces) ")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "apply(X=Fruits,MARGIN=2,FUN=sum)"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Doyen Goron est content et t'offre un rubis doré. Tu décides,
après cette quête secondaire, de compléter le temple du feu, ce que tu fais en quelques heures,
et de continuer ton aventure.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre aux attentes du Doyen Goron. Celui-ci est vexé et te roule dessus.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: la fonction apply a 3 arguments.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## utilisation de base apply

exercice5c<-function(vie){
  cat("La tablette sheikah de Link commence à s'affoler sans raison, elle affiche
des colonnes de chiffres que vous n'arrivez pas à décrypter. Soudain te viens une idée.
Complète la formule pour obtenir la moyenne de chaque colonne du tableau de la tablette sheikah : 
apply(X=tab, MARGIN=2, FUN=??) ")
  reponse<-readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "mean"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as réussi à comprendre ces chiffres, ce sont des coordonnées, 
un sanctuaire se situe tout près de toi. Tu le complètes et continues ton aventure, en direction du domaine Zora cette fois-ci.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à comprendre ces colonnes de chiffres . 
Tu es passé à côté de quelque chose d'important et la tablette ne répond plus à rien. 
Link ne peut plus continuer l'aventure sans cette dernière.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE: l'argument FUN désigne un nom de fonction.")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## différence sapply/lapply

exercice5d<-function(vie){
  cat("En approchant du domaine Zora, toi et Link tombez sur un parchemin
Sheikah, mentionnant leur technologie avancée. Quelle est la différence entre lapply() et sapply() ?
        	1 : lapply() renvoie une liste et sapply() un vecteur
        	2 : lapply() renvoie un vecteur et sapply() une liste.")
  reponse<-readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "1"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Un coffre se dévoile à vous, il contient deux armures Zora,
permettant de nager plus vite mais aussi à contre courant. Elles vous permettent d'accéder au temple de l'eau.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre à l'énigme, le parchemin commence à s'engorger d'eau et se déchire dans tous les sens.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## utilisation tapply

exercice5e<-function(vie){
  cat("Link et toi arrivez à l'entrée du temple de l'eau. Une énigme s'affiche sur la
porte d'entrée, il s'agit encore une fois de la technologie avancée des Sheikahs :
On veut calculer l'âge moyen en fonction du sexe, quelle est la bonne formule ?
        	1 : tapply(X=Genre, INDEX=Age, FUN=mean)
        	2 : tapply(X=Age, INDEX=Genre, FUN=log
        	3 : tapply(X=Age, INDEX=Genre, FUN=mean.")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "3"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! La porte s'ouvre et tu peux accéder au temple. 
Tu le complètes et continues ton aventure.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre à l'énigme, Link ne pourra pas rassembler la triforce sans accéder à ce temple.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Exercice fonctions

exercice5f<-function(vie){
  cat("En chemin vous rencontrez Terry le vendeur, il propose a Link une nouvelle tenue (verte)
flamboyante pour remplacer la sienne, toute abimée par les combats. Link marchande et réussi à
obtenir une réduction de 50% sur sa nouvelle tenue, il devait payer 133 rubis
Il ne peut pas séparer un rubis en 2 et doit donc tronquer le résultat.
Aide le en complétant cette fonction 'Troncature': 
      
Troncature <- ???(décimal){    # Cette fonction permet de tronquer un chiffer décimal
  ?????(as.integer(décimal))   # On renvoie le résultat
}
            
Sépare tes réponses par des virgules (ne pas mettre d'espace).      
      ")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "function,return"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Link doit bien 66 rubis à Terry. 
Il achète sa nouvelle tenue et vous continuez votre route en direction du village Cocorico.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre correctement, Link ne sait plus combien il doit. 
Il s'énerve, casse des pots, prend une poule et part en planant avec.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : une fonction commence par 'func....' et finit par 'ret...'.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

## Exercice fonctions

exercice5g<-function(vie){
  cat("Ganondorf a encore semé la terreur dans le village Cocorico, les poules sont paniquées
et l'éleveur René vous demande de rassembler ses 10 poules dans son enclos.
Link est trop occupé à battre les ennemis restants, tu vas devoir t'en occuper.
Tu disposes de la fonction 'capturer(nombre,personne)' qui prend en paramètres le nombre de poules
et la personne à qui rapporter les poules. 
Utilise-la pour ramener les poules à René.")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "capturer(10,'René')" | reponse == 'capturer(10,"René")'){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! René te remercie en t'offrant un flacon. 
Il te permettra de contenir de la potion ou bien une fée pour te régénérer. 
Avec un tel équipement, tu es prêt à affronter Ganondorf.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi à répondre aux attentes de René, il t'accuse d'avoir mangé ses poules 
et vous bloque l'accès au prochain temple, Link ne pourra donc pas rassembler la triforce.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas ! INDICE : pense à l'utilisation de guillements pour un objet de type string.")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}


## remplissage_effiace:

exercice5h<-function(vie){
  cat("Link et toi arrivez au niveau du château d'Hyrule, pour ouvrir la porte principale, derrière laquelle
se situe Ganondorf, il vous fait résoudre une énigme à l'aide de ta tablette Sheikah :
Quelle est la meilleure manière d'effectuer un remplissage efficace sur la boîte (tableau)
connaissant les dimensions de cette dernière ?  

1 : Ajouter au fur et à mesure des colonnes  
2 : Créer le tableau, le remplir de NA et remplacer par la suite")
  reponse <- readline("Entre ta réponse : ")
  while(vie > 0){
    if (reponse == "2"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! La porte s'ouvre, Ganondorf engage le combat contre vous.")
      return(TRUE)
    }else{
      beep(9)
      vie <- vie - 1
      if (vie == 0){
        cat("Tu n'as pas réussi l'énigme, Link et toi n'avez pas réussi à ouvrir la porte à temps.
Ganon se délivre de son emprise et prend le contrôle du royaume d'Hyrule en entier.")
        return(FALSE)
      }
      cat("Mauvaise réponse, ne te décourages pas !")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

###==========================================
###EXERCICES DES CHEMIN DE L'AXE 6
###==========================================

exercice6a <- function(vie){
  cat("Le cristal t'a transféré dans une autre dimension de façon beaucoup plus contrôlée.
Tu te dis que rien de pire ne peut t'arriver après ce que tu as vécu ... Et pourtant ...
Tu remarques de grandes murailles au loin, de plus, tu remarques que tu portes 
une veste et un équipement que tu reconnais.
Tu comprends que cette veste est celle du bataillon d'exploration et l'équipement 
est un équipement tridimensionnel de l'animé 'l'attaque des titans'
Tu aperçois une brèche dans le mur au loin, tu arrives à déterminer qu'il s'agit du mur Rosa.
La ville est à feu et à sang, des cris retentissent de partout, des citoyens se font manger devant toi
par des titans en surnombre comparé aux quelques soldats défendant la ville au prix de leurs vies.

Une voix t'interpelle 'Reste pas là à rien faire le rookie, on a besoin de toi pour repérer les titans'
Il s'agit d'Eren Jäger, il te demande de lui rapporter le nombre de titans en fonction de la distance du 
mur Rosa.
Comment afficher ce qu'Eren souhaite avec les vecteurs 'NombreTitans' et 'Distance' ?")
  reponse <- readline(prompt = "Entre ta réponse : ")
  while(vie>0){
    if ((reponse == "plot('NombreTitans,'Distance')") | (reponse == 'plot("NombreTitans","Distance")')){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Eren te remercie, tu es un fin stratège tout comme Armin, lui et Mikasa foncent en direction des titans.")
      return(TRUE)
    }
    vie=vie-1
    beep(9)
    if(vie == 0){
      cat("Eren n'a pas de bonnes informations, et part au combat mais se fait dévorer par un titan")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas !  INDICE: utiliser la fonction plot() ")
    reponse <- readline("Quelle est ta nouvelle réponse ? ")
  }
}


exercice6b <- function(vie){
  cat("Tu ne sais pas trop comment, mais après quelques minutes, il s'agit d'un carnage. Le bataillon
d'exploration a anéanti tous les titans. et le mur Rosa a été rebouché. Quelques jours plus tard, toi et le bataillon d'exploration suivez une formation afin d'affronter de nouveaux types de titans. Le professeur te pose une question de régression linéaire avec le jeu de données 'Titans' : 
Regression <- ???(???$taille~???$vitesse, data = Titans)
Complète la fonction ci-dessus en séparant tes réponses d'une virgule.")
  reponse <- readline(prompt = "Entre ta réponse : ")
  while(vie>0){
    if (reponse == "lm,Titans,Titans"){
      beep(5)
      cat("Maintenant, le professeur te demande tracer cette régression linéaire sur un graphique
déjà existant, qui affiche la vitesse en fonction de la taille des Titans.")
      break
    }
    vie=vie-1
    beep(9)
    if(vie == 0){
      cat("Tu n'as pas été sélectionné pour la prochaine mission à cause de tes mauvaises réponses...")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE : Souviens toi de la fonction de régression linéaire.")
    reponse <- readline("Quelle est ta nouvelle réponse ? ")
  }
  cat("Complète la fonction suivante en séparant tes réponses d'une virgule  :
???(Regression, ??? = 'blue')")
  reponse2 <- readline(prompt = "Entre ta réponse : ")
  while (vie>0) {
    if (reponse2 == "abline,col"){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! Tu as été sélectionné pour la prochaine mission et tu accompagneras Eren")
      return(TRUE)
    }
    vie=vie-1
    beep(9)
    if(vie == 0){
      cat("Tu n'as pas été sélectionné pour la prochaine mission à cause de tes mauvaises réponses...")
      return(FALSE)
    }
    cat("Mauvaise réponse, ne te décourages pas ! INDICE : Souviens toi de la fonction pour tracer une ligne.")
    reponse2 <- readline("Quelle est ta nouvelle réponse ? ")
  }
}


# Question sur ggplot

exercice6c <- function(vie){
  cat("Maintenant, Erwin Smith, le caporal en  chef du bataillon d'exploration, t'appelle afin de mettre en place une nouvelle stratégie pour sauver l'humanité lors de cette nouvelle mission.
Avant de te donner ta mission, il te présente le jeu de données 'Victimes', présentant le nombre de victimes moyen par titan primordial par jour de la semaine :
          
Titans        Jour     vict

Bestial       Lundi     50 
Feminin       Lundi     40      
Colossal      Lundi     80   
Cuirasse      Lundi     20 
Bestial       Mardi     50   
Feminin       Mardi     30     
Colossal      Mardi     70  
Cuirasse      Mardi     40 
Bestial       Jeudi     60  
Feminin       Jeudi     90     
Colossal      Jeudi     80  
Cuirasse      Jeudi      0 

Erwin te demande tout d'abord de représenter, à l'aide de ggplot, le nombre de victimes par titan par jour sur un graphique.
          
La ligne de code suivante permet de représenter le nombre de victimes par titans, en colorisant par jour : 
  > ggplot(data = Victimes, aes(x=*, y=**, color = ***)) + geom_point()d
          
Tu dois compléter la ligne de code, 3 propositions s'offrent à toi :
      1 : * = Titans, ** = vict, *** = Jour
      2 : * = Jour, ** = vict, *** = Titans
      3 : * = Titans, ** = Jour, *** = vict.
      
Quelle est la bonne proposition ? Tu dois entrer le numéro correspondant.")
  reponse <- readline("Entre ta réponse :")       
  while (vie > 0){ # L'exercice se termine quand le joueur n'a plus de vie
    if (reponse == "1"){
      beep(5) # Son victorieux
      cat("Bravo ! C'était la bonne réponse ! Erwin te félicite et dit le poing sur le coeur : 'Shinzou wo sasageyo !!'.")
      return(TRUE) # Permet de dire que l'exercice est réussi
    }
    else{
      beep(9) # Son de la défaite
      vie = vie - 1 # Le personnage perd un point de vie
      if (vie == 0){
        cat("Erwin est très déçu et décide de ne pas compter sur toi pendant la prochaine mission.")
        return(FALSE) # Permet de dire que l'exercice n'a pas été réussi 
      }
      cat("Mauvaise réponse, ne te décourages pas !  INDICE: réfléchis bien à ce qui doit être en abscisse et en ordonnée...")
      reponse <- readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

#Exercice boxplot:

exercice6d<-function(vie){
  nom<-c("eren","mikasa","armin","jean","sasha","connie","ymir","christa","erwin","levi","hanji","marco","annie","reiner","bertholdt")
  combat<-c(9,10,0,9,6,6,7,6,9,10,7,8,10,8,9)
  strategie<-c(0,8,10,7,5,0,7,4,10,8,10,8,7,7,6)
  travail_equipe<-c(5,6,8,0,6,7,0,8,7,2,8,10,0,10,10)
  titans<-data.frame(nom,strategie,travail_equipe)
  print(titans)
  cat("Bien intégré dans le bataillon d'exploration, vous préparez votre première attaque contre les titans. Afin de préparer l'attaque, Hanji doit étudier deux critères dans l'équipe : stratégie et travail d'équipe. Pour l'aider, tu dois réaliser un histogramme sous forme de boxplot en faisant apparaître les critères. Les données se trouvent dans le rapport qui s'appelle : titans.")
  reponse<-readline("Entre ta ligne de code : ")
  while(vie>0){
    if ((reponse=="boxplot(titans[,c(2:3)])")|(reponse=="boxplot(titans$strategie,titans$travail_equipe)")|(reponse=="boxplot(titans$travail_equipe,titans$strategie)")){
      beep(5)
      cat("Bravo ! C'était la bonne réponse ! L'attaque contre les titans a été un succès.  Après avoir célébré cette victoire, tu t'endors de fatigue à 
deux pas de ton lit. Soudain, tu entends l'arme retentir et tu te rends compte que le Mur Rosa est attaqué.
Le camp ennemi contre-attaque, c'est le titan bestial !")
      return(TRUE)
    }else{
      beep(9)
      vie=vie-1
      if (vie==0){
        cat("Tu as échoué dans la tâche qui  t'a été confiée, le bataillon a subit de gros dégâts")
        return(FALSE)
      }     
      cat("Mauvaise réponse, ne te décourages pas. INDICE: sélection des colonnes du dataframe : titans[,c(2:3)]")
      reponse<-readline("Quelle est ta nouvelle réponse ? ")
    }
  }
}

