// simondice.ino
// Programa para generar la seceuncia del juego simon dice.
// Autores: Equipo de 8vo del Liceo Willow, Salinas, Uruguay.

// DEFINICION DE PINES
#define   BUZZER   7
// Botones
#define   ENTRADA_A  10
#define   ENTRADA_B  11
#define   ENTRADA_C  12
#define   ENTRADA_D  13
// Leds conectados
#define   SALIDA_A   2
#define   SALIDA_B   3
#define   SALIDA_C   4
#define   SALIDA_D   5

// DEFINICION DE OTRAS VARIABLES
int melodia[ ] = {262, 196, 196, 220, 196, 0, 247, 262};
int duracionNotas[] = {4, 8, 8, 4, 4, 4, 4, 4};
int nivelActual = 1;
int velocidad = 500;
const int NIVEL_MAX = 100;
int secuencia[NIVEL_MAX];
int secuenciaUsuario[NIVEL_MAX];

//#########################################
void setup(){
   // ENTRADAS
   pinMode(ENTRADA_D, INPUT);
   pinMode(ENTRADA_C, INPUT);
   pinMode(ENTRADA_B, INPUT);
   pinMode(ENTRADA_A, INPUT);

   // SALIDAS
   pinMode(SALIDA_A, OUTPUT);
   pinMode(SALIDA_B, OUTPUT);
   pinMode(SALIDA_C, OUTPUT);
   pinMode(SALIDA_D, OUTPUT);

   // APAGAR LEDS
   digitalWrite(SALIDA_A, LOW);
   digitalWrite(SALIDA_B, LOW);
   digitalWrite(SALIDA_C, LOW);
   digitalWrite(SALIDA_D, LOW);
}
//#########################################
// Lanza por el pin 7 (buzzer) unos tonos alamacenados en el
// array melodia[]
void melodiaError(){
   for(int i = 0; i < 8; i++){
      int duracionNota = 1000/duracionNotas[i];
      tone(BUZZER, melodia[i], duracionNota); // Corrección aquí
      int pausaEntreNotas = duracionNota * 1.30;
      delay(pausaEntreNotas);
      noTone(BUZZER);
   }
}

//#########################################
void secuenciaError(){
   // Primero: prender todas las luces para alertar !!
   digitalWrite(SALIDA_A, HIGH);
   digitalWrite(SALIDA_B, HIGH);
   digitalWrite(SALIDA_C, HIGH);
   digitalWrite(SALIDA_D, HIGH);
   delay(250);
   // Tonos de error
   melodiaError();
   nivelActual = 1;
   velocidad = 500; 
   // Apagar Leds  
   digitalWrite(SALIDA_A, LOW);
   digitalWrite(SALIDA_B, LOW);
   digitalWrite(SALIDA_C, LOW);
   digitalWrite(SALIDA_D, LOW);
   delay(250);
}

//#########################################
// Genera en el array secuencia[] los 100 niveles
// (cada nivel es una luz o secuencia mas ..)
void generaSecuencia(){
   randomSeed(millis());
   for(int i = 0; i < NIVEL_MAX; i++){
      secuencia[i] = random(2,6);
   }
}
//######################################### 
void muestraSecuencia(){
   // Apagar leds
   digitalWrite(SALIDA_A, LOW);
   digitalWrite(SALIDA_B, LOW);
   digitalWrite(SALIDA_C, LOW);
   digitalWrite(SALIDA_D, LOW);
   
   // Emitir Tono segun la "secuencia actual".
   for(int i = 0; i < nivelActual; i++){
      if( secuencia[i] == SALIDA_A ){
         tone(BUZZER, 200);
         delay(200);
         noTone(BUZZER);
      }
      if( secuencia[i] == SALIDA_B ){
         tone(BUZZER, 300);
         delay(200);
         noTone(BUZZER);
      }
      if( secuencia[i] == SALIDA_C ){
         tone(BUZZER, 400);
         delay(200);
         noTone(BUZZER);
      }
      if( secuencia[i] == SALIDA_D ){
         tone(BUZZER, 500);
         delay(200);
         noTone(BUZZER);
      }

      // prende el Led correspondiente a la "secuencia actual"
      digitalWrite(secuencia[i], HIGH);
      delay(velocidad);
      digitalWrite(secuencia[i], LOW);
      delay(200);
   }
}
//#########################################
// Avanza de nivel e incrementa la velocidad del juego
void secuenciaCorrecta(){
   if(nivelActual < NIVEL_MAX)
      nivelActual++;
   velocidad -= 50;
   delay(200);
}

//#########################################
void leeSecuencia(){
   int flag = 0;
   // Para toda la secuencia alamacenada ...
   for(int i = 0; i < nivelActual; i++){
      flag = 0;
      // Leer el boton que presione el usuario
      // y compararlo con la secuencia generada por Simon
      // Si es correcta, avanzar el nivel e incrementar la velocidad
      // Si no, Generar el error y comenzar de nuevo
      while(flag == 0){
         if(digitalRead(ENTRADA_D) == 1){
            digitalWrite(SALIDA_D, HIGH);
            tone(BUZZER, 500);
            delay(200);
            noTone(BUZZER);
            secuenciaUsuario[i] = SALIDA_D;
            flag = 1;
            delay(200);
            if(secuenciaUsuario[i] != secuencia[i]){
               secuenciaError();
               return;
            }
            digitalWrite(SALIDA_D, LOW);
         }
         if(digitalRead(ENTRADA_C) == 1){
            digitalWrite(SALIDA_C, HIGH);
            tone(BUZZER, 400);
            delay(200);
            noTone(BUZZER);
            secuenciaUsuario[i] = SALIDA_C;
            flag = 1;
            delay(200);
            if(secuenciaUsuario[i] != secuencia[i]){
               secuenciaError();
               return;
            }
            digitalWrite(SALIDA_C, LOW);
         }
         if(digitalRead(ENTRADA_B) == 1){
            digitalWrite(SALIDA_B, HIGH);
            tone(BUZZER, 300);
            delay(200);
            noTone(BUZZER);
            secuenciaUsuario[i] = SALIDA_B;
            flag = 1;
            delay(200);
            if(secuenciaUsuario[i] != secuencia[i]){
               secuenciaError();
               return;
            }
            digitalWrite(SALIDA_B, LOW);
         }
         if(digitalRead(ENTRADA_A) == 1){
            digitalWrite(SALIDA_A, HIGH);
            tone(BUZZER, 200);
            delay(200);
            noTone(BUZZER);
            secuenciaUsuario[i] = SALIDA_A;
            flag = 1;
            delay(200);
            if(secuenciaUsuario[i] != secuencia[i]){
               secuenciaError();
               return;
            }
            digitalWrite(SALIDA_A, LOW);
         }
      }
   }
   secuenciaCorrecta();
}

//#########################################
// CODIGO PRINCIPAL
void loop(){

    // Generar secuencia SOLAMENTE si es nivel 1
    if(nivelActual == 1){
        generaSecuencia();
    }

    // Con la secuencia generada, JUGAR ....
    muestraSecuencia();
    leeSecuencia();
}

//############    FIN PROGRAMA   #################