// laat je groepjes leds aan en uitzetten zoals in "lights off". Nog in ontwikkeling.

const int xpin1 = A0;
const int xpin2 = A2;    
const int ypin1 = A1;
const int ypin2 = A3;
const int XMAX = 800 ; // min and max values for touchscreen hardcoded, could get recalibrated during use (see below)
const int XMIN = 80 ;
const int YMAX = 730 ;
const int YMIN = 80 ;


byte dispRam[5];


void setup() {
  Serial.begin(9600);
  dispRam[0]=0x00;
  dispRam[1]=0x00;
  dispRam[2]=0x00;
  dispRam[3]=0x00;
  dispRam[4]=0x00;

}

void loop() {

  int Xpos, Ypos, xper, yper;
  byte disprowpos, pixmap[5]={
    0,0,0,0,0          };
  enum gamestate {
    GAME_NEW=0, GAME_IN_PLAY=1, GAME_WON=2, RECAL_TOUCH=3        };
  static byte Gamestate; // op basis van gamestate besluiten wat te doen, nieuw bord initten, niks doen en laten spelen, of winstanimatie. byte moet dus heel blijven tussen runnen loop, dus static

  //Serial.print(Gamestate);
  //Serial.print("\n");

  switch(Gamestate){
  case GAME_NEW:
    // setup board, random.
    randomSeed(analogRead(5)); // seed random met adc waarde van floating pin

    for(byte i=0;i<5;i++){   // 5 keer de regels toepassen, zodat in theorie elk bit uit een rij (van de 5x5) getoggled kan zijn
      for(byte i=0;i<5;i++){ // van elke rij 1 bit setten, maar random welk bit
        byte shift = random(0,5);
        pixmap[i]=0x01<<shift;
      }

      // spelregels toepassen, zodat niet random bits geset worden, maar er een speelbare situatie ontstaat.
      switch(pixmap[0]){
      case 0x01:
        dispRam[0]=dispRam[0]^0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
        dispRam[1]=dispRam[1]^(0x01);
        break;
      case 0x02:
        dispRam[0]=dispRam[0]^0x07; 
        dispRam[1]=dispRam[1]^0x02;
        break; 
      case 0x04:
        dispRam[0]=dispRam[0]^0x0E; 
        dispRam[1]=dispRam[1]^0x04;
        break;
      case 0x08:
        dispRam[0]=dispRam[0]^0x1C; 
        dispRam[1]=dispRam[1]^0x08;
        break;
      case 0x10:
        dispRam[0]=dispRam[0]^0x18; 
        dispRam[1]=dispRam[1]^0x10;
        break;
      default:
        Serial.print("Board Setup Err /n");
        break;  
      }


      switch(pixmap[1]){
      case 0x01:
        dispRam[0]^=0x01;
        dispRam[1]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
        dispRam[2]^=0x01;
        break;
      case 0x02:
        dispRam[0]^=0x02;
        dispRam[1]^=0x07; 
        dispRam[2]^=0x02;
        break; 
      case 0x04:
        dispRam[0]^=0x04;
        dispRam[1]^=0x0E;
        dispRam[2]^=0x04;
        break;
      case 0x08:
        dispRam[0]^=0x08;
        dispRam[1]^=0x1C; 
        dispRam[2]^=0x08;
        break;
      case 0x10:
        dispRam[0]^=0x10;
        dispRam[1]^=0x18; 
        dispRam[2]^=0x10;
        break;
      default:
        Serial.print("Board Setup Err /n");
        break; 
      }

      switch(pixmap[2]){
      case 0x01:
        dispRam[1]^=0x01;
        dispRam[2]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
        dispRam[3]^=0x01;
        break;
      case 0x02:
        dispRam[1]^=0x02;
        dispRam[2]^=0x07; 
        dispRam[3]^=0x02;
        break; 
      case 0x04:
        dispRam[1]^=0x04;
        dispRam[2]^=0x0E;
        dispRam[3]^=0x04;
        break;
      case 0x08:
        dispRam[1]^=0x08;
        dispRam[2]^=0x1C; 
        dispRam[3]^=0x08;
        break;
      case 0x10:
        dispRam[1]^=0x10;
        dispRam[2]^=0x18; 
        dispRam[3]^=0x10;
        break;
      default:
        Serial.print("Board Setup Err /n");
        break; 
      }

      switch(pixmap[3]){
      case 0x01:
        dispRam[2]^=0x01;
        dispRam[3]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
        dispRam[4]^=0x01;
        break;
      case 0x02:
        dispRam[2]^=0x02;
        dispRam[3]^=0x07; 
        dispRam[4]^=0x02;
        break; 
      case 0x04:
        dispRam[2]^=0x04;
        dispRam[3]^=0x0E;
        dispRam[4]^=0x04;
        break;
      case 0x08:
        dispRam[2]^=0x08;
        dispRam[3]^=0x1C; 
        dispRam[4]^=0x08;
        break;
      case 0x10:
        dispRam[2]^=0x10;
        dispRam[3]^=0x18; 
        dispRam[4]^=0x10;
        break;
      default:
        Serial.print("Board Setup Err /n");
        break; 
      }  

      switch(pixmap[4]){
      case 0x01:
        dispRam[3]^=0x01;
        dispRam[4]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
        break;
      case 0x02:
        dispRam[3]^=0x02;
        dispRam[4]^=0x07; 
        break; 
      case 0x04:
        dispRam[3]^=0x04;
        dispRam[4]^=0x0E;
        break;
      case 0x08:
        dispRam[3]^=0x08;
        dispRam[4]^=0x1C;
        break;
      case 0x10:
        dispRam[3]^=0x10;
        dispRam[4]^=0x18; 
        break;
      default:
        Serial.print("Board Setup Err /n");
        break; 
      } 
    }
    // nu het bord is opgezet en de regels zijn toegepast, gaan we spelen:
    Gamestate=GAME_IN_PLAY; //spel gaan spelen
    break;
  case GAME_IN_PLAY:
    // invoer lezen en verwerken
    leestouchscreen(&Xpos, &Ypos, &xper, &yper);

    if(yper<=12); // yper van 12 tot 92, dus stapjes van 80/5=16 
    else                // percentages hardcoded. niet vanaf 0 om kleiner deel van te groot touchscreen te gebruiken
    if(yper<28) disprowpos=0x10; 
    else    
    if(yper<44) disprowpos=0x08; 
    else
      if(yper<60) disprowpos=0x04; 
      else
        if(yper<76) disprowpos=0x02; 
        else 
          if(yper<92) disprowpos=0x01;

    if(xper<=20); 
    else //xper loopt van 20 tot 80 in stapjes van 60/5=12
    if(xper<32) pixmap[0]=disprowpos; 
    else 
      if(xper<44) pixmap[1]=disprowpos; 
    else
      if(xper<56) pixmap[2]=disprowpos; 
      else
        if(xper<68) pixmap[3]=disprowpos; 
        else 
          if(xper<80)pixmap[4]=disprowpos;  


    // nu per pixel ook de naastgelegen pixels aanzetten. Dat wordt een vreselijke hoop ifjes of selects... Oh well, there we go.
    switch(pixmap[0]){
    case 0x01:
      dispRam[0]=dispRam[0]^0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
      dispRam[1]=dispRam[1]^(0x01);
      break;
    case 0x02:
      dispRam[0]=dispRam[0]^0x07; 
      dispRam[1]=dispRam[1]^0x02;
      break; 
    case 0x04:
      dispRam[0]=dispRam[0]^0x0E; 
      dispRam[1]=dispRam[1]^0x04;
      break;
    case 0x08:
      dispRam[0]=dispRam[0]^0x1C; 
      dispRam[1]=dispRam[1]^0x08;
      break;
    case 0x10:
      dispRam[0]=dispRam[0]^0x18; 
      dispRam[1]=dispRam[1]^0x10;
      break;
    }


    switch(pixmap[1]){
    case 0x01:
      dispRam[0]^=0x01;
      dispRam[1]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
      dispRam[2]^=0x01;
      break;
    case 0x02:
      dispRam[0]^=0x02;
      dispRam[1]^=0x07; 
      dispRam[2]^=0x02;
      break; 
    case 0x04:
      dispRam[0]^=0x04;
      dispRam[1]^=0x0E;
      dispRam[2]^=0x04;
      break;
    case 0x08:
      dispRam[0]^=0x08;
      dispRam[1]^=0x1C; 
      dispRam[2]^=0x08;
      break;
    case 0x10:
      dispRam[0]^=0x10;
      dispRam[1]^=0x18; 
      dispRam[2]^=0x10;
      break;
    }

    switch(pixmap[2]){
    case 0x01:
      dispRam[1]^=0x01;
      dispRam[2]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
      dispRam[3]^=0x01;
      break;
    case 0x02:
      dispRam[1]^=0x02;
      dispRam[2]^=0x07; 
      dispRam[3]^=0x02;
      break; 
    case 0x04:
      dispRam[1]^=0x04;
      dispRam[2]^=0x0E;
      dispRam[3]^=0x04;
      break;
    case 0x08:
      dispRam[1]^=0x08;
      dispRam[2]^=0x1C; 
      dispRam[3]^=0x08;
      break;
    case 0x10:
      dispRam[1]^=0x10;
      dispRam[2]^=0x18; 
      dispRam[3]^=0x10;
      break;
    }

    switch(pixmap[3]){
    case 0x01:
      dispRam[2]^=0x01;
      dispRam[3]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
      dispRam[4]^=0x01;
      break;
    case 0x02:
      dispRam[2]^=0x02;
      dispRam[3]^=0x07; 
      dispRam[4]^=0x02;
      break; 
    case 0x04:
      dispRam[2]^=0x04;
      dispRam[3]^=0x0E;
      dispRam[4]^=0x04;
      break;
    case 0x08:
      dispRam[2]^=0x08;
      dispRam[3]^=0x1C; 
      dispRam[4]^=0x08;
      break;
    case 0x10:
      dispRam[2]^=0x10;
      dispRam[3]^=0x18; 
      dispRam[4]^=0x10;
      break;
    }  

    switch(pixmap[4]){
    case 0x01:
      dispRam[3]^=0x01;
      dispRam[4]^=0x03; // bit zelf en naastliggende bits toggelen (door xor met mask)
      break;
    case 0x02:
      dispRam[3]^=0x02;
      dispRam[4]^=0x07; 
      break; 
    case 0x04:
      dispRam[3]^=0x04;
      dispRam[4]^=0x0E;
      break;
    case 0x08:
      dispRam[3]^=0x08;
      dispRam[4]^=0x1C;
      break;
    case 0x10:
      dispRam[3]^=0x10;
      dispRam[4]^=0x18; 
      break;
    } 

    for(byte i=0;i<100;i++){
      muxdisp(); // moet eigenlijk als interrupt. Dan hoef ik er geen rare lus omheen te breien om te kunnen wachten.
    }

    if((dispRam[0]==0)&&(dispRam[1]==0)&&(dispRam[2]==0)&&(dispRam[3]==0)&&(dispRam[4]==0)) Gamestate=GAME_WON;

    break;

  case GAME_WON:

    for(unsigned int i =0;i<5;i++){  
      dispRam[0]=0xFF;
      dispRam[1]=0xFF;
      dispRam[2]=0xFF;
      dispRam[3]=0xFF;
      dispRam[4]=0xFF;

      for(unsigned int i=0;i<100;i++){
        muxdisp(); // moet eigenlijk als interrupt. Dan hoef ik er geen rare lus omheen te breien om te kunnen wachten.
      }

      dispRam[0]=0;
      dispRam[1]=0;
      dispRam[2]=0;
      dispRam[3]=0;
      dispRam[4]=0;
      for(unsigned int i=0;i<100;i++){
        muxdisp(); // moet eigenlijk als interrupt. Dan hoef ik er geen rare lus omheen te breien om te kunnen wachten.
      }  
    }

    //todo: betere winstanimatie

    Gamestate=GAME_NEW;
    break;
    case RECAL_TOUCH:
    // TODO: touchscreen hercalibreren. Geef dots op hoekpunten weer en sla minimum en maximumwaarden voor X en Y op.
    break;
  }


  // unomment indien handig voor debugging:
  // Serial.print("Xper: ");
  // Serial.print(xper);
  // Serial.print(", Yper: ");
  // Serial.print(yper);
  //Serial.print("\n");


}



void leestouchscreen(int* Xpos, int* Ypos, int*Xper, int* Yper){
  static unsigned int Xmax=XMAX, Xmin=XMIN, Ymax=YMAX, Ymin=YMIN;  

  // een en ander kan efficienter met DDR, maar werkt wel.
  pinMode(ypin1,INPUT);
  pinMode(ypin2,INPUT);
  pinMode(xpin1,OUTPUT);
  pinMode(xpin2,OUTPUT);
  digitalWrite(xpin1,HIGH);
  digitalWrite(xpin2,LOW);
  *Xpos = analogRead(ypin1);    
  digitalWrite(xpin1,LOW); // to counteract floating input, but does not help

  // delay(50);

  pinMode(xpin1,INPUT);
  pinMode(xpin2,INPUT);  
  pinMode(ypin1,OUTPUT);
  pinMode(ypin2,OUTPUT);
  digitalWrite(ypin1,HIGH);
  digitalWrite(ypin2,LOW);
  *Ypos = analogRead(xpin1);    
  digitalWrite(ypin1,LOW);

  // uncomment to recalibrate xmin and ymin during use
  // if(Ymax<*Ypos) Ymax=*Ypos;
  // if(*Ypos<Ymin) Ymin=*Ypos;
  // if(Xmax<*Xpos) Xmax=*Xpos;
  // if(*Xpos<Xmin) Xmin=*Xpos;

  if((*Xpos>Xmin)&&(*Ypos>Ymin)){ 
    *Xper= ((*Xpos-Xmin)*100.0)/(Xmax-Xmin);
    *Yper= ((*Ypos-Ymin)*100.0)/(Ymax-Ymin);
    if(*Xper>100) *Xper=100;
    if(*Yper>100) *Yper = 100; 
  }
  else{
    *Xper=0;
    *Yper=0;
  }


  // uncomment for use in manual calibration
  Serial.print("Xmin: ");Serial.print(Xmin);
  Serial.print(" Ymin: ");Serial.print(Ymin);
  Serial.print(" Xmax: ");Serial.print(Xmax);
  Serial.print(" Ymax: ");Serial.print(Ymax);
  Serial.print(" Xper: ");Serial.print(*Xper);
  Serial.print(" Yper: ");Serial.print(*Yper);
  Serial.print("\n");

}


void muxdisp(){
  DDRD=(0xF8); //portd 3..7 zijn outputs voor LEDmatrix (0 en 1 zijn Rx/tx)
  DDRB=(0xFF); //PORTB idem

  PORTD=0xF0;

  for(byte i=0;i<5;i++){
    PORTB=dispRam[i];
    delay(1);
    PORTD=(PORTD<<1)+0x08;

  } 

}