int clearPin = 8;   //Arduino pin 5 verbind met Pin 10, SRCLR(Clear/Reset) of 74HC595
int serialData = 5; //Arduino pin 6 verbind met Pin 14, SER(serial input) of 74HC595
int shiftClock = 7; //Arduino pin 7 verbind met Pin 11, SRCLK(shift clock) of 74HC595
int latchClock = 6; //Arduino pin 8 verbind met Pin 12, RCLK(storage/latch clock) of 74HC595 
int ground0 = 9;
int ground1 = 10;
int ground2 = 11;
int ground3 = 12;

//delay waardes
int ghostingDelay = 2;
int afwisselDelay = 2;

//array waar een 1 led aan betekent en 0 led uit
int bitArray[4][4][4] = { { {0, 0, 0, 0}, 
                            {1, 1, 1, 1}, 
                            {0, 1, 0, 0}, 
                            {0, 0, 0, 0} }, 

                          { {1, 1, 1, 1}, 
                            {1, 0, 0, 1}, 
                            {1, 0, 0, 1}, 
                            {1, 1, 1, 1} }, 

                          { {1, 1, 1, 1}, 
                            {1, 0, 0, 1}, 
                            {1, 0, 0, 1}, 
                            {1, 1, 1, 1} }, 

                          { {0, 0, 0, 0}, 
                            {1, 1, 1, 1}, 
                            {0, 1, 0, 0}, 
                            {0, 0, 0, 0} } }; 




int bitNummer; //het nummer dat gemaakt wordt uit de array om in shiftOut() te gebruiken
int bitNummer2;

int ledCount = 4; //Hoeveel leds per kleine array
int aantalLagen = 4; //Totaal aantal lagen
int aantalRijen = 4; //Aantal Rijen achter elkaar

//Welk patroon moet af gaan spelen
int welkPatroon = 0;

//Alle speciefieke patroon waarden
int beginPatroonEen = 0;
int beginPatroonTwee = 24;
int beginPatroonDrie = 37;
int beginPatroonVier = 50;
int beginPatroonVijf = 63;
int eindPatronen = 70;

//om tijdelijk waardes op te slaan
int temp;
int temp2;

void setup() { //runs once at startup
  Serial.begin(9600);
  pinMode(clearPin, OUTPUT);
  pinMode (shiftClock, OUTPUT);
  pinMode(latchClock, OUTPUT);
  pinMode(serialData, OUTPUT);
  pinMode(ground0, OUTPUT);
  pinMode(ground1, OUTPUT);
  pinMode(ground2, OUTPUT);
  pinMode(ground3, OUTPUT);
  
  //zet alle leds uit
  digitalWrite(clearPin, LOW); 
  digitalWrite(clearPin, HIGH); 

  //zet ground als ground
  digitalWrite(ground0, HIGH);
  digitalWrite(ground1, HIGH);
  digitalWrite(ground2, HIGH);
  digitalWrite(ground3, HIGH);
}

void loop() {
  int j;
  for(j = 0; j < 96; j++) {
    switch(j % 4) {
      case 0:
        digitalWrite(ground3, HIGH);
        keuze();
        output(0);
        digitalWrite(ground0, LOW);
        delay(afwisselDelay);
        break;
      case 1:
        digitalWrite(ground0, HIGH);
        keuze();
        output(1);
        digitalWrite(ground1, LOW);
        delay(afwisselDelay);
        break;
      case 2:
        digitalWrite(ground1, HIGH);
        keuze();
        output(2);
        digitalWrite(ground2, LOW);
        delay(afwisselDelay);
        break;
      case 3:
        digitalWrite(ground2, HIGH);
        keuze();
        output(3);
        digitalWrite(ground3, LOW);
        delay(afwisselDelay);
        break;
    }
  }
  welkPatroon++;
  if(welkPatroon >= eindPatronen) {
    welkPatroon = beginPatroonEen;
  }
}

//Zet het algemene stukje van shiftOut etc bij elkaar
void output(int laag) {
  digitalWrite(latchClock, LOW);
    //Geen updates terwijl de register gewijzigd wordt
    
  convert(laag);

  shiftOut(serialData, shiftClock, MSBFIRST, bitNummer2);
  shiftOut(serialData, shiftClock, MSBFIRST, bitNummer);  //stuurt bits naar de shiftregister

  digitalWrite(latchClock, HIGH);  //update het hele register
  delay(ghostingDelay);
}

//Zet een bit array om naar een nummer om in shift array 
void convert(int laag) {
  int m; 
  bitNummer = 0;
  bitNummer2 = 0;
  int multiplier = 1;
  //eerste 8
  for(m = 0; m < 8; m++) {
    if(m > 0) {
      multiplier *= 2;
    }
    if(m < 4) {
      bitNummer += (bitArray[laag][3][ledCount - 1 - m] * multiplier);
      bitNummer2 += (bitArray[laag][1][ledCount - 1 - m] * multiplier);
    } else {
      temp = m - 4;
      bitNummer += (bitArray[laag][2][ledCount - 1 - temp] * multiplier);
      //0 is de rechter rij
      bitNummer2 += (bitArray[laag][0][temp] * multiplier);
    }
  }
}

void keuze(){
  if (welkPatroon >= beginPatroonEen && welkPatroon < beginPatroonTwee) {
    vierSlangRondje();
  } else if (welkPatroon >= beginPatroonTwee && welkPatroon < beginPatroonDrie) {
    zRijAan();
  } else if (welkPatroon >= beginPatroonDrie && welkPatroon < beginPatroonVier) {
    xRijAan();
  } else if (welkPatroon >= beginPatroonVier && welkPatroon < beginPatroonVijf) {
    laagAan();
    temp2 = 0;
  } else if (welkPatroon >= beginPatroonVijf && welkPatroon < eindPatronen) {
    randomRegen();
  }
}

void zetCubeUit() {
  int y;
  int z;
  int x;
  for(y = 0; y < aantalLagen; y++) {
    for(z = 0; z < aantalRijen; z++) {
      for(x = 0; x < ledCount; x++) {
        bitArray[y][z][x] = 0;
      }
    }
  }
}

//laat een slangetje van 4 leds een rondje lopen op de cubes
void vierSlangRondje() {
  zetCubeUit();
  temp = welkPatroon % 12;
  int x;
  int y;
  int z;
  int s;
  for(s = 0; s < 4; s++) { // < 4 is de lengte van de slang
    temp2 = temp - s;
    if(temp2 < 0) {
      temp2 += 12;
    }
    switch(temp2) {
      case 0:
        z = 0;
        x = 0;
        break;
      case 1:
        z = 1;
        x = 0;
        break;
      case 2:
        z = 2;
        x = 0;
        break;
      case 3:
        z = 3;
        x = 0;
        break;
      case 4:
        z = 3;
        x = 1;
        break;
      case 5:
        z = 3;
        x = 2;
        break;
      case 6:
        z = 3;
        x = 3;
        break;
      case 7:
        z = 2;
        x = 3;
        break;
      case 8:
        z = 1;
        x = 3;
        break;
      case 9:
        z = 0;
        x = 3;
        break;
      case 10:
        z = 0;
        x = 2;
        break;
      case 11:
        z = 0;
        x = 1;
        break;
    }

    for(y = 0; y < aantalLagen; y++) {
      bitArray[y][z][x] = 1;
    }
  }
}

//zet 1 hele z rij aan
void zRijAan() {
  zetCubeUit();
  temp = welkPatroon - beginPatroonTwee;
  int x;
  int y;
  int z  = vervanger(temp);
  for(y = 0; y < aantalLagen; y++) {
    for(x = 0; x < ledCount; x++) {
      bitArray[y][z][x] = 1;
    }
  }
}

//zet 1 hele x rij aan
void xRijAan() {
  zetCubeUit();
  temp = welkPatroon - beginPatroonDrie;
  int x = vervanger(temp);
  int y;
  int z;
  for(y = 0; y < aantalLagen; y++) {
    for(z = 0; z < ledCount; z++) {
      bitArray[y][z][x] = 1;
    }
  }
}

//zet 1 laag tegelijk aan
void laagAan() {
  zetCubeUit();
  temp = welkPatroon - beginPatroonVier;
  int x;
  int y = vervanger(temp);
  int z;
  for(z = 0; z < aantalLagen; z++) {
    for(x = 0; x < ledCount; x++) {
      bitArray[y][z][x] = 1;
    }
  }
}

//de willekeurige regen op het eind
void randomRegen() {
  int x;
  int z;
  int q;
  if(welkPatroon > temp2) {
    if(welkPatroon == beginPatroonVijf) {
      zetCubeUit();
    }
    
      for(z = 0; z < 4; z++) {
        for(x = 0; x < 4; x++) {
          bitArray[0][z][x] = bitArray[1][z][x];
          bitArray[1][z][x] = bitArray[2][z][x];
          bitArray[2][z][x] = bitArray[3][z][x];
          bitArray[3][z][x] = random(0, 2);
       }
      }
    
    temp2 = welkPatroon;
  }
}

//switch om de stuiter soepel te laten lopen niet 2 keer zolang aan een zijkant vast hangen
int vervanger(int veelGebruik) {
  int terug;
  switch(veelGebruik) {
    case 0:
      terug = 0;
      break;
    case 1:
      terug = 1;
      break;
    case 2:
      terug = 2;
      break;
    case 3:
      terug = 3;
      break;
    case 4:
      terug = 2;
      break;
    case 5:
      terug = 1;
      break;
    case 6:
      terug = 0;
      break;
    case 7:
      terug = 1;
      break;
    case 8:
      terug = 2;
      break;
    case 9:
      terug = 3;
      break;
    case 10:
      terug = 2;
      break;
    case 11:
      terug = 1;
      break;
    case 12:
      terug = 0;
      break;
  }
  return terug;
}