// PIN
int cible0=A0;
int cible1=A1;
int cible2=A2;
int cible3=A3;
int cible4=A4;
int cible5=A5;
int pinServo1 = 2;
int pinServo2 = 3;
int pinServo3 = 4;
int pinServo4 = 5;
int pinServo5 = 6;
int pinServo6 = 7;
int pinled1 = 22;
int pinled2 = 23;
int pinled3 = 24;
int pinled4 = 25;
int pinled5 = 26;
int pinled6 = 27;
int PINStart = 8;
int pinBuzzer = 10;

// variable moyenne capteur lumiere
int moyennecible0=0;
int moyennecible1=0;
int moyennecible2=0;
int moyennecible3=0;
int moyennecible4=0;
int moyennecible5=0;

// tableau pour savoir quelle cible est levee et peut etre toucher
int cibleCapteur[]={0,0,0,0,0,0};

int i = 0;
int start = 0;

// ronud de jeu tableau multi { temps en ms , numero servo , angle en degre } 15 pour plat et 90 pour levé , ajout valeur hors cadre a la fin
int round1[ ][ 3 ] = { { 1000, 0, 90 },{ 4000, 0, 15 },{ 4000, 2, 90 },{ 4000, 3, 90 },{ 8000, 2, 15 },{ 8000, 3, 15 },{ 8000, 4, 90 },{ 8000, 1, 90 },{ 10000, 4, 15 },{ 10000, 1, 15 },{ 10000, 5, 90 },{ 12000, 5, 15 },{ 12500, 5, 90 },{ 12500, 0, 90 },{ 14000, 5, 15 },{ 14000, 0, 15 },{ 14000, 3, 90 },{ 14000, 4, 90 },{ 16000, 4, 15 },{ 16000, 3, 15 },{ 16000, 1, 90 },{ 17500, 1, 15 },{ 18000, 0, 90 },{ 18000, 1, 90 },{ 18000, 3, 90 },{ 22000, 0, 15 },{ 22000, 1, 15 },{ 22000, 3, 15 },{ 22000, 2, 90 },{ 23000, 2, 15 },{ 23000, 5, 90 },{ 24000, 5, 15 },{ 24000, 0, 90 },{ 24000, 1, 90 },{ 24000, 2, 90 },{ 24000, 3, 90 },{ 24000, 4, 90 },{ 24200, 5, 90 },{ 27800, 5, 15 },{ 28000, 0, 15 },{ 28100, 1, 15 },{ 28200, 2, 15 },{ 28300, 3, 15 },{ 28400, 4, 15 }};
int round2[ ][ 3 ] = { { 1000, 0, 90 },{ 2000, 0, 15 },{ 2000, 3, 90 },{ 3000, 3, 15 },{ 3000, 0, 90 },{ 4000, 0, 15 },{ 4000, 2, 90 },{ 5000, 2, 15 },{ 5000, 4, 90 },{ 6000, 4, 15 },{ 6000, 1, 90 },{ 7000, 1, 15 },{ 7000, 2, 90 },{ 7000, 3, 90 },{ 8000, 2, 15 },{ 8000, 3, 15 },{ 8000, 1, 90 },{ 8000, 5, 90 },{ 9000, 1, 15 },{ 9000, 5, 15 },{ 9000, 0, 90 },{ 10000, 0, 15 },{ 10000, 4, 90 },{ 11000, 4, 15 },{ 11000, 5, 90 },{ 12000, 5, 15 },{ 12000, 4, 90 },{ 13000, 4, 15 },{ 13000, 5, 90 },{ 14000, 5, 15 },{ 14000, 2, 90 },{ 15000, 2, 15 },{ 15000, 1, 90 },{ 15700, 1, 15 },{ 16000, 1, 90 },{ 16000, 0, 90 },{ 17000, 0, 15 },{ 17000, 1, 15 },{ 17000, 2, 90 },{ 17000, 4, 90 },{ 18000, 4, 15 },{ 18000, 2, 15 },{ 18000, 5, 90 },{ 19000, 5, 15 },{ 19000, 3, 90 },{ 19200, 5, 90 },{ 20000, 5, 15 },{ 20000, 3, 15 },{ 20500, 3, 90 },{ 21000, 3, 15 },{ 21000, 4, 90 },{ 22000, 4, 15 },{ 22000, 0, 90 },{ 23000, 0, 15 },{ 23000, 2, 90 },{ 24000, 2, 15 },{ 24000, 1, 90 },{ 25000, 1, 15 },{ 25000, 5, 90 },{ 26000, 5, 15 },{ 26200, 0, 90 },{ 26200, 1, 90 },{ 26200, 2, 90 },{ 26200, 3, 90 },{ 26200, 4, 90 },{ 26200, 5, 90 },{ 28500, 5, 15 },{ 28500, 4, 15 },{ 28500, 3, 15 },{ 28500, 2, 15 },{ 28500, 1, 15 },{ 28500, 0, 15 }};
// temps des round , premier a 0 car se base sur la variable start ( start = 0 a l'init ) 
int tempsRound[]= {0,30000,30000};

// temps et step pour les sequences
long tempsdebut = 0;
long stepSequence = 0;

// points 
int points = 0;
int pointsManche = 0;

#include "pitches.h"
#include <Servo.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

Servo monServo0;
Servo monServo1;
Servo monServo2;
Servo monServo3;
Servo monServo4;
Servo monServo5;
Servo mesServos[]={monServo0,monServo1,monServo2,monServo3,monServo4,monServo5};

LiquidCrystal_I2C lcd(0x27,20,4);

// variable pour jouer les melodies
int numeroMelody = 0;
int numeroNote = 0;
int numeroNoteBefore = 9;
long tempsMelody = 0;
long pauseNotes;
bool boolMelody = 1;
const float MelodySpeed = 0.05;

// 2 melodies
int melody[][78] = {{
NOTE_E4, NOTE_G4, NOTE_A4, NOTE_A4, 0,
    NOTE_A4, NOTE_B4, NOTE_C5, NOTE_C5, 0,
    NOTE_C5, NOTE_D5, NOTE_B4, NOTE_B4, 0,
    NOTE_A4, NOTE_G4, NOTE_A4, 0,

    NOTE_E4, NOTE_G4, NOTE_A4, NOTE_A4, 0,
    NOTE_A4, NOTE_B4, NOTE_C5, NOTE_C5, 0,
    NOTE_C5, NOTE_D5, NOTE_B4, NOTE_B4, 0,
    NOTE_A4, NOTE_G4, NOTE_A4, 0,

    NOTE_E4, NOTE_G4, NOTE_A4, NOTE_A4, 0,
    NOTE_A4, NOTE_C5, NOTE_D5, NOTE_D5, 0,
    NOTE_D5, NOTE_E5, NOTE_F5, NOTE_F5, 0,
    NOTE_E5, NOTE_D5, NOTE_E5, NOTE_A4, 0,

    NOTE_A4, NOTE_B4, NOTE_C5, NOTE_C5, 0,
    NOTE_D5, NOTE_E5, NOTE_A4, 0,
    NOTE_A4, NOTE_C5, NOTE_B4, NOTE_B4, 0,
    NOTE_C5, NOTE_A4, NOTE_B4, 0,

    NOTE_A4, NOTE_A4,
},
{NOTE_E3,NOTE_A3,NOTE_E4,NOTE_C4,NOTE_G4,NOTE_G4,0}
}
;
// duree des notes des melodies
int noteDurations[][78] = {{
    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 375, 125,

    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 375, 125,

    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 250, 125, 125,
    125, 125, 125, 250, 125,

    125, 125, 250, 125, 125,
    250, 125, 250, 125,
    125, 125, 250, 125, 125,
    125, 125, 375, 375,

    250, 125,
},{8,8,8,8,8,2,999} };

// // déclaration d’un tableau de 8 octets chiffre 3
// 1 pour pixel affiché – 0 pour pixel éteint
byte image30[8] = {B00000, B00000, B00011, B00111, B01111, B11111, B11110, B11100};
byte image31[8] = {B00000, B00000, B11000, B11100, B11110, B11111, B01111, B00111};
byte image32[8] = {B00111, B00111, B01110, B11110, B11110, B01110, B00111, B00111};
byte image33[8] = {B00111, B01111, B11111, B11110, B11100, B11000, B00000, B00000};
byte image34[8] = {B11100, B11110, B11111, B01111, B00111, B00011, B00000, B00000};
byte image35[8] = {B00000, B00000, B00000, B00011, B00011, B00000, B00000, B00000};
byte image20[8] = {B00000, B00000, B00011, B00111, B01111, B11111, B11110, B11100};
byte image21[8] = {B00000, B00000, B11000, B11100, B11110, B11111, B01111, B00111};
byte image22[8] = {B00111, B01110, B01110, B11100, B11100, B11000, B11000, B10000};
byte image23[8] = {B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00001};
byte image24[8] = {B00111, B00111, B01110, B01110, B11100, B11111, B11111, B11111};
byte image25[8] = {B00000, B00000, B00000, B00000, B00000, B11111, B11111, B11111};

void setup() {

  Serial.begin(9600);
  pinMode(cible0,INPUT);
  pinMode(cible1,INPUT);
  pinMode(cible2,INPUT);
  pinMode(cible3,INPUT);
  pinMode(cible4,INPUT);
  pinMode(cible5,INPUT);
  pinMode(PINStart, INPUT);

  // attacher les servos a leur pins
  unlockServos();

  delay(1000);
  // detache les servos de leur pins
  lockServos();

  lcd.backlight();
  lcd.clear();
  lcd.init();

  // initialise les variables moyenne pour les capteur de luminosité
  //initSensorLight();
}

void loop() {

  // demarrer le jeu ?
  if(digitalRead(PINStart) == HIGH){
    start = 1;
    stopMusique();
    points = 0;

  }

  switch (start) {
    case 1:
    // round 1
        demarrerRound(tempsRound[start],round1);
      break;
    case 2:
    // round 2
        delay(2000);
        demarrerRound(tempsRound[start],round2);
      break;
    default: 
      // joue la melodie toutes les 60 scondes si le jeu n'est pas lancé
      if(millis() > tempsMelody+60000 ){
        numeroMelody=0;
        boolMelody = 1;
        numeroNote = 0;
        numeroNoteBefore = 9;       
      }
      // appelle jouer de la musique     
      jouerMusique();
    break;
  }
}

// initialisation des capteurs de lumiere pour capter le laser en phase de jeu
void initSensorLight(){
  int totalCible=0;
  //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible0);
  }
  moyennecible0=totalCible/10;
  totalCible=0;
  //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible1);
  }
  moyennecible1=totalCible/10;
  totalCible=0;
  //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible2);
  }
  moyennecible2=totalCible/10;
  totalCible=0;
    //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible3);
  }
  moyennecible3=totalCible/10;
  totalCible=0;
    //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible4);
  }
  moyennecible4=totalCible/10;
  totalCible=0; 
    //for each sensor catch 10 value for better aim
  for (i=0;i<10;i++) {
    totalCible+=analogRead(cible5);
  }
  moyennecible5=totalCible/10;
  totalCible=0;

}

// avant de demarrer le jeu
void preStart(){

  pointsManche = 0;
  initSensorLight();

  lcd.clear();
  Serial.println("3");
  trois();
  tone(pinBuzzer,NOTE_FS4, 500);
  delay(1000);
  lcd.clear();
  Serial.println("2");
  deux();
  tone(pinBuzzer,NOTE_FS4, 500);
  delay(1000);
  lcd.clear();
  Serial.println("1");
  lcd.setCursor(0,3);
  lcd.print("1");
  tone(pinBuzzer,NOTE_FS4, 500);
  delay(1000);
  Serial.println("Go");
  lcd.setCursor(0,3);
  lcd.print("Go");
  tone(pinBuzzer,NOTE_F5, 500);
  
}

// detacher les servo pour eviter les tremblements
void lockServos(){
  monServo0.detach();
  monServo1.detach();
  monServo2.detach();  
  monServo3.detach();
  monServo4.detach();
  monServo5.detach(); 
}
// attacher les servo pour les utiliser
void unlockServos(){
  monServo0.attach(pinServo1);
  monServo1.attach(pinServo2);
  monServo2.attach(pinServo3);
  monServo3.attach(pinServo4);
  monServo4.attach(pinServo5);
  monServo5.attach(pinServo6);

  monServo0.write(15);
  monServo1.write(15);
  monServo2.write(15);
  monServo3.write(15);
  monServo4.write(15);
  monServo5.write(15);
}

// affiche le score de la manche( pour la v2 ) et jouer musique
void scoreManche(){

int tempsScore = millis ();
numeroMelody=1;
boolMelody = 1;
numeroNote = 0;
numeroNoteBefore = 9;
while(jouerMusique()== true){

}
// on joue la meoldie fin du stage

  Serial.print("Score Manche");
  Serial.println(pointsManche);

}

// fonction qui gere les position des cible et les shots, an parametre le temps du round et le tableau des positions des servos 
void demarrerRound(int tempsTempo,int tempoRound[][3]){

      unlockServos();
      preStart();
      tempsdebut=millis();
      stepSequence = 0;
      while((millis()-tempsdebut) < tempsTempo){
        if(( millis() - tempsdebut ) >= tempoRound[ stepSequence ][ 0 ]){   

          mesServos[tempoRound[ stepSequence ][1]].write(tempoRound[ stepSequence ][2]);

          // autoriser un tir sur cible si valeur degré >89 ok pour cible sinon desactivé
          if(tempoRound[ stepSequence ][2]> 89){
            cibleCapteur[tempoRound[ stepSequence ][1]]=1;
          }
          else{
            cibleCapteur[tempoRound[ stepSequence ][1]]=0;
          }

          stepSequence++;
        }


        // sequence pour receptionner les signaux
        if(cibleCapteur[0] == 1 ){
            if(analogRead(cible0)> moyennecible0 + 50){
                monServo0.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[0] = 0;
                Serial.println(" Cible 0 Touche");
                lcd.setCursor(0,3);
                lcd.print(" Cible 0 Touche");
                delay(500);
                tone(pinBuzzer,NOTE_DS8, 500);       
                digitalWrite(22, HIGH);
                delay(500);
                digitalWrite(22, LOW);
           }
        }

        if(cibleCapteur[1] == 1 ){
            if(analogRead(cible1)> moyennecible1 + 50){
                monServo1.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[1] = 0;
                Serial.println(" Cible 1 Touche");
                lcd.setCursor(0,3);
                lcd.print(" Cible 1 Touche");
                delay(500);
                tone(pinBuzzer,NOTE_DS8, 500);
                digitalWrite(23, HIGH);
                delay(500);
                digitalWrite(23, LOW); 
            }
        }

        if(cibleCapteur[2] == 1 ){
            if(analogRead(cible2)> moyennecible2 + 50){
                monServo2.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[2] = 0;
              Serial.println("Cible 2 Touche");
              lcd.setCursor(0,3);
              lcd.print(" Cible 2 Touche");
              delay(500);
              tone(pinBuzzer,NOTE_DS8, 500);
              digitalWrite(24, HIGH);
              delay(500);
              digitalWrite(24, LOW); 
            }
        }
        if(cibleCapteur[3] == 1 ){
            if(analogRead(cible3)> moyennecible3 + 50){
                monServo3.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[3] = 0;
                Serial.println(" Cible 3 Touche");
                lcd.setCursor(0,3);
                lcd.print(" Cible 3 Touche");
                delay(500);
                tone(pinBuzzer,NOTE_DS8, 500);
                digitalWrite(25, HIGH);
                delay(500);
                digitalWrite(25, LOW);                 
            }
        }
        if(cibleCapteur[4] == 1 ){
            if(analogRead(cible4)> moyennecible4 + 50){
                monServo4.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[4] = 0;
                Serial.println(" Cible 4 Touche");
                lcd.setCursor(0,3);
                lcd.print(" Cible 4 Touche");
                delay(500);
                tone(pinBuzzer,NOTE_DS8, 500);
                digitalWrite(26, HIGH);
                delay(500);
                digitalWrite(26, LOW);                 
            }
        }
        if(cibleCapteur[5] == 1 ){
            if(analogRead(cible5)> moyennecible5 + 50){
                monServo5.write(15); 
                pointsManche++;
                  // init cible pour eviter plusieurs tirs et points
                cibleCapteur[5] = 0;
                Serial.println(" Cible 5 Touche");
                lcd.setCursor(0,3);
                lcd.print(" Cible 5 Touche");
                delay(500);
                tone(pinBuzzer,NOTE_DS8, 500); 
                digitalWrite(27, HIGH);
                delay(500);
                digitalWrite(27, LOW);                
            }
        }
      }

      start++;
      lockServos();
      scoreManche(); 

}

// fonction jouer de la musique pour jouer le theme hors jeu et pendant les phases de score
bool jouerMusique(){

  if( boolMelody == 1 ){

  // depart du temps de reference de la melodie au temps 0
        if(numeroNote == 0){
          tempsMelody=millis();
        }

          // durée de la note en cours
        int noteDuration = 1000 / noteDurations[numeroMelody][numeroNote];

        if(numeroNote != numeroNoteBefore){
            numeroNoteBefore=numeroNote;     
            tone(pinBuzzer, melody[numeroMelody][numeroNote], noteDuration);

        // ici on calcule le temps qu'il faut avant de passer a la step suivante ( note suivante )
        pauseNotes = (noteDuration * 1.30) ;
        pauseNotes+=tempsMelody;

        }

        if(millis() >= pauseNotes){
            numeroNote+=1;
            tempsMelody=millis();
        }
        if(numeroNote >= (sizeof(noteDurations[numeroMelody])/sizeof(int)) || noteDurations[numeroMelody][numeroNote] == 999 ){
           boolMelody = 0;
           numeroNote = 0;
           numeroMelody = 0;
           numeroNoteBefore = 9;
           noTone(pinBuzzer);
           return false;
        }
  }  
  return true;
}

// arrete la musique
void stopMusique(){
  boolMelody = 0;
  numeroNote = 0;
  numeroMelody = 0;
}

void trois()
{
      // Create a new characters:
lcd.createChar(0, image30);
lcd.createChar(1, image31);
lcd.createChar(2, image32);
lcd.createChar(3, image33);
lcd.createChar(4, image34);
lcd.createChar(5, image35);

  lcd.clear(); // Efface l’écran.
  lcd.setCursor(8, 1);
  lcd.write(byte(0));
  lcd.setCursor(9, 1);
  lcd.write(byte(1));
  lcd.setCursor(9, 2);
  lcd.write(byte(2));
  lcd.setCursor(9, 3);
  lcd.write(byte(3));
  lcd.setCursor(8, 3);
  lcd.write(byte(4));
  lcd.setCursor(8, 2);
  lcd.write(byte(5));
}

void deux()
{
      // Create a new characters:
lcd.createChar(0, image20);
lcd.createChar(1, image21);
lcd.createChar(2, image22);
lcd.createChar(3, image23);
lcd.createChar(4, image24);
lcd.createChar(5, image25);

lcd.setCursor(8, 1);
lcd.write(byte(0));
lcd.setCursor(9, 1);
lcd.write(byte(1));
lcd.setCursor(9, 2);
lcd.write(byte(2));
lcd.setCursor(8, 2);
lcd.write(byte(3));
lcd.setCursor(8, 3);
lcd.write(byte(4));
lcd.setCursor(9, 3);
lcd.write(byte(5));
}