// Trail of Gradients and Images
// Draws a trail of gradient in a column, where the mouse is pressed.
// Author: Byungwook Ethan Yoon
// Class: PUDT 1203 Creative Computing


int numberOfSquaresHorizontal = 8;
int numberOfSquaresVertical = 5;
int lengthOfSquares = 100;

int windowWidth = numberOfSquaresHorizontal * lengthOfSquares;
int windowHeight = numberOfSquaresVertical * lengthOfSquares;

int counter = 0; //keeps track of the movement of each block moving down
float swap = 255;
float store = 255;

float [][] grid = new float[numberOfSquaresVertical][numberOfSquaresHorizontal];
PImage [][] imageGrid = new PImage [numberOfSquaresVertical][numberOfSquaresHorizontal];

PImage imageSwap;
PImage imageStore;

void setup(){
  frameRate(10);
  noStroke();
 
  size(windowWidth, windowHeight);
  
  //assigns and draw all arrays with white blocks
  renew();
}


void draw(){
  //when mouse is pressed, then the trail of blocks fall in a single column where the cursor is placed.
  if(mousePressed){
    //when mouse cursor stays within the width of the column, then the trail of blocks fall in that column
    if(floor(mouseX/lengthOfSquares)==floor(pmouseX/lengthOfSquares)){
      if(floor(mouseX/lengthOfSquares)%2 == 1){
        colorPlacement(floor(mouseX/lengthOfSquares));
        drawSquares(floor(mouseX/lengthOfSquares));
      }
      else{
        preLoadImages(floor(mouseX/lengthOfSquares), floor(mouseX/lengthOfSquares));
        placeImages(floor(mouseX/lengthOfSquares));
      }
    }
    //when the mouse cursor leaves the column, the trail stops and turns blank
    else{
      renew();
    }
  }
  //when mouse is released, the trail stops and turns blank
  else{
    renew();
  }
}

//this function assigns color value to the trail of arrays in an assigned column
void colorPlacement(int column){


  
  //when the counter is less than or equal to the number of squares vertically, then assign a gradient of blacks  
  if(counter<=numberOfSquaresVertical){
    //first block is black, then pushes each block down with the lighter gradient block
    for(int row=0; row<=counter; row++){
      if(row<numberOfSquaresVertical-1){     
        if(row==0){
          store = grid[row][column];
          grid[0][column] = map(row, 0, numberOfSquaresVertical, 0, 255-(255/numberOfSquaresVertical)); 
        }
        swap = grid[row+1][column];
        grid[row+1][column] = store;
        store = swap;
      }
    }
    grid[0][column] = map(counter, 0, numberOfSquaresVertical, 0, 255-(255/numberOfSquaresVertical));
    counter++;
  }
  //when counter is greater than number of squares vertically, then assign white blocks until the last gradient block disappears
  else{
    //when the black block is at the bottom, then start pushing the gradient down with white blocks
    for(int row=0; row<numberOfSquaresVertical; row++){
      if(row<numberOfSquaresVertical-1){
        if(row==0){
          store = grid[row][column];
          grid[row][column] = 255;
        }
        swap = grid[row+1][column];
        grid[row+1][column] = store;
        store = swap;
      }
      else{
        //when all the gradient blocks are pushed out, then restart the trail
        if(grid[row][column]==255){
          renew();
        }
      }
    }
  }
}

//draw blocks on assigned column
void drawSquares(int column){
  int xPos = column*lengthOfSquares;
  int yPos = 0;
  
  for(int row=0; row<numberOfSquaresVertical; row++){
    if(column == 1){
      fill(grid[row][column],0,0);
    }
    else if(column == 3){
      fill(0,grid[row][column],0);
    }
    else if(column == 5){
      fill(0,0,grid[row][column]);
    }
    else if(column == 7){
      fill(grid[row][column]);
    }
    rect(xPos, yPos, lengthOfSquares, lengthOfSquares);
    yPos = yPos + lengthOfSquares;
  }
}


//assigns images to arrays
void preLoadImages(int column, int imageFolder){
 
  if(counter<=numberOfSquaresVertical){
    for(int row=0; row<=counter; row++){
      if(row<numberOfSquaresVertical-1){
        if(row==0){
          imageStore = imageGrid[row][column];
          imageGrid[0][column] = loadImage(imageFolder+"/"+counter+".jpg");
        }
        imageSwap = imageGrid[row+1][column];
        imageGrid[row+1][column] = imageStore;
        imageStore = imageSwap;
      } 
    }
    imageGrid[0][column] = loadImage(imageFolder+"/"+counter+".jpg");
  }
  //when counter is greater than number of squares vertically, then assign white blocks until the last portion of the image dissapears
  else{
    //when the first portion of the image is at the bottom, then start pushing the image down with white blocks
    for(int row=0; row<numberOfSquaresVertical; row++){
      if(row<numberOfSquaresVertical-1){
        if(row==0){
          imageStore = imageGrid[row][column];
          imageGrid[row][column] = loadImage(imageFolder+"/5.jpg");
        }
        imageSwap = imageGrid[row+1][column];
        imageGrid[row+1][column] = imageStore;
        imageStore = imageSwap;
      }
      else{
        //when all the image blocks are pushed out, then restart the trail
        if(counter==numberOfSquaresVertical*2){
          renew();
        }
      }
    }
  }
  counter++;
}

//draws the images
void placeImages(int column){
  int xPos = column*lengthOfSquares;
  int yPos = 0;
  
  for(int row=0; row<numberOfSquaresVertical; row++){
    image(imageGrid[row][column], xPos, yPos);
    yPos = yPos + lengthOfSquares;
  } 
}



//resets all blocks to white
void renew(){
  counter=0;
   
  //assigning white to each of the array box  
  for(int row=0; row<numberOfSquaresVertical; row++){
    for(int column=0; column<numberOfSquaresHorizontal; column++){
      if(column%2==1){
        grid[row][column] = 255;
      }
      else{
        imageGrid[row][column] = loadImage(column+"/5.jpg");
      }
    }
  }

  //draws the array box in its position with its color value or draws the white box image
  int yPos = 0;
  for(int row=0; row<numberOfSquaresVertical; row++){
    int xPos = 0;
    for(int column=0; column<numberOfSquaresHorizontal; column++){
      if(column%2==1){
        fill(grid[row][column]);
        rect(xPos, yPos, lengthOfSquares, lengthOfSquares);
      }
      else{
        image(imageGrid[row][column], xPos, yPos);
      }
      xPos = xPos + lengthOfSquares;
    }
    yPos = yPos + lengthOfSquares;
  }
}