//variables necesary to do the movement betwen the seasons
int screenCounter;
boolean doMovement;


////variables used in the terrain generation
//random position for the first object
float randomPositionX1 =random(25, 775);
float randomPositionY1 =random(25, 575);

//random position for the second object
float randomPositionX2 =random(25, 775);
float randomPositionY2 =random(25, 575);

//random position for the third object
float randomPositionX3 =random(25, 775);
float randomPositionY3 =random(25, 575);



////winter
//class rock for the winter
Rock winterRock1;
Rock winterRock2;
Rock winterRock3;
Rock winterRock4;
Rock winterRock5;
Rock winterRock6;
//class snow tree for the winter
SnowTree snowTree1;
SnowTree snowTree2;
SnowTree snowTree3;
SnowTree snowTree4;
SnowTree snowTree5;
SnowTree snowTree6;
SnowTree snowTree7;
SnowTree snowTree8;
SnowTree snowTree9;
SnowTree snowTree10;

////spring
//class flower for the spring
Flower flower1;
Flower flower2;
Flower flower3;
Flower flower4;
Flower flower5;
//class rock for the spring
Rock springRock1;
Rock springRock2;
Rock springRock3;
Rock springRock4;
Rock springRock5;
Rock springRock6;
//class green tree for the spring
GreenTree greenTree1;
GreenTree greenTree2;
GreenTree greenTree3;
GreenTree greenTree4;
GreenTree greenTree5;
GreenTree greenTree6;
GreenTree greenTree7;
GreenTree greenTree8;
GreenTree greenTree9;
GreenTree greenTree10;

////summer
//class rock for the summer
Rock summerRock1;
Rock summerRock2;
Rock summerRock3;
Rock summerRock4;
Rock summerRock5;
Rock summerRock6;
//class green tree for summer
WindyTree windyTree1;
WindyTree windyTree2;
WindyTree windyTree3;
WindyTree windyTree4;
WindyTree windyTree5;
WindyTree windyTree6;
WindyTree windyTree7;
WindyTree windyTree8;
WindyTree windyTree9;
WindyTree windyTree10;
WindyTree windyTree11;
WindyTree windyTree12;
WindyTree windyTree13;
WindyTree windyTree14;
WindyTree windyTree15;
WindyTree windyTree16;
WindyTree windyTree17;
WindyTree windyTree18;
WindyTree windyTree19;
WindyTree windyTree20;

////autumn
//class rock for the autumn
Rock autumnRock1;
Rock autumnRock2;
Rock autumnRock3;
Rock autumnRock4;
Rock autumnRock5;
Rock autumnRock6;
//class orange tree for autumn 
OrangeTree orangeTree1;
OrangeTree orangeTree2;
OrangeTree orangeTree3;
OrangeTree orangeTree4;
OrangeTree orangeTree5;
OrangeTree orangeTree6;
OrangeTree orangeTree7;
OrangeTree orangeTree8;
OrangeTree orangeTree9;
OrangeTree orangeTree10;
OrangeTree orangeTree11;
OrangeTree orangeTree12;
OrangeTree orangeTree13;
OrangeTree orangeTree14;
OrangeTree orangeTree15;
OrangeTree orangeTree16;
OrangeTree orangeTree17;
OrangeTree orangeTree18;
OrangeTree orangeTree19;
OrangeTree orangeTree20;

////halloween
//class rock for halloween
Rock halloweenRock1;
Rock halloweenRock2;
Rock halloweenRock3;
//class pumkin for hallowen
Pumkin pumkin1;
Pumkin pumkin2;
Pumkin pumkin3;
Pumkin pumkin4;
Pumkin pumkin5;
//class purple tree for halloween
PurpleTree purpleTree1;
PurpleTree purpleTree2;
PurpleTree purpleTree3;
PurpleTree purpleTree4;
PurpleTree purpleTree5;
PurpleTree purpleTree6;
PurpleTree purpleTree7;
PurpleTree purpleTree8;
PurpleTree purpleTree9;
PurpleTree purpleTree10;
PurpleTree purpleTree11;
PurpleTree purpleTree12;
PurpleTree purpleTree13;
PurpleTree purpleTree14;
PurpleTree purpleTree15;


void setup()
{
  //screen size  
  size(800, 600);
  rectMode(CENTER);
  noStroke();
  frameRate(12);
  ////winter
  //winter rock initialization
  winterRock1=new Rock();
  winterRock2=new Rock();
  winterRock3=new Rock();
  winterRock4=new Rock();
  winterRock5=new Rock();
  winterRock6=new Rock();
  //snow tree initialization
  snowTree1=new SnowTree();
  snowTree2=new SnowTree();
  snowTree3=new SnowTree();
  snowTree4=new SnowTree();
  snowTree5=new SnowTree();
  snowTree6=new SnowTree();
  snowTree7=new SnowTree();
  snowTree8=new SnowTree();
  snowTree9=new SnowTree();
  snowTree10=new SnowTree();

  ////spring
  //flower initialization
  flower1=new Flower();
  flower2=new Flower();
  flower3=new Flower();
  flower4=new Flower();
  flower5=new Flower();
  //spring rock initialization
  springRock1=new Rock();
  springRock2=new Rock();
  springRock3=new Rock();
  springRock4=new Rock();
  springRock5=new Rock();
  springRock6=new Rock();
  //green tree initialization
  greenTree1= new GreenTree();
  greenTree2= new GreenTree();
  greenTree3= new GreenTree();
  greenTree4= new GreenTree();
  greenTree5= new GreenTree();
  greenTree6= new GreenTree();
  greenTree7= new GreenTree();
  greenTree8= new GreenTree();
  greenTree9= new GreenTree();
  greenTree10= new GreenTree();

  ////summer
  //summer rock initialization
  summerRock1=new Rock();
  summerRock2=new Rock();
  summerRock3=new Rock();
  summerRock4=new Rock();
  summerRock5=new Rock();
  summerRock6=new Rock();
  //windy tree initialization
  windyTree1= new WindyTree();
  windyTree2= new WindyTree();
  windyTree3= new WindyTree();
  windyTree4= new WindyTree();
  windyTree5= new WindyTree();
  windyTree6= new WindyTree();
  windyTree7= new WindyTree();
  windyTree8= new WindyTree();
  windyTree9= new WindyTree();
  windyTree10= new WindyTree();
  windyTree11= new WindyTree();
  windyTree12= new WindyTree();
  windyTree13= new WindyTree();
  windyTree14= new WindyTree();
  windyTree15= new WindyTree();
  windyTree16= new WindyTree();
  windyTree17= new WindyTree();
  windyTree18= new WindyTree();
  windyTree19= new WindyTree();
  windyTree20= new WindyTree();

  ////autumn
  //autumn rock initialization
  autumnRock1= new Rock();
  autumnRock2= new Rock();
  autumnRock3= new Rock();
  autumnRock4= new Rock();
  autumnRock5= new Rock();
  autumnRock6= new Rock();
  //orange tree initialization
  orangeTree1=new OrangeTree();
  orangeTree2=new OrangeTree();
  orangeTree3=new OrangeTree();
  orangeTree4=new OrangeTree();
  orangeTree5=new OrangeTree();
  orangeTree6=new OrangeTree();
  orangeTree7=new OrangeTree();
  orangeTree8=new OrangeTree();
  orangeTree9=new OrangeTree();
  orangeTree10=new OrangeTree();
  orangeTree11=new OrangeTree();
  orangeTree12=new OrangeTree();
  orangeTree13=new OrangeTree();
  orangeTree14=new OrangeTree();
  orangeTree15=new OrangeTree();
  orangeTree16=new OrangeTree();
  orangeTree17=new OrangeTree();
  orangeTree18=new OrangeTree();
  orangeTree19=new OrangeTree();
  orangeTree20=new OrangeTree();

  ////halloween
  //halloween rock initialization
  halloweenRock1=new Rock();
  halloweenRock2=new Rock();
  halloweenRock3=new Rock();
  //pumpkin initialization
  pumkin1=new Pumkin();
  pumkin2=new Pumkin();
  pumkin3=new Pumkin();
  pumkin4=new Pumkin();
  pumkin5=new Pumkin();
  //Purple tree initialization
  purpleTree1=new PurpleTree();
  purpleTree2=new PurpleTree();
  purpleTree3=new PurpleTree();
  purpleTree4=new PurpleTree();
  purpleTree5=new PurpleTree();
  purpleTree6=new PurpleTree();
  purpleTree7=new PurpleTree();
  purpleTree8=new PurpleTree();
  purpleTree9=new PurpleTree();
  purpleTree10=new PurpleTree();
  purpleTree11=new PurpleTree();
  purpleTree12=new PurpleTree();
  purpleTree13=new PurpleTree();
  purpleTree14=new PurpleTree();
  purpleTree15=new PurpleTree();



  screenCounter = 1;
}
void draw()
{
  startScreen();
  movement();
  startScreen();

  //the four seasons
  winter();
  spring();
  summer();
  autumn();

  //halloween
  halloween();

  endScreen();
}
//
//when the space bar is pressed the movement goes to true
void keyPressed()
{
  if (key == ' ');
  {
    doMovement = true;
  }
}
//when the space bar is not pressed the movement goes to false
void keyReleased()
{
  if (key == ' ');
  {
    doMovement= false;
  }
}
//when mouse is pressed set the movement to true
void mousePressed()
{
  doMovement = true;
}
//when mouse is not pressed set the movement to false
void mouseReleased()
{
  doMovement= false;
}
//if the movement is true set the counter to counter plus one
void movement()
{
  if (doMovement == true)
  {
    screenCounter= screenCounter + 1;
  }
}
//the begining screen that teaches the player and guives instructions
void startScreen()
{
  if (screenCounter == 1)
  {
    background(#666666);
    fill(0);


    //Text input in the start screen to guide the player on how to use the interactive toy
    textSize(14.7);
    fill(#f5e353);
    text("To navigate trough the four seasons (plus halloween) please press the spacebar or click on it with the mouse.", 10, 150);
    fill(#93cf20);
    text("Every time you open this program the positions and the arrangment of the terrain change randomly.", 10, 200);
  }
}
//winter season, including snow trees and rocks
void winter()
{
  if (screenCounter == 2)
  {
    //first layer of snow
    background(225);

    //first layer of grass
    fill(#41CA41);
    rect(randomPositionX1, randomPositionY1, 600, 600, 50);
    rect(randomPositionX2, randomPositionY2, 600, 600, 50);
    rect(randomPositionX3, randomPositionY3, 600, 600, 50);

    //second layer of snow
    fill(240);
    rect(randomPositionX1, randomPositionY1, 500, 500, 50);
    rect(randomPositionX2, randomPositionY2, 500, 500, 50);
    rect(randomPositionX3, randomPositionY3, 500, 500, 50);

    //second layer of grass
    fill(#52FF52);
    rect(randomPositionX1, randomPositionY1, 300, 300, 50);
    rect(randomPositionX2, randomPositionY2, 300, 300, 50);
    rect(randomPositionX3, randomPositionY3, 300, 300, 50);

    //third layer of snow
    fill(255);
    rect(randomPositionX1, randomPositionY1, 240, 240, 50);
    rect(randomPositionX2, randomPositionY2, 240, 240, 50);
    rect(randomPositionX3, randomPositionY3, 240, 240, 50);



    //Rock draw for the winter season
    winterRock1.drawRock();
    winterRock2.drawRock();
    winterRock3.drawRock();
    winterRock4.drawRock();
    winterRock5.drawRock();
    winterRock6.drawRock();

    //Tree draw for the winter season
    snowTree1.drawSnowTree();
    snowTree2.drawSnowTree();
    snowTree3.drawSnowTree();
    snowTree4.drawSnowTree();
    snowTree5.drawSnowTree();
    snowTree6.drawSnowTree();
    snowTree7.drawSnowTree();
    snowTree8.drawSnowTree();
    snowTree9.drawSnowTree();
    snowTree10.drawSnowTree();
  }
}
//spring season incluyding flowers, rock and windy trees
void spring()
{
  if (screenCounter == 3)
  {
    //first layer of ground
    background(#00D037);

    //second layer of ground
    fill(#00E63D);
    rect(randomPositionX1, randomPositionY1, 500, 500, 50);   
    rect(randomPositionX2, randomPositionY2, 500, 500, 50);
    rect(randomPositionX3, randomPositionY3, 500, 500, 50);

    //third layer of ground
    fill(#00FF44);
    rect(randomPositionX1, randomPositionY1, 250, 250, 50);
    rect(randomPositionX2, randomPositionY2, 250, 250, 50);
    rect(randomPositionX3, randomPositionY3, 250, 250, 50);

    //flowers draw for the spring season 
    flower1.drawFlower();
    flower2.drawFlower();
    flower3.drawFlower();
    flower4.drawFlower();
    flower5.drawFlower();

    //rocks draw for the spring season
    springRock1.drawRock();
    springRock2.drawRock();
    springRock3.drawRock();
    springRock4.drawRock();
    springRock5.drawRock();
    springRock6.drawRock();

    //green tree draw for the spring season
    greenTree1.drawGreenTree();
    greenTree2.drawGreenTree();
    greenTree3.drawGreenTree();
    greenTree4.drawGreenTree();
    greenTree5.drawGreenTree();
    greenTree6.drawGreenTree();
    greenTree7.drawGreenTree();
    greenTree8.drawGreenTree();
    greenTree9.drawGreenTree();
    greenTree10.drawGreenTree();
  }
}

void summer()
{
  if (screenCounter == 4)
  {
    //first layer of grass
    background(#4AC900);

    //first layer of ground
    fill(#BA7600);
    rect(randomPositionX1, randomPositionY1, 550, 550, 50);   
    rect(randomPositionX2, randomPositionY2, 550, 550, 50);
    rect(randomPositionX3, randomPositionY3, 550, 550, 50);

    //second layer of grass
    fill(#52E100);
    rect(randomPositionX1, randomPositionY1, 500, 500, 50);   
    rect(randomPositionX2, randomPositionY2, 500, 500, 50);
    rect(randomPositionX3, randomPositionY3, 500, 500, 50);

    //second layer of ground
    fill(#E19005);
    rect(randomPositionX1, randomPositionY1, 300, 300, 50);
    rect(randomPositionX2, randomPositionY2, 300, 300, 50);
    rect(randomPositionX3, randomPositionY3, 300, 300, 50);

    //third layer of grass
    fill(#5BF900);
    rect(randomPositionX1, randomPositionY1, 250, 250, 50);
    rect(randomPositionX2, randomPositionY2, 250, 250, 50);
    rect(randomPositionX3, randomPositionY3, 250, 250, 50);

    //summer rock draw for the summer season 
    summerRock1.drawRock();
    summerRock2.drawRock();
    summerRock3.drawRock();
    summerRock4.drawRock();
    summerRock5.drawRock();
    summerRock6.drawRock();

    //windy tree draw for the summer season
    windyTree1.drawWindyTree();
    windyTree2.drawWindyTree();
    windyTree3.drawWindyTree();
    windyTree4.drawWindyTree();
    windyTree5.drawWindyTree();
    windyTree6.drawWindyTree();
    windyTree7.drawWindyTree();
    windyTree8.drawWindyTree();
    windyTree9.drawWindyTree();
    windyTree10.drawWindyTree();
    windyTree11.drawWindyTree();
    windyTree12.drawWindyTree();
    windyTree13.drawWindyTree();
    windyTree14.drawWindyTree();
    windyTree15.drawWindyTree();
    windyTree16.drawWindyTree();
    windyTree17.drawWindyTree();
    windyTree18.drawWindyTree();
    windyTree19.drawWindyTree();
    windyTree20.drawWindyTree();
  }
}

void autumn()
{
  if (screenCounter == 5)
  {
    //first layer of ground
    background(#DEAA00);

    //second layer of ground
    fill(#C37D05);
    rect(randomPositionX1, randomPositionY1, 600, 600, 50);   
    rect(randomPositionX2, randomPositionY2, 600, 600, 50);
    rect(randomPositionX3, randomPositionY3, 600, 600, 50);

    //third layer of ground
    fill(#EEB600);
    rect(randomPositionX1, randomPositionY1, 500, 500, 50);   
    rect(randomPositionX2, randomPositionY2, 500, 500, 50);
    rect(randomPositionX3, randomPositionY3, 500, 500, 50);

    //fourth layer of ground
    fill(#E29003);
    rect(randomPositionX1, randomPositionY1, 300, 300, 50);
    rect(randomPositionX2, randomPositionY2, 300, 300, 50);
    rect(randomPositionX3, randomPositionY3, 300, 300, 50);

    //fift layer of ground
    fill(#FFC400);
    rect(randomPositionX1, randomPositionY1, 250, 250, 50);
    rect(randomPositionX2, randomPositionY2, 250, 250, 50);
    rect(randomPositionX3, randomPositionY3, 250, 250, 50);

    //autumn rock draw for the autumn season
    autumnRock1.drawRock();
    autumnRock2.drawRock();
    autumnRock3.drawRock();
    autumnRock4.drawRock();
    autumnRock5.drawRock();
    autumnRock6.drawRock();
    //orange trees draw for the autumn season
    orangeTree1.drawOrangeTree();
    orangeTree2.drawOrangeTree();
    orangeTree3.drawOrangeTree();
    orangeTree4.drawOrangeTree();
    orangeTree5.drawOrangeTree();
    orangeTree6.drawOrangeTree();
    orangeTree7.drawOrangeTree();
    orangeTree8.drawOrangeTree();
    orangeTree9.drawOrangeTree();
    orangeTree10.drawOrangeTree();
    orangeTree11.drawOrangeTree();
    orangeTree12.drawOrangeTree();
    orangeTree13.drawOrangeTree();
    orangeTree14.drawOrangeTree();
    orangeTree15.drawOrangeTree();
    orangeTree16.drawOrangeTree();
    orangeTree17.drawOrangeTree();
    orangeTree18.drawOrangeTree();
    orangeTree19.drawOrangeTree();
    orangeTree20.drawOrangeTree();
  }
}

void halloween()
{
  if (screenCounter == 6)
  {
    //first layer of ground
    background(#B66FCB);

    //second layer of ground
    fill(#84359C);
    rect(randomPositionX1, randomPositionY1, 600, 600, 50);   
    rect(randomPositionX2, randomPositionY2, 600, 600, 50);
    rect(randomPositionX3, randomPositionY3, 600, 600, 50);

    //third layer of ground
    fill(#CF7EE8);
    rect(randomPositionX1, randomPositionY1, 500, 500, 50);   
    rect(randomPositionX2, randomPositionY2, 500, 500, 50);
    rect(randomPositionX3, randomPositionY3, 500, 500, 50);

    //fourth layer of ground
    fill(#AD58C7);
    rect(randomPositionX1, randomPositionY1, 300, 300, 50);
    rect(randomPositionX2, randomPositionY2, 300, 300, 50);
    rect(randomPositionX3, randomPositionY3, 300, 300, 50);

    //fift layer of ground
    fill(#E58DFF);
    rect(randomPositionX1, randomPositionY1, 250, 250, 50);
    rect(randomPositionX2, randomPositionY2, 250, 250, 50);
    rect(randomPositionX3, randomPositionY3, 250, 250, 50);

    //halloween rocks draw for halloween
    halloweenRock1.drawRock();
    halloweenRock2.drawRock();
    halloweenRock3.drawRock();
    //pumpkings draw for halloween
    pumkin1.drawPumkin();
    pumkin2.drawPumkin();
    pumkin3.drawPumkin();
    pumkin4.drawPumkin();
    pumkin5.drawPumkin();
    //purple trees draw for halloween
    purpleTree1.drawPurpleTree();
    purpleTree2.drawPurpleTree();
    purpleTree3.drawPurpleTree();
    purpleTree4.drawPurpleTree();
    purpleTree5.drawPurpleTree();
    purpleTree6.drawPurpleTree();
    purpleTree7.drawPurpleTree();
    purpleTree8.drawPurpleTree();
    purpleTree9.drawPurpleTree();
    purpleTree10.drawPurpleTree();
    purpleTree11.drawPurpleTree();
    purpleTree12.drawPurpleTree();
    purpleTree13.drawPurpleTree();
    purpleTree14.drawPurpleTree();
    purpleTree15.drawPurpleTree();
  }
}

void endScreen()
{
  if (screenCounter == 7)
  {
    screenCounter = 1;
  }
}

class Flower
{
  //variable that change the red,green and blue hues to generate a new color for the flowers
  float treeColorR = random(178, 255); 
  float treeColorG = random(100, 255); 
  float treeColorB = 120; 
  //variable for the flower size
  float flowerSize = random(5, 15);

  //use of PVector class for the diferent positions of the flowers
  PVector position1;
  PVector position2;
  PVector position3;
  PVector position4;
  PVector position5;
  PVector position6;

  Flower()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();
    //position for the flower1
    position1=new PVector(random(25, 775), random(25, 575));
    //position for the flower 2
    position2=new PVector(random(25, 775), random(25, 575));
    //position for the flower 3
    position3=new PVector(random(25, 775), random(25, 575));
    //position for the flower 4
    position4=new PVector(random(25, 775), random(25, 575));
    //position for the flower 5
    position5=new PVector(random(25, 775), random(25, 575));
    //position for the flower 6
    position6=new PVector(random(25, 775), random(25, 575));
  }

  void drawFlower()
  {

    ////flower1
    fill(treeColorR, treeColorG, treeColorB);
    rect(position1.x, position1.y, flowerSize, flowerSize, 15);

    ////flower2
    fill(treeColorR, treeColorG, treeColorB);
    rect(position2.x, position3.y, flowerSize, flowerSize, 15);

    ////flower3
    fill(treeColorR, treeColorG, treeColorB);
    rect(position3.x, position3.y, flowerSize, flowerSize, 15);

    ////flower4
    fill(treeColorR, treeColorG, treeColorB);
    rect(position4.x, position4.y, flowerSize, flowerSize, 15);

    ////flower5
    fill(treeColorR, treeColorG, treeColorB);
    rect(position5.x, position5.y, flowerSize, flowerSize, 15);

    ////flower6
    fill(treeColorR, treeColorG, treeColorB);
    rect(position6.x, position6.y, flowerSize, flowerSize, 15);
  }
}

class GreenTree
{
  float treeColorR = random(0, 100); 
  float treeColorB = random(0, 100); 

  //array for the diferent greens
  float[] greens = new float[4];
  //array for the diferent tree sizes
  float[] treeSizes = new float[4];
  //PVector for the random position of the green tree
  PVector position;


  GreenTree()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();
    //declaration of the array for the green color
    greens[0] = random(130, 160);
    greens[1] = random(160, 190);
    greens[2] = random(190, 220);
    greens[3] = random(220, 255);
    //declaration of the array for the tree sizes
    treeSizes[0] = random (40, 65);
    treeSizes[1] = random (30, 40);
    treeSizes[2] = random (20, 30);
    treeSizes[3] = random (5, 20);

    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawGreenTree()
  {

    ////layer 1
    fill(treeColorR, greens[0], treeColorB);
    rect(position.x, position.y, treeSizes[0], treeSizes[0], 15);

    ////layer 2
    fill(treeColorR, greens[1], treeColorB);
    rect(position.x, position.y, treeSizes[1], treeSizes[1], 15);

    ////layer 3
    fill(treeColorR, greens[2], treeColorB);
    rect(position.x, position.y, treeSizes[2], treeSizes[2], 15);

    ////layer 4
    fill(treeColorR, greens[3], treeColorB);
    rect(position.x, position.y, treeSizes[3], treeSizes[3], 15);
  }
}

class OrangeTree
{
  //variables that makes the red and blue hue change giving it a new color
  float treeColorR = random(220, 255); 
  float treeColorB = random(0, 100); 

  //array for the diferent greens
  float[] greens = new float[4];
  //array for the diferent tree sizes
  float[] treeSizes = new float[4];

  PVector position;


  OrangeTree()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();
    //declaration of the array for the green color
    greens[0] = random(130, 160);
    greens[1] = random(160, 190);
    greens[2] = random(190, 220);
    greens[3] = random(220, 255);
    //declaration of the array for the tree sizes
    treeSizes[0] = random (40, 65);
    treeSizes[1] = random (30, 40);
    treeSizes[2] = random (20, 30);
    treeSizes[3] = random (5, 20);

    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawOrangeTree()
  {

    ////layer 1
    fill(treeColorR, greens[0], treeColorB);
    rect(position.x, position.y, treeSizes[0], treeSizes[0], 15);

    ////layer 2
    fill(treeColorR, greens[1], treeColorB);
    rect(position.x, position.y, treeSizes[1], treeSizes[1], 15);

    ////layer 3
    fill(treeColorR, greens[2], treeColorB);
    rect(position.x, position.y, treeSizes[2], treeSizes[2], 15);

    ////layer 4
    fill(treeColorR, greens[3], treeColorB);
    rect(position.x, position.y, treeSizes[3], treeSizes[3], 15);
  }
}

class Pumkin
{
  float layer1Size = random(60, 70);
  float layer2Size = random(40, 50);

  PVector position;

  Pumkin()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();
    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawPumkin()
  {

    ////layer 1
    fill(255, 255, 0, 30);
    rect(position.x, position.y, random(60, 70), random(60, 70), 15);

    ////layer 2
    fill(255, 255, 0, 30);
    rect(position.x, position.y, random(40, 45), random(40, 45), 15);

    ////layer 3
    fill(200, 90, 0);
    rect(position.x, position.y, 20, 20, 5);

    ////layer 3
    fill(255, 150, 0);
    rect(position.x, position.y, 16, 16, 10);
  }
}

class PurpleTree
{
  //variables that makes the green hue change giving it a new color
  float treeColorG = random(0, 100); 


  //arrays that makes the red and blue hue change giving it a new color
  float[] reds = new float[4];
  float[] blues = new float[4];
  //array for the diferent tree sizes
  float[] treeSizes = new float[4];
  //PVector for the random x and y position
  PVector position;


  PurpleTree()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();
    //declaration of the array for the reds
    reds[0] = random(130, 160);
    reds[1] = random(160, 190);
    reds[2] = random(190, 220);
    reds[3] = random(220, 255);
    //declaration of the array for the blues
    blues[0] = random(130, 160);
    blues[1] = random(160, 190);
    blues[2] = random(190, 220);
    blues[3] = random(220, 255);
    //declaration of the array for the tree sizes
    treeSizes[0] = random (40, 65);
    treeSizes[1] = random (30, 40);
    treeSizes[2] = random (20, 30);
    treeSizes[3] = random (5, 20);

    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawPurpleTree()
  {

    ////layer 1
    fill(reds[0], treeColorG, blues[0]);
    rect(position.x, position.y, treeSizes[0], treeSizes[0], 15);

    ////layer 2
    fill(reds[1], treeColorG, blues[1]);
    rect(position.x, position.y, treeSizes[1], treeSizes[1], 15);

    ////layer 3
    fill(reds[2], treeColorG, blues[2]);
    rect(position.x, position.y, treeSizes[2], treeSizes[2], 15);

    ////layer 4
    fill(reds[3], treeColorG, blues[3]);
    rect(position.x, position.y, treeSizes[3], treeSizes[3], 15);
  }
}

class Rock
{
  float rockColor1 = random(120, 150);
  float rockColor2 = random(150, 200);
  float rockColor3 = random(200, 230);

  float randomPosition1 = random(-20, 20);
  float randomPosition2 = random(-20, 20);

  //array for the rock sizes
  float[] treeSizesX = new float[3];
  float[] treeSizesY = new float[3];

  PVector position;


  Rock()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();

    //declaration of the array for the X size
    treeSizesX[0] = random (40, 65);
    treeSizesX[1] = random (30, 40);
    treeSizesX[2] = random (20, 30);

    //declaration of the array for the Y size
    treeSizesY[0] = random (60, 75);
    treeSizesY[1] = random (40, 60);
    treeSizesY[2] = random (30, 40);


    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawRock()
  {


    ////layer 1
    fill(rockColor1, rockColor1, rockColor1);
    rect(position.x, position.y, treeSizesX[0], treeSizesY[0], 3);

    ////layer 2
    fill(rockColor2, rockColor2, rockColor2);
    rect(position.x+randomPosition1, position.y, treeSizesX[1], treeSizesY[1], 3);

    ////layer 3
    fill(rockColor3, rockColor3, rockColor3);
    rect(position.x+randomPosition2, position.y, treeSizesX[2], treeSizesY[2], 3);
  }
}

class SnowTree
{
  //variables that makes the red and blue hue change giving it a new color
  float treeColorR = random(0, 100); 
  float treeColorB = random(0, 100); 

  //array for the diferent green color
  float[] greens = new float[4];
//array for the diferent tree sizes
  float[] treeSizes = new float[4];

  PVector position;


  SnowTree()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();

    //declaration of the array for the green color
    greens[0] = random(130, 160);
    greens[1] = random(160, 190);
    greens[2] = random(190, 220);
    greens[3] = random(220, 255);
    //declaration of the array for the tree sizes
    treeSizes[0] = random (40, 65);
    treeSizes[1] = random (30, 40);
    treeSizes[2] = random (20, 30);
    treeSizes[3] = random (5, 20);

    position=new PVector(random(25, 775), random(25, 575));
  }

  void drawSnowTree()
  {

    ////layer 1
    fill(treeColorR, greens[0], treeColorB);
    rect(position.x, position.y, treeSizes[0], treeSizes[0], 15);

    ////layer 1.5
    fill(#E9FFEA);
    rect(position.x, position.y, treeSizes[0]-8, treeSizes[0]-8, 15);

    ////layer 2
    fill(treeColorR, greens[1], treeColorB);
    rect(position.x, position.y, treeSizes[1], treeSizes[1], 15);

    ////layer 2.5
    fill(#E9FFEA);
    rect(position.x, position.y, treeSizes[1]-8, treeSizes[1]-8, 15);

    ////layer 3
    fill(treeColorR, greens[2], treeColorB);
    rect(position.x, position.y, treeSizes[2], treeSizes[2], 15);

    ////layer 3.5
    fill(#E9FFEA);
    rect(position.x, position.y, treeSizes[2]-8, treeSizes[2]-8, 15);


    ////layer 4
    fill(treeColorR, greens[3], treeColorB);
    rect(position.x, position.y, treeSizes[3], treeSizes[3], 15);
  }
}

class WindyTree
{
  //variables that makes the red and blue hue change giving it a new color
  float treeColorR = random(0, 100); 
  float treeColorB = random(0, 100); 

  //array for the diferent green color
  float[] greens = new float[4];




  float randomRotation;

  PVector position;


  WindyTree()
  {
    //initialization code
    rectMode(CENTER);
    noStroke();

    //declaration of the array for the green color
    greens[0] = random(130, 160);
    greens[1] = random(160, 190);
    greens[2] = random(190, 220);
    greens[3] = random(220, 255);

    position=new PVector(random(0, 800), random(0, 600));
  }

  void drawWindyTree()
  {

    ////layer 1
    fill(treeColorR, greens[0], treeColorB);
    //The size varies from frame to frame to guive the efect of wind
    rect(position.x, position.y, random (50, 55), random (50, 55), 50);

    ////layer 2
    fill(treeColorR, greens[1], treeColorB);
    //The size varies from frame to frame to guive the efect of wind
    rect(position.x, position.y, random (30, 35), random (30, 35), 50);

    ////layer 3
    fill(treeColorR, greens[2], treeColorB);
    //The size varies from frame to frame to guive the efect of wind
    rect(position.x, position.y, random (25, 30), random (25, 30), 50);

    ////layer 4
    fill(#95F671);
    //The size varies from frame to frame to guive the efect of wind
    rect(position.x, position.y, random (15, 20), random (15, 20), 50);
  }
}