/**
 * Copyright (c) 2010 LAFKON/Benjamin Stephan.
 *
 * This is free software, and you may redistribute it under the GPL.
 * This Software comes with absolutely no warranty.
 * For details see the license (http://www.lafkon.net/gpl.txt)
 *
 * http://www.forkable.eu/generators/va300/
 * http://www.lafkon.net/what/is/va300
 */

 // This is the live-version, made for continuous live projection!
 // For a pdf-outputting-version check the URLs above. 

import fisica.*;
import geomerative.*;
import ijeoma.motion.*;
import ijeoma.motion.tween.*;

float x,y,x1,x2,y1,y2;

RShape shp;
RPoint[] points;
RPoint[][] pointPaths;
String[]vektorlist, singletonList;
PGraphics canvas;

boolean firstRun = true;

ArrayList traceBodies, singletonBodies, allBodies;
FWorld world;
FPolyPlus poly;
FPolyMinus polym;
FPolyMinus obstacle, obstacle02, obstacle03, obstacle04;
Tween t;
TweenParallel tp;

//===========================================
boolean invert = false;  // black <on> white
//===========================================

String outputFormat, typosize, inverted;
int gravityy = 100;
int gravityx = 0;
float rndx;
float wert = 1;
float wert2 = 0.5;
float wert3 = 0;
float wert4 = 5;
float rot = 0;
public float eraserecty = 0;
public float obstX, obstY, obstNextX, obstNextY, obstR, obstNextR;


void setup() {
  size(580, 850, JAVA2D);
  smooth();
  frameRate(100);

  if(firstRun) {
    outputFormat = loadStrings("i/posterformat.i")[0];
    typosize = loadStrings("i/typosize.i")[0];
    vektorlist = loadStrings("i/participants_" +typosize +".list");
    singletonList = loadStrings("i/info.list"); 
    Collections.shuffle(Arrays.asList(vektorlist));   
  }

//============================================== WORLD init ====
  if(firstRun) {
    Fisica.init(this);
    RG.init(this);
    Motion.setup(this);  
      
    world = new FWorld();

    world.setGravity(0, 100);
    world.setEdges();
    world.remove(world.top);  
    world.top.setDrawable(false); 
    world.left.setDrawable(false);
    world.right.setDrawable(false);
    world.bottom.setDrawable(false);  
    world.setEdgesRestitution(0.8);
    world.setEdgesFriction(100);

    world.bottom.setGrabbable(true);
    world.bottom.setDensity(100);
    world.bottom.setDamping(0); 
    world.bottom.setRestitution(0.81);
    world.bottom.setFriction(wert2);    
    
    
    traceBodies = new ArrayList(); 
    singletonBodies = new ArrayList();  
    allBodies = new ArrayList(); 
  }


//============================================== SINGLETONS init ====
  if(firstRun) {
    for(int k=0; k<singletonList.length; k++) { 
      shp = loadRShape(singletonList[k]);
      polym = new FPolyMinus();
      //polym.setCollisionShape(unionPath(shp));
      polym.setCollisionShape(shp.getBoundsPoints()); //BoundingBox-CollisionDetection only for LiveMode
      polym.setDrawShape(loadShape(singletonList[k])); 

      singletonBodies.add(polym);
      world.add(polym);   
    }
  }
  for (int k = 0; k < singletonBodies.size(); k++) { 
    polym = (FPolyMinus) singletonBodies.get(k);
    polym.setVisible(true);//false
    polym.setRotation(0);
    polym.setPosition(random(0,width/3), -400);
    polym.setDensity(0.5);
    polym.setDamping(0); 
    polym.setRestitution(0.94);
    polym.setFriction(wert2);    
    polym.setAngularDamping(wert);
  }

//============================================== TRACERS init ====
  if(firstRun) {
    for(int k=0; k<vektorlist.length; k++) { 
      shp = loadRShape(vektorlist[k]);
      poly = new FPolyPlus();
      //poly.setCollisionShape(unionPath(shp));
      poly.setCollisionShape(shp.getBoundsPoints());      
      poly.setDrawShape(loadShape(vektorlist[k]));

      traceBodies.add(poly);
      //world.add(poly);
    }
  }
  Collections.shuffle(traceBodies);
  rndx = random(0, (width/3)-30);
  for (int k = 0; k < traceBodies.size(); k++) { 
    poly = (FPolyPlus) traceBodies.get(k);
    poly.setVisible(true);
    poly.setDensity(0.2);
    poly.setRestitution(0.5);
    poly.setDamping(0);
    poly.setFriction(0.3);
    poly.setRotation(0);    
    poly.setPosition(rndx, (40*k)-80);
    world.remove(poly);
    world.add(poly);
  }

//============================================== OBSTACLE01 init ====
  if(firstRun) {
    obstacle = new FPolyMinus();
    String svgpath = "i/non-free/v/logos/va300logo_" +outputFormat +((invert) ? "_i" : "") +".svg";
    shp = loadRShape(svgpath);
    obstacle.setCollisionShape(unionPath(shp));
    obstacle.setDrawShape(loadShape(svgpath));
    obstX = random(40,width-130);
    obstY = random((height/2)+50, (height)-40);
    obstR = random(radians(-30), radians(30));
    
    singletonBodies.add(obstacle);
    world.add(obstacle);
  }
  obstacle.setStatic(true);  
  obstacle.setRotation(obstR);
  obstacle.setPosition(obstX, obstY);
  obstacle.setRestitution(random(0.4,1.2));
  obstacle.setFriction(wert2);

//============================================== OBSTACLE02 init ====
  if(firstRun) {
    obstacle02 = new FPolyMinus();
    String svgpath = "i/non-free/v/logos/sponsoren_" +outputFormat +((invert) ? "_i" : "") +".svg";
    shp = loadRShape(svgpath);
    obstacle02.setCollisionShape(unionPath(shp));
    obstacle02.setDrawShape(loadShape(svgpath));
    
    singletonBodies.add(obstacle02);
    world.add(obstacle02);
  }
  obstacle02.setStatic(true);  
  obstacle02.setPosition(0,height-70);
  obstacle02.setRestitution(random(0.4,1.2));
  obstacle02.setFriction(wert2);


//============================================== OBSTACLE03 init ====
  if(firstRun) {
    obstacle03 = new FPolyMinus();
    String svgpath = "i/non-free/v/logos/lafkon_" +outputFormat +((invert) ? "_i" : "") +".svg";
    shp = loadRShape(svgpath);
    obstacle03.setCollisionShape(unionPath(shp));
    obstacle03.setDrawShape(loadShape(svgpath));
    
    singletonBodies.add(obstacle03);
    world.add(obstacle03);
  }
  obstacle03.setStatic(true);  
  obstacle03.setPosition(-10,height-50);
  obstacle03.setRestitution(random(0.4,1.2));
  obstacle03.setFriction(wert2);
    
  
//============================================================
  if(firstRun) {
    allBodies.addAll(traceBodies);
    allBodies.addAll(singletonBodies);
    firstRun = false ;
  }

  canvas = this.g;
  if(invert) background(0);
  else background(255);
  
}//setup end


void draw() {
    if(frameCount%1000 == 0) {  //remove world floor (1st step)
      if(frameCount == 1000) {
        world.bottom.setPosition(width*2,height*2); 
        frameCount = -400;
        obstX = obstacle.getX();
        obstY = obstacle.getY();
      }  
    }
    if(frameCount == -1) {  //add world floor again (2nd step)
      world.bottom.setPosition(width/2,height+5);
      frameCount = -1000;
    }
    if(frameCount < -300) {
      if(frameCount == -900) {  //start clearcircle-tween (3st step)
        //Ani.to(this, 1.0, "eraserecty", height, Ani.QUAD_IN_OUT);
        t = new Tween(0f, 1f, 100, 0f, ijeoma.motion.MotionConstant.QUAD_BOTH);
        t.addParameter(new Parameter(this, "eraserecty", 0, height+100));
        t.play();
      } else if (frameCount == -600) {  //start logotween to new position and rotation (4th step)
          obstNextX = random(40,width-40);
          obstNextY = random((height/2)+50, (height)-180);
          obstNextR = random(radians(-30), radians(30));
          //Ani.to(this, 1.0, "obstX", obstNextX, Ani.QUAD_IN_OUT);
          //Ani.to(this, 1.0, "obstY", obstNextY, Ani.QUAD_IN_OUT);
          //Ani.to(this, 1.0, "obstR", obstNextR, Ani.QUAD_IN_OUT);
          tp = new TweenParallel();
          t = new Tween(0f, 1f, 100, 0f, ijeoma.motion.MotionConstant.QUAD_BOTH);
          t.addParameter(new Parameter(this, "obstX", obstX, obstNextX));
          tp.addChild(t);
          t = new Tween(0f, 1f, 100, 0f, ijeoma.motion.MotionConstant.QUAD_BOTH);
          t.addParameter(new Parameter(this, "obstY", obstY, obstNextY));
          tp.addChild(t);
          t = new Tween(0f, 1f, 100, 0f, ijeoma.motion.MotionConstant.QUAD_BOTH);
          t.addParameter(new Parameter(this, "obstR", obstR, obstNextR));
          tp.addChild(t);
          tp.play();
      }
        else if (frameCount == -500) { //finished this cycle -> start over again (5th step)
          reset();
      } else { //set tween values
          noStroke();     
          if(invert) fill(0,0,0); 
          else  fill(255);
        
          ellipseMode(RADIUS);
          ellipse(obstacle.getX()+40, obstacle.getY()+40, eraserecty, eraserecty);
        
          obstacle.setPosition(obstX, obstY);
          obstacle.setRotation(obstR);
      }  
    }  
  
  
    // advance simulation and draw world  
    world.step();
    if(frameCount%1 == 0) { //draw every n-th frame only
      world.draw(canvas);
    }  
    
}//draw end


void reset() {
  frameCount = 0;
  eraserecty = 0;
  setup();
}



//=================================================== UTILS ===========

RPoint[] unionPath(RShape shp) {
  RPoint[][] shapo = shp.getPointsInPaths();
  ArrayList polys = new ArrayList();
  RPolygon unionPoly = new RPolygon();

  for(int i = 0; i < shapo.length; i++) {
    RPolygon rpoly = new RPolygon(shapo[i]);
    polys.add(rpoly);
  }
  for(int i = 0; i < polys.size(); i++) {
    RPolygon p = (RPolygon) polys.get(i);
    unionPoly = unionPoly.union(p);
  }

  return unionPoly.getPoints();
}


RShape loadRShape(String svgpath) {
  RShape svgload;
  RG.ignoreStyles(true);
  //RG.setPolygonizer(RG.UNIFORMSTEP);  

  svgload = RG.loadShape(svgpath); 

  return svgload;
}