class Vec{
  float x,y;
  
  Vec(){
    x=0;
    y=0;
  }
  
  Vec(float a,float b){
    x=a;
    y=b;
  }
  
  Vec set(float a,float b){
    x=a;
    y=b;
    return this;
  }
  
  float length(){
    return sqrt(x*x+y*y);
  }
  
  float distance(Vec a){
    float u=x-a.x;
    float v=y-a.y;
    return sqrt(u*u+v*v);
  }
  
  void normalize(){
    float len=length();
    x/=len;
    y/=len;
  }
  
  Vec add(Vec a,Vec b){
    x=a.x+b.x;
    y=a.y+b.y;
    return this;
  }
  
  Vec add(Vec a){
    x+=a.x;
    y+=a.y;
    return this;
  }
    
  Vec sub(Vec a,Vec b){
    x=a.x-b.x;
    y=a.y-b.y;
    return this;
  }
  
  Vec sub(Vec a){
    x-=a.x;
    y-=a.y;
    return this;
  }
    
  Vec mul(Vec a,float b){
    x=a.x*b;
    y=a.y*b;
    return this;
  }
  
  Vec mul(float a){
    x*=a;
    y*=a;
    return this;
  }
  
  Vec div(Vec a,float b){
    x=a.x/b;
    y=a.y/b;
    return this;
  }
  
  Vec div(float a){
    x/=a;
    y/=a;
    return this;
  }
    
  Vec dup(){
    return new Vec(x,y);
  }
  
  Vec assign(Vec a){
    x=a.x;
    y=a.y;
    return this;
  }
  
  void adjust(Vec a,float distance){
    Vec unit=(new Vec()).sub(a,this);
    float dis=unit.length();
    float d=distance-dis;
    if(dis==0)
      return;
    unit.div(dis);
    unit.mul(d*0.5);
    this.sub(unit);
    a.add(unit);
  }
  
  void adjust(Vec a,float distance,float alpha,float beta){
    Vec unit=(new Vec()).sub(a,this);
    float dis=unit.length();
    float d=distance-dis;
    if(dis==0)
      return;
    unit.div(dis);
    Vec unit2=unit.dup();
    unit2.mul(d*beta);
    unit.mul(d*alpha);
    this.sub(unit);
    a.add(unit2);
  }
 
  void adjustMax(Vec a,float distance,float alpha,float beta){
    Vec unit=(new Vec()).sub(a,this);
    float dis=unit.length();
    float d=distance-dis;
    if(dis<distance)
      return;
    unit.div(dis);
    Vec unit2=unit.dup();
    unit2.mul(d*beta);
    unit.mul(d*alpha);
    this.sub(unit);
    a.add(unit2);
  }
   
  void interp(Vec a,Vec b,float alpha){
    float beta=1-alpha;
    x=a.x*beta + b.x*alpha;
    y=a.y*beta + b.y*alpha;    
  }
    
  void interp(Vec v,float alpha){
    float beta=1-alpha;
    x=x*beta + v.x*alpha;
    y=y*beta + v.y*alpha;    
  }

}

class MassPoint{
  Vec pos;
  Vec prev;
  Vec vel;
  float weight;

  MassPoint(){}

  MassPoint(Vec v){
    pos=new Vec();
    prev=new Vec();
    vel=new Vec();
    pos.assign(v);
    prev.assign(v);
    vel.set(0,0);
    weight=1;
  }
  
  MassPoint(Vec p,Vec v){
    pos=new Vec();
    prev=new Vec();
    pos.assign(p);
    prev.sub(pos,v);
    vel.sub(pos,prev);
    weight=1;
  }
  
  void trans(Vec v){
    pos.add(v);
    prev.add(v);
  }

  void update(float d){ 
    vel.sub(pos,prev);
    prev.assign(pos);
    vel.mul(d);
    pos.add(vel);
  }
  
  void update(){ 
    vel.sub(pos,prev);
    prev.assign(pos);
    vel.mul(0.99);
    pos.add(vel);
  }
    
  void adjust(MassPoint a,float d){
    pos.adjust(a.pos,d);
  }

  void adjust(MassPoint a,float d,float alpha,float beta){
    pos.adjust(a.pos,d,alpha,beta);
  }
  
 void adjustMax(MassPoint a,float d,float alpha,float beta){
    pos.adjustMax(a.pos,d,alpha,beta);
  }  
}

class MassPointLink{

  MassPoint first;
  MassPoint second;
  float distance;

  MassPointLink(){}

  MassPointLink(MassPoint a,MassPoint b){
    first=a;
    second=b;
    distance=a.pos.distance(b.pos);
  }

  MassPointLink(MassPoint a,MassPoint b,float d){
    first=a;
    second=b;
    distance=d;
  }
  
  void adjust(){
    float sum=first.weight+second.weight;
    first.adjust(second,distance,second.weight/sum,first.weight/sum);  
  }
  
  void adjust(float scale){
    float sum=first.weight+second.weight;
    first.adjust(second,distance*scale,second.weight/sum,first.weight/sum);
  }
  
  void adjustMax(){
    float sum=first.weight+second.weight;
    first.adjustMax(second,distance,second.weight/sum,first.weight/sum);
  }
}

class Curtain{
  int WIDTH=32;
  int HEIGHT=32;
  MassPoint[] pos;
  MassPointLink[] links;
  int link_size;
  BImage curtain_image;
  Curtain(){
    pos=new MassPoint[WIDTH*HEIGHT];
    for(int y=0; y<HEIGHT; ++y){
      for(int x=0; x<WIDTH; ++x){
        pos[y*WIDTH+x]=new MassPoint(new Vec(x,y));
      }
    }
    links=new MassPointLink[(WIDTH-1)*(HEIGHT-1)*2*2];
    for(int y=0; y<HEIGHT-1; ++y){
      for(int x=0; x<WIDTH-1; ++x){
        links[link_size++]=new MassPointLink(pos[y*WIDTH+x],pos[y*WIDTH+x+1]);
        links[link_size++]=new MassPointLink(pos[y*WIDTH+x],pos[y*WIDTH+x+WIDTH]);
        links[link_size++]=new MassPointLink(pos[y*WIDTH+x+1],pos[y*WIDTH+x+1+WIDTH]);
        links[link_size++]=new MassPointLink(pos[y*WIDTH+x+WIDTH],pos[y*WIDTH+x+1+WIDTH]);
      }
    }
    
    for(int i=0; i<link_size; ++i){
      MassPointLink temp=links[i];
      int k=int(random(i,link_size));
      links[i]=links[k];
      links[k]=temp;
    }
    
    for(int i=0; i<link_size; ++i){
      links[i].distance*=1.2;
    }
   
    for(int y=0; y<HEIGHT; ++y){
      for(int x=0; x<WIDTH; ++x){
        pos[y*WIDTH+x].prev.y=pos[y*WIDTH+x].pos.y=y*y*0.002;
      }
    }
       
    curtain_image=loadImage("curtain.jpg");
    
  }
  
  void update(){
    for(int i=0; i<link_size; ++i){
      links[i].adjustMax();
    }
    
    for(int i=0; i<pos.length; ++i){
      pos[i].update(0.99);
      pos[i].pos.y+=0.02;
    }
    
    for(int i=0; i<WIDTH; ++i){
      pos[i].pos.y=0;
      pos[i].pos.x=i;
    }
    for(int i=0; i<HEIGHT; ++i){
      pos[i*WIDTH].pos.x=0;
      pos[i*WIDTH+WIDTH-1].pos.x=WIDTH;
    }
        
    for(int j=4; j<=28; j+=4){
      for(int i=4; i<=28; i+=8){
        pos[j*WIDTH+i].pos.y-=0.5;
      }
    }
    /*
    for(int y=0; y<256; ++y){
      for(int x=0; x<256; ++x){
        curtain_image.pixels[y*256+x]*=0.99;
      }
    }
    */
  }

  void draw(){
    noStroke();
    fill(255,255,255);
    for(int y=0; y<HEIGHT-1; ++y){
      beginShape(TRIANGLE_STRIP);
      texture(curtain_image);
      int offset=y*WIDTH;
      float w=256.0/32.0;
      for(int x=0; x<WIDTH; ++x){
        vertex(pos[offset+x].pos.x,pos[offset+x].pos.y,0,x*w,y*w);
        vertex(pos[offset+x+WIDTH].pos.x,pos[offset+x+WIDTH].pos.y,0,x*w,y*w);
       }
      endShape();
    }    
  }

}

Bullets bullets;
Curtain curtain;

class Bullets{
  class Unit{
    Vec pos,vel;
    int life;
    Unit(){
      pos=new Vec(0,0);
      vel=new Vec(0,0);
      life=200;
    }
  }
  Unit[] units=new Unit[2048];
  int used=0;
  
  Bullets(){
    for(int i=0; i<units.length; ++i){
      units[i]=new Unit();
    }
  }
  
  void put(Vec pos,Vec vel){
    if(used==units.length)
      return;
    Unit u=units[used];
    u.pos.x=pos.x;
    u.pos.y=pos.y;
    u.vel.x=vel.x;
    u.vel.y=vel.y;
    u.life=100;
    used++;
  }
  
  void erase(int i){
    if(used<=1){
      used=0;
      return;
    }
    Unit temp=units[i];
    units[i]=units[used-1];
    units[used-1]=temp;
    used--;
  }
  

  
  void draw(){
    fill(0,0,0);
    noStroke();
    ellipseMode(CENTER_DIAMETER);
    for(int i=0; i<used; i++){
      Unit u=units[i];
      u.pos.x+=u.vel.x;
      u.pos.y+=u.vel.y;
      float sz=u.life>10 ? 1 : u.life*0.1;
      ellipse(u.pos.x,u.pos.y,sz,sz);
      if(u.life--<0){
        erase(i);
        --i;
      }
      
      for(int y=0; y<32; ++y){
        for(int x=0; x<32; ++x){
        float dx=curtain.pos[y*32+x].pos.x-u.pos.x;
        float dy=curtain.pos[y*32+x].pos.y-u.pos.y;
        float len=dx*dx+dy*dy;
        if(len<4){
          float ddx=(curtain.pos[y*32+x].vel.x-u.vel.x);
          float ddy=(curtain.pos[y*32+x].vel.y-u.vel.y);
          curtain.pos[y*32+x].pos.x-=ddx*0.02;
          curtain.pos[y*32+x].pos.y-=ddy*0.02;
          u.vel.x+=ddx*0.05;
          u.vel.y+=ddy*0.05;       
        }
      }
     }
    }
  }
}

BImage back;
int count=0;
void setup(){

  size(256,350);
  
  back=loadImage("back.jpg");
  
  curtain=new Curtain();
  bullets=new Bullets();
  
  textFont(loadFont("Futura-ExBlack.vlw.gz"),20);
  
  framerate(50);  
}

void gene(float x,float  y){
  for(int i=0; i<10; i++){
    bullets.put(new Vec(x,y),new Vec(random(-0.5,0.5),random(-3.0,-2)));
  }
}

float ssc=256.0/32.0;
 
void mousePressed(){
  if(count<255)
    return;
  gene(mouseX/ssc,mouseY/ssc);
}

void loop(){
  count+=2;
  if(count<255)
    background(count);
  else
    background(back);
  
  push();
  scale(ssc);
  curtain.update();
  curtain.draw();
  
  stroke(0,0,0);
  fill(255,255,255);
  beginShape(TRIANGLE_STRIP);
  vertex(mouseX/ssc,mouseY/ssc-1);
  vertex(mouseX/ssc-1,mouseY/ssc+1);
  vertex(mouseX/ssc+1,mouseY/ssc+1);
  endShape();
  
  bullets.draw();
  
  pop();
}