//==========================
class Atomic extends FX{
  float radius = 20f;
  float maxSize = 25f;
  float[][] pos;
  float rot;
  //---------------
  Atomic(float x, float y, float z){
    this.x = x;
    this.y = y;
    this.z = z;
    lifespan = timer = 15;
    pos = new float[7][3];
    for(int i=0;i<pos.length;i++)
      pos[i] = new float[]{x+random(-radius,radius),y+random(-radius,radius),z+random(0,5)};
    rot = random(0,PI);
  }
  //---------------
  void visualize(){
    noStroke();
    stroke(255,timer*255f/lifespan);
    fill(255,timer*128f/lifespan);
    for(int i=0;i<pos.length;i++){
      pushMatrix();
      translate(pos[i][0],pos[i][1],pos[i][2]);
      rotateZ(rot);
      float q = (lifespan-timer)*maxSize/lifespan;
      rect( -q/2,-q/2,q,q );
      popMatrix();
    }
    
    pushMatrix();
    translate(x,y,z);
    for(int i=0;i<200;i++){
      stroke(255,random(16,64));
      float angle = random(0,TWO_PI);
      float magni = random(0,2*radius*(1-timer/(float)lifespan) );
      float px = magni*cos(angle);
      float py = magni*sin(angle);
      line(px,py,z,px,py,z+2*timer);
    }
    popMatrix();
  }
}
//==========================
class Cubeplosion extends FX{
  float radius = 5f;
  float maxSize = 15f;
  float[][] pos;
  float[][] rot;
  //---------------
  Cubeplosion(float x, float y, float z){
    this.x = x;
    this.y = y;
    this.z = z;
    lifespan = timer = 20;
    pos = new float[3][3];
    for(int i=0;i<pos.length;i++)
      pos[i] = new float[]{x+random(-radius,radius),y+random(-radius,radius),z+random(-radius,radius)};
    rot = new float[pos.length][2];
    for(int i=0;i<rot.length;i++)
      rot[i] = new float[]{random(0,PI),random(0,PI),random(0,PI)};
  }
  //---------------
  void visualize(){
    noStroke();
    stroke(255,timer*255f/lifespan);
    fill(255,timer*128f/lifespan);
    for(int i=0;i<pos.length;i++){
      pushMatrix();
      translate(pos[i][0],pos[i][1],pos[i][2]);
      rotateX(rot[i][0]);
      rotateY(rot[i][1]);
      box( (lifespan-timer)*maxSize/lifespan );
      popMatrix();
    }
  }
}
//==========================
class Shockwave extends FX{
  float diameter = 40f;
  int[] shockWidth;
  //---------------
  Shockwave(float x, float y, float z){
    this.x = x;
    this.y = y;
    this.z = z;
    lifespan = timer = 20;
    shockWidth = new int[4];
    for(int i=0;i<shockWidth.length;i++)
      shockWidth[i] = (int)random(-4,4);
  }
  //---------------
  void visualize(){
    noFill();
    stroke(0,192,255,timer*255f/lifespan);
    pushMatrix();
    translate(x,y,z-shockWidth.length);
    for(int i=0;i<shockWidth.length;i++){
      translate(0,0,2);
      float w = (lifespan-timer)*diameter/lifespan;
      ellipse(0,0,w+shockWidth[i],w+shockWidth[i]);
    }
    popMatrix();
  }
}
//==========================
class Death extends FX{
  int dustDensity = 1;
  float[][] dust;
  float rotation;
  color dustColor;
  //---------------
  Death(Entity e){
    this.x = e.x;
    this.y = e.y;
    dustColor = e.lineStrokeColor;
    timer = 20;
    lifespan = timer;
    
    if(e.isEnemy) rotation = -HALF_PI + atan2( ((Enemy)e).vy, ((Enemy)e).vx);

    int dustLength = 0;
    float scl = e.geometry.scl;
    int[][][] p = e.geometry.polys;
    int[][][] l = e.geometry.lines;

    for(int i=0;i<p.length;i++)
      for(int j=1;j<p[i].length;j++){
        float d = scl*dist( p[i][j][0], p[i][j][1], p[i][j][2], p[i][j-1][0], p[i][j-1][1], p[i][j-1][2]  );
        dustLength += 1+(int)d/dustDensity ;
      }

    for(int i=0;i<l.length;i++)
      for(int j=1;j<l[i].length;j++){
        float d = scl*dist( l[i][j][0], l[i][j][1], l[i][j][2], l[i][j-1][0], l[i][j-1][1], l[i][j-1][2]  );
        dustLength += 1+(int)d/dustDensity ;
      }

    dust = new float[ dustLength ][3];
    int dIndex = 0;

    for(int i=0;i<p.length;i++)
      for(int j=1;j<p[i].length;j++){
        float d = scl*dist( p[i][j][0], p[i][j][1], p[i][j][2], p[i][j-1][0], p[i][j-1][1], p[i][j-1][2]  );
        float q = dustDensity/d;
        for(int k=0;k<d/dustDensity;k++){
          dust[dIndex][0] = scl*lerp( p[i][j][0], p[i][j-1][0], k*q ) ;
          dust[dIndex][1] = scl*lerp( p[i][j][1], p[i][j-1][1], k*q ) ;
          dust[dIndex][2] = scl*lerp( p[i][j][2], p[i][j-1][2], k*q ) ;
          dIndex++;
        }
      }

    for(int i=0;i<l.length;i++)
      for(int j=1;j<l[i].length;j++){
        float d = scl*dist( l[i][j][0], l[i][j][1], l[i][j][2], l[i][j-1][0], l[i][j-1][1], l[i][j-1][2]  );
        float q = dustDensity/d;
        for(int k=0;k<d/dustDensity;k++){
          dust[dIndex][0] = scl*lerp( l[i][j][0], l[i][j-1][0], k*q ) ;
          dust[dIndex][1] = scl*lerp( l[i][j][1], l[i][j-1][1], k*q ) ;
          dust[dIndex][2] = scl*lerp( l[i][j][2], l[i][j-1][2], k*q ) ;
          dIndex++;
        }
      }
  }
  //---------------
  void update(){
    super.update();
    for(int i=0;i<dust.length;i++)
      dust[i][2] += random(0,2);
  }
  //---------------
  void visualize(){
    stroke( red(dustColor), green(dustColor), blue(dustColor),255f*timer/lifespan);
    pushMatrix();
    translate(x,y,z);
    rotateZ(rotation);
    for(int i=0;i<dust.length;i++)
      point( dust[i][0], dust[i][1], dust[i][2] );
    popMatrix();
  }
}
//==========================
class Deletion extends FX{
  int fragments, gridx, gridy;
  float[][] fragmentVelocity;
  int r,g,b;
  //---------------
  Deletion(int gridx, int gridy){
    this.gridx = gridx;
    this.gridy = gridy;
    r = 255;
    g = 255;
    b = 64;
    timer = 40;
    lifespan = timer;
    fragments = 8;
    x = game.terrain.xPos(gridx);
    y = game.terrain.yPos(gridy);
    fragmentVelocity = new float[fragments][fragments];
    for(int i=0;i<fragments;i++)
      for(int j=0;j<fragments;j++)
        fragmentVelocity[i][j] = random(0.1,1.5);
  }
  //---------------
  void visualize(){

    noStroke();
    float fSize = game.terrain.cellSize/(float)fragments;
    float fOff = game.terrain.cellSize/2f;

    for(int i=0;i<fragments;i++)
      for(int j=0;j<fragments;j++){
        pushMatrix();
        translate(0,0,fragmentVelocity[i][j]*(lifespan-timer));
        fill(r,g,b,timer*255/lifespan);
        rect(x+i*fSize-fOff,y+j*fSize-fOff,fSize,fSize);
        popMatrix();
      }
  }
}
//==========================
class PhotonicPillar extends FX{
  int pillarRadius = 5;
  int glowRadius = 8;
  PhotonicPillar(float x, float y){
    timer = 15;
    this.x = x;
    this.y = y;
    this.z = 0;
  }
  //---------------
  void visualize(){
    for(int i=0;i<10*timer;i++){
      stroke( 255, random(0,64) );
      float x1 = x + random(-pillarRadius,pillarRadius);
      float y1 = y + random(-pillarRadius,pillarRadius);
      line(x1,y1,z,x1,y1,z+random(0,200));
    }

    noStroke();    
    fill( 255, 16 );
    pushMatrix();
    translate(x,y,z+1);
    for(int i=0;i<4;i++){
      rect( -glowRadius, -glowRadius, 2*glowRadius, 2*glowRadius );
      translate(0,0,2);
    }
    popMatrix();
  }
}
//==========================
class UpgradeFlash extends FX{
  int pillarRadius = 10;
  int glowRadius = 14;
  UpgradeFlash(float x, float y){
    timer = 15;
    this.x = x;
    this.y = y;
    this.z = 0;
  }
  //---------------
  void visualize(){
    for(int i=0;i<5*timer;i++){
      stroke( 0,255,0, random(0,64) );
      float x1 = x + random(-pillarRadius,pillarRadius);
      float y1 = y + random(-pillarRadius,pillarRadius);
      line(x1,y1,z,x1,y1,z+random(0,100));
    }

    noStroke();    
    fill( 0,255,0, 16 );
    pushMatrix();
    translate(x,y,z+1);
    for(int i=0;i<timer;i++){
      rect( -glowRadius, -glowRadius, 2*glowRadius, 2*glowRadius );
      translate(0,0,2);
    }
    popMatrix();
  }
}
//==========================
class Lightning extends FX{
  Entity source, sink;
  float[][] bolt;
  float segmentLength = 10;
  //---------------
  Lightning(Entity source, Entity sink){
    this.source = source;
    this.sink = sink;
    timer = 10;
    int segs = (int)(dist(source.x,source.y,source.z+source.fxZ,sink.x,sink.y,sink.z+sink.fxZ)/segmentLength);
    bolt = new float[segs][3];
    randomizeBolt();
  }
  //---------------
  void randomizeBolt(){
    float x1 = source.x + source.fxX;
    float y1 = source.y + source.fxY;
    float z1 = source.z + source.fxZ;
    float x2 = sink.x + sink.fxX;
    float y2 = sink.y + sink.fxY;
    float z2 = sink.z + sink.fxZ;
    float len = bolt.length-1f;

    for(int i=0;i<bolt.length;i++){
      bolt[i][0] = lerp(x1,x2,i/len);
      bolt[i][1] = lerp(y1,y2,i/len);
      bolt[i][2] = lerp(z1,z2,i/len);
    }
    for(int i=1;i<bolt.length-1;i++){
      bolt[i][0] += random(-segmentLength,segmentLength);
      bolt[i][1] += random(-segmentLength,segmentLength);
      bolt[i][2] += random(-segmentLength,segmentLength);
    }
  }
  //---------------
  void update(){
    super.update();
    randomizeBolt();
  }
  //---------------
  void visualize(){
    noStroke();
    fill(255,64);
    for(int i=0;i<bolt.length-1;i++){
      beginShape(TRIANGLE_STRIP);
      vertex(bolt[i][0],bolt[i][1],bolt[i][2]+3);
      vertex(bolt[i+1][0],bolt[i+1][1],bolt[i+1][2]+3);
      vertex(bolt[i][0],bolt[i][1],bolt[i][2]-3);
      vertex(bolt[i+1][0],bolt[i+1][1],bolt[i+1][2]-3);
      endShape(CLOSE);
    }
    for(int i=0;i<bolt.length-1;i++){
      beginShape(TRIANGLE_STRIP);
      vertex(bolt[i][0]+3,bolt[i][1],bolt[i][2]);
      vertex(bolt[i+1][0]+3,bolt[i+1][1],bolt[i+1][2]);
      vertex(bolt[i][0]-1,bolt[i][1],bolt[i][2]);
      vertex(bolt[i+1][0]-1,bolt[i+1][1],bolt[i+1][2]);
      endShape(CLOSE);
    }

    stroke( 255, random(0,255) );
    noFill();
    beginShape();
    for(int i=0;i<bolt.length;i++)
      vertex(bolt[i][0],bolt[i][1],bolt[i][2]);
    endShape();

    fill(255,64);
    //drawSpark( source.x,source.y,source.z+source.fxZ, 8 );
    //drawSpark( sink.x,sink.y,sink.z+sink.fxZ, 8 );
  }
  //---------------
  void drawSpark(float x, float y, float z, float s){
    noStroke();
    pushMatrix();
    translate(x,y,z);
    beginShape(TRIANGLES);
    vertex( s, s, 0);
    vertex(-s, s, 0);
    vertex( 0,-s, 0);
    vertex( s, 0, s);
    vertex( s, 0,-s);
    vertex(-s, 0, 0);
    vertex( 0, s, s);
    vertex( 0,-s, s);
    vertex( 0, 0,-s);
    endShape();
    popMatrix();
  }
}
//==========================
class FX extends Entity{
  int timer, lifespan;
  //---------------
  void update(){
    timer--;
    if(timer<=0) kill();
  }
}