nudemengarden.txt

视频交互游戏实验

int res = 10;             // collision detection area

int totalPixels;         // total for array setup
int[][] vPixels;         // video pixel array
int startx, starty;      // pixel to be modified

int bb;                  // hue, saturation, brightness
int brightMean;

boolean newFrame;

// Global variables for rain drops

float[] rain_x;
float[] rain_y;
float[] rain_speed;

int[] rainStartF;
int[] rainStopF;
int[] rainCurrF;
int[] rainStage;  //0:falling 1:landing 2:sitting 3:standing-up 4: standing 5:walking left 6: walking right

int rain_total=30;
int dropLimit=90; //smaller the number, lighter the region they land
int[][] rainTF = {{9,8,1,4,1,5,5}};
int rainTypeTotal = rainTF.length;
int[] rainType;

BImage[][] rainImg;

//////////////////////////////////////////////////////////////////////
int flowerMax = 40;//15;
int cactusMax = 40;//4;
int mimosaMax = 40;//6;

Flower[] flowerList = new Flower[flowerMax];
Cactus[] cactusList = new Cactus[cactusMax];
Mimosa[] mimosaList = new Mimosa[mimosaMax];

BImage[] flowerImageList = new BImage[3];
BImage[] leafImageList = new BImage[3];

BImage spike;
BImage cactusTop;
BImage cactus;
BImage cactusBall;
BImage mimosa;
BImage cloud;

/////////////////////////////////////////////////////////////////////

void setup() { 
println("!!!");
  size(320, 240); 
  background(0);
  ellipseMode(CENTER_DIAMETER);
  noStroke();
  
  vPixels   = new int[height][width];
  
  rainStartF = new int[rain_total];
  rainStopF = new int[rain_total];
  rainCurrF = new int[rain_total];
  rainStage = new int[rain_total];
  
  rain_x = new float[rain_total];
  rain_y = new float[rain_total];
  rain_speed= new float[rain_total];  
  rainType = new int[rain_total];



  rainImg = new BImage[rain_total][50];
  
  /// henry var init start////////////////////////////////////////////////////
  
  spike = loadImage("spike.gif");
  cactusTop = loadImage("cactusTop.gif");
  cactus = loadImage("cactus.gif");
  cactusBall = loadImage("cactusBall.gif");
  mimosa = loadImage("mimosa.gif");
  flowerImageList[0] = loadImage("flower1.gif");
  flowerImageList[1] = loadImage("flower2.gif");
  flowerImageList[2] = loadImage("flower3.gif");
  leafImageList[0] = loadImage("leaf1.gif");
  leafImageList[1] = loadImage("leaf2.gif");
  leafImageList[2] = loadImage("leaf3.gif");

  for (int i=0; i<cactusMax; i++){
      cactusList[i] = new Cactus(0,240,300,50,false);
  }
  for (int i=0; i<mimosaMax; i++){
     mimosaList[i] = new Mimosa(0,240,50,90,false);
  }
  for (int i=0; i<flowerMax; i++){  
      flowerList[i] = new Flower(0,240,10,70,false);  
  }

/////henry var init end///////////////////////////////////////////
  beginVideo(width, height,24);
  
  // init raindrops
  for(int i=0; i<rain_total; i++) { 
  
    initVar(i); 
  
  }
 
  
}


void loop() {


  if (newFrame){

    image(video,0,0);
    newFrame = false;
    drawPlant();    
    drawRain();
  }
  
// Saves each frame as line-0000.tif, line-0001, etc. 
   //saveFrame("garden_close-####.tif"); 
}

void mouseReleased(){
  growNew("Mimosa", mouseX);
}

void videoEvent(){
  if (!newFrame){
    newFrame = true;
  }
}

// get raindrop's total frames
int getTotalFrames(int i){
 int sum=0;
 for (int k=0; k<rainTF[i].length; k++)
   sum = sum + rainTF[i][k];
 return(sum);
}

// get raindrop's total frames from stage
int getTotalFramesFrom(int i, int stageNo){
 int sum=0;
 for (int k=0; k<stageNo+1; k++)
   sum = sum + rainTF[i][k];
 return(sum);
}

// init snow properties
void initVar(int i){

    
    rain_x[i]=random(width);
    rain_y[i]=-100-random(100);
    rain_speed[i]=random(5,10);
    
    //rainType[i]= (int) random(rainTypeTotal);
    rainType[i]=0;
    
    rainGotoStage(0, rainType[i], i);
    
    
    
    int temp=getTotalFrames(rainType[i]);
    
    for (int k=0; k<temp; k++)
    {
      rainImg[i][k]= loadImage("rain"+rainType[i]+"f"+k+".gif"); 
      
     } 
    
}

//goto a raindrop's stage
void rainGotoStage(int stageNo, int rType, int i){

    if (stageNo==0) rainStartF[i]=0;
    else
    {
       rainStartF[i]=getTotalFramesFrom(rType,stageNo-1);
    }

    rainStopF[i]=rainStartF[i]+rainTF[rType][stageNo]-1;
    
    rainCurrF[i]=rainStartF[i];
    
    rainStage[i]=stageNo;


}

void drawRain(){

  
  
  for(int i=0; i<rain_total; i++)
  {
    rain_y[i]+=rain_speed[i];
    if (rain_y[i]>height || rain_x[i]<-100 || rain_x[i]>width+100) {
         
     
     
     // planting
     if (rain_y[i]>height && rain_x[i]>0 && rain_x[i]<width) {
        
        
         if ( int(random(100))>50) growNew("Flower", rain_x[i]);
         else if (int(random(100))>10) growNew("Mimosa", rain_x[i]);
         else growNew("Cactus", rain_x[i]);
      } 
      
      // rebuild
     initVar(i);
    }
    
  if (rain_y[i]>0 && rain_y[i]<height)checkCam(i);
    
  // render rain     
   
     image(rainImg[i][rainCurrF[i]],rain_x[i]-rainImg[i][rainCurrF[i]].width/2, rain_y[i]);
     
     if (rainCurrF[i]>=rainStopF[i]) 
     {
       if (rainStage[i]==0) //falling down
       {
         
       }
       else rainCurrF[i]=rainStartF[i]; //looping
     }
     else rainCurrF[i]++;
   
  }
  


      
}

void checkCam(int ri)
{
  // check video area of the ball 

    startx=(int)(rain_x[ri])-(int)(res/2);
    starty=(int)(rain_y[ri]+rainImg[ri][0].height)-(int)(res/2);
    
    if (startx<0) startx=0;
    if (starty<0) starty=0;
    if (startx>width-res) startx=width-res;
    if (starty>height-res) starty=height-res;

    brightMean=0;
            
    for(int j=starty; j<starty+res; j++){
    for(int i=startx; i<startx+res; i++){
    
      
      vPixels[j][i] = video.pixels[(j * video.width) + i];
      bb = (int)(brightness(vPixels[j][i]));
      
      brightMean += bb;

     }
     }
     
     brightMean = (int) ( brightMean/res/res);
     
     if (brightMean < dropLimit ) 
     {
       
       rain_y[ri]-=rain_speed[ri];
      
       //landing.. (1)
       if (rainStage[ri]==0) rainGotoStage(1, rainType[ri], ri);
       
       
       //sitting (2)
       if (rainStage[ri]==1 && rainCurrF[ri]==rainStopF[ri]) rainGotoStage(2, rainType[ri], ri);
       
       // standing up (3)
       if (rainStage[ri]==2 && rainCurrF[ri]==rainStopF[ri] && random(100)>95) rainGotoStage(3, rainType[ri], ri);
       
       // standing(4)
       if (rainStage[ri]==3 && rainCurrF[ri]==rainStopF[ri]) rainGotoStage(4, rainType[ri], ri);
       
       // walking LEFT(5) Right (6)
       if (rainStage[ri]==4 && rainCurrF[ri]==rainStopF[ri] && random(100)>90) 
       {
          if (random(100)>50) rainGotoStage(5, rainType[ri], ri);
          else rainGotoStage(6, rainType[ri], ri);
       }
       
       // walking 
       float step=random(2,5);
       if (rainStage[ri]==5) rain_x[ri]-=step;
       else if (rainStage[ri]==6) rain_x[ri]+=step;
       
       
     }
     else
     {
       //falling...
       
       if (rainStage[ri]!=0) 
       {
          // if they walking...
          if (rainStage[ri]==5) rain_x[ri]-=20;
          else if (rainStage[ri]==6) rain_x[ri]+=20;
          
          //change to falling stage
          rainGotoStage(0, rainType[ri], ri);
       }
     }
     
     //println("bright:"+brightMean);
    
}

///////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////// Classes written by Henry
///////////////////////////////////////////////////////////////////////////

void drawPlant(){
   for (int i=0; i<cactusMax; i++){
     if(cactusList[i].life>0 && cactusList[i].readyGrow){
       cactusList[i].grow();
     }
   }

   for (int i=0; i<mimosaMax; i++){
     if(mimosaList[i].life>0 && mimosaList[i].readyGrow){
       mimosaList[i].grow();
     }
   }

   for (int i=0; i<flowerMax; i++){
     if(flowerList[i].life>0 && flowerList[i].readyGrow){
       flowerList[i].grow();
     }
   }
}

 void growNew(String type,float x){
   if(type=="Flower"){
     boolean growFinish = false;
     for (int i=0; i<flowerMax && !growFinish; i++){
       if(!flowerList[i].readyGrow){
         flowerList[i] = new Flower(x,240,random(10,20),int(random(15,35)),true);
         growFinish = true;
       }
     }
   }
   if(type=="Cactus"){
     boolean growFinish = false;
     for (int i=0; i<cactusMax && !growFinish; i++){
       if(!cactusList[i].readyGrow){
         cactusList[i] = new Cactus(x,240,random(300,400),int(random(35,70)),true);
         growFinish = true;
       }
     }
   }
   if(type=="Mimosa"){
     boolean growFinish = false;
     for (int i=0; i<mimosaMax && !growFinish; i++){