//This is a sketch for the "Simon Says" project
//using a shift register, LEDs, the random and 
//randomSeed functions.

//globals
int randomValue;            //random value to be received from the random function
int LEDValue =1;            //value to correspond to the appropriate LED via the shift register
uint8_t simonSays [50];         //Simon Says (original pattern) array
uint8_t iSay [50];              //User Input array
int iSaySpot = 0;           //Current location of the user array

//global buttons that correspond to the LEDs with button1 corresponding with the LED on the far right
int btns[8] = {11, 10, 9, 8, 7, 6, 5, 4};

//globals for the shift register pins
int serialIn = 30;
int rclk = 32;
int sclk = 34;
int sclr = 36;

boolean finalAnsState = false;  //current state of if a final answer is being submitted
int finalAnsB = 26;             //final answer button to be pressed
int count;                      //how long the orignal pattern should be

void setup(){
  //preparing the shift register pins
  pinMode(serialIn, OUTPUT);
  pinMode(rclk, OUTPUT);
  pinMode(sclk, OUTPUT);
  pinMode(sclr, OUTPUT);
  //preparing the buttons on the PmodBTNs
  for(int i=0; i<8; i++){
    pinMode(btns[i], INPUT);
  }
  //preparing the final answer button
  pinMode(finalAnsB, INPUT);
  
  //setting the shift register pins
  digitalWrite(serialIn, LOW);
  digitalWrite(rclk, LOW);
  digitalWrite(sclk, LOW);
  digitalWrite(sclr, LOW);
  //clearing out the registers
  digitalWrite(rclk, HIGH);
  digitalWrite(rclk, LOW);
  digitalWrite(sclr, HIGH);
  delay(500);
  count = 1;
}//end of setup

void loop(){
  //resetting the arrays to all zeros
  for(int i=0; i<50; i++){
    simonSays[i]= 0;
    iSay[i]= 0;
  }
  
  //loop to display an LED pattern of the approripate length
  for(int j=0; j<count; j++){          //loop length changes based on if you got the previous pattern correct or not
    LEDValue = 1;                      //setting an initial value that will be placed in the shift register to light up the appropriate LED
    randomSeed(millis());              //choosing a random spot on the number sequence
    randomValue = random(1,9);         //picking a random number between 1 and 8
    LEDValue = LEDValue<<randomValue;  //turn the random number into the appropriate value for the shift register
    simonSays[j]=LEDValue;             //storing that value in an array
    //sending the value to the shift register with a predefined function, shiftOut
    digitalWrite(rclk, LOW);
    shiftOut(serialIn, sclk, LSBFIRST, LEDValue);
    digitalWrite(rclk, HIGH);
    delay(500);
      
    //sending a value of zero to all the LEDs to have them turn off before displaying the next value, if there is one
    digitalWrite(rclk, LOW);
    shiftOut(serialIn, sclk, LSBFIRST, 0);
    digitalWrite(rclk, HIGH);
    delay(250);
  }//end of Simon saying his pattern

  //while none of the buttons are being pressed, we will wait 1 millisecond
  while(digitalRead(btns[0])==LOW && digitalRead(btns[1])==LOW && digitalRead(btns[2])==LOW && digitalRead(btns[3])==LOW 
        && digitalRead(btns[4])==LOW && digitalRead(btns[5])==LOW && digitalRead(btns[6])==LOW && digitalRead(btns[7])==LOW && digitalRead(finalAnsB)==LOW){
    delay(1);
  }//end of while all the buttons are not being pressed
  
  iSaySpot = 0;  //setting the answer array location to the first spot
  
  //while the final answer has not been submitted, wait for a button to be pressed
  while(digitalRead(finalAnsB) == LOW){
    
    LEDValue = 1; //setting an initial value that will be placed in the shift register to light up the appropriate LED
    
    
    if(digitalRead(btns[0])==HIGH){
      btnPress(0);                    //defined function if the button corresponding to the 1st LED was pressed
    }
    
    if(digitalRead(btns[1])==HIGH){
      btnPress(1);                    //defined function if the button corresponding to the 2nd LED was pressed
    }
    
    if(digitalRead(btns[2])==HIGH){
      btnPress(2);                    //3rd LED
    }
    
    if(digitalRead(btns[3])==HIGH){
      btnPress(3);                    //and so on
    }
    
    if(digitalRead(btns[4])==HIGH){
      btnPress(4);
    }
    
    if(digitalRead(btns[5])==HIGH){
      btnPress(5);
    }
    
    if(digitalRead(btns[6])==HIGH){
      btnPress(6);
    }
    
    if(digitalRead(btns[7])==HIGH){
      btnPress(7);
    }
  }//end of while the finalAnsB is LOW
  
  
  //if the final answer button was pressed
  if(digitalRead(finalAnsB)==HIGH){
    finalAnsCheck();                  //defined function to compare LED patterns
  }
  
}//end of loop



////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/*                                                                            */
/*                        User Defined Functions                              */
/*                                                                            */
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////////
/*                                                                             */
/*       Function for lighting up LEDs when certain buttons are pressed        */
/*                                                                             */
/////////////////////////////////////////////////////////////////////////////////

void btnPress(int shift){
  LEDValue = LEDValue<<shift;                                     //adjusting the number
  iSay[iSaySpot] = LEDValue;                           //storing the adjusted number
  
  //sending the adjusted number to the shift register
  digitalWrite(rclk, LOW);
  shiftOut(serialIn, sclk, LSBFIRST, LEDValue);
  digitalWrite(rclk, HIGH);
  
  //wait for while the button is held
  while(digitalRead(btns[shift])==HIGH){
    delay(5);
  }//end of waiting for btn1 to stop being pressed
  delay(100);
  
  //resetting an initial value that will be placed in the shift register to light up the appropriate LED
  LEDValue = 1;                                        
  
  //turning off all of the LEDs
  digitalWrite(rclk, LOW);
  shiftOut(serialIn, sclk, LSBFIRST, 0);
  digitalWrite(rclk, HIGH);
  
  //incrementing to the next spot in the array storing the user answer
  iSaySpot++;
}//end of btn1Press


/////////////////////////////////////////////////////////////////////////////////
/*                                                                             */
/*  Function to see if the user submitted pattern matches the orignal pattern  */
/*                                                                             */
/////////////////////////////////////////////////////////////////////////////////

void finalAnsCheck(){
  //small time delay
  delay(1);
  
  //setting a final answer state to be a presumed "true: the answers match"
  finalAnsState = true;

  //another delay, just for fun
  delay(500);
  
  
  while(finalAnsState == true){             //while the answer is still true
    for(int i=0; i<50; i++){                //check every spot in both arrays
      if(simonSays[i] != iSay[i]){          //if the arrays do not match in a certain spot
      finalAnsState = false;                //set the final answer state to be "false: the answers do not match"
      i=50;                                 //stop the loop checking every spot
      }                                     //end of checking if the LEDValues are equal
    }                                       //end of looping through the arrays
    
  
    if(finalAnsState == true){              //if all of the LEDValues matched
      
      for(int good=0; good<3; good++){      //flash the green LEDs (numbers 5,6,7, and 8 or 240 in binary form) three times
        digitalWrite(rclk, LOW);
        shiftOut(serialIn, sclk, LSBFIRST, 240);
        digitalWrite(rclk, HIGH);
        delay(300);
        digitalWrite(rclk, LOW);
        shiftOut(serialIn, sclk, LSBFIRST, 0);
        digitalWrite(rclk, HIGH);
        delay(125);
      }                                      //end of flashing the green LEDs
      
      count++;                               //increase the original pattern length by 1
      LEDValue = 1;                          //resetting an initial value that will be placed in the shift register to light up the appropriate LED
    }                                        //end of if all of the LEDValues matched
    
    else{                                    //if all the LEDValues did not match
  
      for(int bad=0; bad<3; bad++){          //flash the red LEDs (numbers 1,2,3, and 4 or 15 in binary form) three times
        digitalWrite(rclk, LOW);
         shiftOut(serialIn, sclk, LSBFIRST, 15);
         digitalWrite(rclk, HIGH);
         delay(300);
         digitalWrite(rclk, LOW);
         shiftOut(serialIn, sclk, LSBFIRST, 0);
         digitalWrite(rclk, HIGH);
         delay(125);
      }                                      //end of flashing the red LEDs
      
      count = 1;                             //reset the original pattern length to just 1
      LEDValue = 1;                          //resetting an initial value that will be placed in the shift register to light up the appropriate LED
    }                                        //end of else if all the LEDValues did not match   
    
    finalAnsState = false;                  //setting the final answer state to false to break out of the while the presumed true since lights were already flashed
  }                                         //end of while the finalAnsState is true
  delay(750);                               //yet another delay
}//end of finalAnsCheck