import java.util.ArrayList;
import java.util.HashMap;

import noc.Vector3D;
import processing.core.PApplet;
import processing.core.PImage;
import twitter4j.Trend;

public class Colony {

  private static final int FONT_SIZE = 15;
  public static final int TEXT_POINT_Y = 50;
  public static final int TEXT_POINT_X = 810;
  private static final int BACTERIAS_INITIAL_NUMBER = 70;
  private static final int MAX_AGE = 1000;
  private static final boolean DEATH_ENABLE = false;

  private ArrayList organisms;
  private HashMap hm;
  public Util util;
  private Organism mainBoid;
  public String action = "";
  private Path path;
  public boolean drawS[]; 
  public boolean drawHelp = false;
  public boolean drawDetails = false;

  public String menuSelection;

  private boolean didGoToInitialPoint = false;
  private String[] topics;

  public Colony(HashMap hm, Util util) {
    this.drawS = new boolean[11];
    drawS[1] = true;
    drawS[2] = true;
    drawS[3] = true;
    drawS[4] = true;
    drawS[5] = true;
    drawS[6] = true;
    drawS[7] = true;
    drawS[8] = true;
    drawS[9] = true;
    drawS[10] = true;
    menuSelection = "0";
    this.hm = hm;
    this.organisms = new ArrayList();
    this.util = util;
    //mainBoid = addBoid(new Vector3D(0, 0));
    this.path = new Path();
    pointsOnPath();
  }

  private void pointsOnPath() {
    path.addPoint(63,520);
    path.addPoint(74,119);
    path.addPoint(84,59);
    path.addPoint(145,34);
    path.addPoint(256,29);
    path.addPoint(332,29);
    path.addPoint(377,64);
    path.addPoint(390,118);
    path.addPoint(394,205);
    path.addPoint(398,420);
    path.addPoint(399,493);
    path.addPoint(388,540);
    path.addPoint(336,559);
    path.addPoint(232,565);
    path.addPoint(125,565);
    path.addPoint(78,541);
    path.addPoint(66,519);
    path.addPoint(65,517);
  }

  public void addInitialBacterias() {
    for (int i = 0; i < BACTERIAS_INITIAL_NUMBER; i++) {
      organisms.add(new Organism(new Vector3D(random(width), random(height)),
      3.0f, 0.1f, util.randomGroup(), floor(random(1.0f, 3.0f)), hm));
    }
  }

  public synchronized Organism addBoid(Vector3D initialPosition) {
    Organism b = new Organism(initialPosition, 3.0f, 0.1f, util.randomGroup(), PApplet.floor(random(1.0f, 4.0f)), hm);
    organisms.add(b);
    return b;
  }

  public synchronized Organism addBoid(Vector3D initialPosition, String group) {
    Organism b = new Organism(initialPosition, 1.5f, 0.1f, group, floor(random(1.0f, 4.0f)), hm);
    organisms.add(b);
    return b;
  }


  public synchronized void loop() {

    path.display();
    textFont(font, 10);
    Iterator it = organisms.iterator();
    //while(it.hasNext()){
    for (int i = 0; i < organisms.size(); i++) {
      Organism b = (Organism)organisms.get(i);
      //Organism b = (Organism)it.next();
      if (b.age > MAX_AGE && DEATH_ENABLE) {
        organisms.remove(i);
      } 
      else {
        act(b);
        if(b.group.equals("1")){
          b.selected = true;
        }
        if(checkGroupRun(b.group)){
          b.run();
        }
        mainBoid = b;
      }
    }
    
    this.displayMenu();	
//    if(organisms.size() > 120){
//      util.duplicateControl = new Vector();
//      organisms.clear();
//    }	
  }

  private boolean checkGroupRun(String group){
    boolean ret = true;
    if(group.equals("1") && drawS[1]){
      ret = true;
    } 
    else if(group.equals("2") && drawS[2]){
      ret = true;
    } 
    else if(group.equals("3") && drawS[3]){
      ret = true;
    } 
    else if(group.equals("4") && drawS[4]){
      ret = true;
    } 
    else if(group.equals("5") && drawS[5]){
      ret = true;
    } 
    else if(group.equals("6") && drawS[6]){
      ret = true;
    } 
    else if(group.equals("7") && drawS[7]){
      ret = true;
    }
    else if(group.equals("8") && drawS[8]){
      ret = true;
    }
    else if(group.equals("9") && drawS[9]){
      ret = true;
    }
    else if(group.equals("10") && drawS[10]){
      ret = true;
    }
    else {
      ret = false;
    }
    return ret;
  }

  private Vector3D locationsOrganize(Organism b) {
    String group = b.group;
    Vector3D dest = new Vector3D(0, 0);
    if (group.equals("1")) {
      dest = new Vector3D(108, 97);
    } 
    else if (group.equals("2")) {
      dest = new Vector3D(301, 83);
    }
    else if (group.equals("3")) {
      dest = new Vector3D(472, 102);
    } 
    else if (group.equals("4")) {
      dest = new Vector3D(718, 184);
    } 
    else if (group.equals("5")) {
      dest = new Vector3D(665, 386);
    } 
    else if (group.equals("6")) {
      dest = new Vector3D(498, 326);
    } 
    else if (group.equals("7")) {
      dest = new Vector3D(316, 326);
    } 
    else if (group.equals("8")) {
      dest = new Vector3D(139, 382);
    }
    else if (group.equals("9")) {
      dest = new Vector3D(188, 559);
    } 
    else {
      dest = new Vector3D(500, 556);
    }
    return dest;
  }

  private synchronized void act(Organism b) {
    if (action.equals("organize")) {
      Vector3D dest = locationsOrganize(b);
      b.seek(dest);
    } 
    else if (action.equals("stopAll")) {
      b.stop();
    } 
    else if (action.equals("follow")) {
      b.follow(mainBoid);
    } 
    else if (action.equals("goRound")) {
      b.goRound(mainBoid);
    } 
    else if (action.equals("followPath")) {
      followPath(b);
    } 
    else if(action.equals("killAll")) {
      this.organisms.removeAll(organisms);
      action = "wander";
    } 
    else if(action.equals("wander")) {
      b.wander();
    } 
    else {
      b.wander();
    }
    if(!action.equals("followPath")){
      didGoToInitialPoint = false;
      b.isLabelEnable = false;
    }
  }

  private void followPath(Organism b){
    b.acceleration.normalize();
    b.velocity.normalize();
    moveEverybody();
    obstacle(b);
    printLabel(b);
    b.follow(path);
    if(b.stopped){
      if(st.blockade){
        b.acceleration.limit(10);
        b.acceleration.add(new Vector3D(100,0));
        b.velocity.limit(100);
        b.velocity.add(new Vector3D(100,0));
        b.velocity.normalize();
        b.acceleration.normalize();
        b.stopped = false;	
        st.blockade = false;
      }
    }
  }

  private void printLabel(Organism b) {
    float up = 60;
    float down = 550;
    float left = 300;
    float right = 425;
    if(b.location.x > left && b.location.x < right
      && b.location.y > up && b.location.y < down){
      b.isLabelEnable = true;
    } 
    else {
      b.isLabelEnable = false;
    }
  }

  private void moveEverybody() {
    if(!didGoToInitialPoint){
      for (int i = 0; i <this.organisms.size(); i++) {
        Organism b = (Organism)organisms.get(i);
        b.location.x = 50;
        b.location.y = 50;
      }
      didGoToInitialPoint = true;
    }

  }

  public void obstacle(Organism b){
    float up = 15;
    float down = 40;
    float left = 200;
    float right = 205;
    if(b.location.x > left && b.location.x < right
      && b.location.y > up && b.location.y < down){
      b.stop();
    }
  }

  public void setAction(String action) {
    this.action = action;
  }
  
  public void removeAllFromGroup(String group){
    for (int i = 0; i < organisms.size(); i++) {
      Organism org = (Organism)organisms.get(i);
      if(org.group.equals(group)){
        organisms.remove(i);
      }
    }
  }

  public void updateTopics(String[] topics, int rateLimitRemaining) {
    this.topics = topics;
  }

  public void displayMenu(){
    int currentX = 10;
    int currentY = 90;

    PImage aux;

    textFont(font, 15);
    text(organisms.size() + " organisms", 800 + currentX + 15, currentY - 25);

    if(this.topics == null){
      textFont(fontMenu,14);
      text("acquiring information...", 800 + currentX, currentY);
    } 
    else {
      for(int i = 1; i <= 10; i++){
        String trendTitle = topics[i-1].split("OR")[0].trim();
        aux = (PImage)hm.get("ic" + i);
        pushMatrix();
        translate(800 + currentX,currentY);
        image(aux, 0, 0);
        if(menuCollision(800 + currentX,currentY,200,40)){
          menuSelection = i + "";
        }
        fill(255);
        textFont(fontMenu,14);
        text(trendTitle, 40, 20);
        if(!drawS[i]){
          stroke(255);
          color c = color(200, 0, 0, 70);
          fill(c);
          rect(-10,-5, 200, 40);
        }
        popMatrix();       
        currentY = currentY + 40;
      }

      if(menuCollision(930,525,70,30)){
        menuSelection = "help";
      } 
      else if(menuCollision(910,560,80,30)){
        menuSelection = "details";
      }

      if(drawHelp){
        image(help, 26,21);
      } 
      else if (drawDetails){
        image(details, 26,21);
      }





      //      for (int i = 0; i < 6; i++) {
      //        String trendTitle = topics[i].getQuery().split("OR")[0].trim();
      //        nextY = FONT_SIZE + TEXT_POINT_Y + (i+1)*FONT_SIZE;
      //        noStroke();
      //        fill(pallette[i]);
      //        rect(TEXT_POINT_X, nextY - FONT_SIZE + 4, 20, FONT_SIZE);
      //        fill(255);
      //        textFont(fontMenu,14);
      //        text(trendTitle, TEXT_POINT_X + 25, nextY);
      //      }

    }
    //text(this.rateLimitRemaining + " RLR", TEXT_POINT_X, nextY + FONT_SIZE);		
  }

  private boolean menuCollision(int X, int Y, int thX, int thY) {
    boolean ret = false;
    float boundXR = X + thX;
    float boundXL = X;// - thX;
    float boundYU = Y;// - thY;
    float boundYD = Y + thY;
    if(mouseX > boundXL && 
      mouseX < boundXR && 
      mouseY > boundYU &&
      mouseY < boundYD){
      ret = true;
    }
    return ret;
  }

}

  import twitter4j.Trend;
import twitter4j.Twitter;
import twitter4j.TwitterException;

public class Feeder extends Thread{

  private static final int NUMBER_TRENDS = 9;
  private Twitter twitter;
  private Colony colony;

  public Feeder(Colony colony){
    this.twitter = new Twitter();
    this.colony = colony;
  }

  public void run() {
    String[] queryFile = loadStrings("query.txt");
    String query = queryFile[0];
    String[] topics = new String[NUMBER_TRENDS + 1];
    while(true){
      try {
        Trend[] trends = twitter.getCurrentTrends().getTrends();
        int rateLimitRemaining = twitter.rateLimitStatus().getRemainingHits();
        SearchAndAddThread[] threads = new SearchAndAddThread[NUMBER_TRENDS + 1];
        for (int i = 0; i < NUMBER_TRENDS; i++) {
          String trend  = trends[i].getQuery();
          topics[i+1] = trend;
          threads[i+1] = new SearchAndAddThread("SAThread" + (i + 1), trend, colony, i+2);
          threads[i+1].start();					
        }
        topics[0] = query;
        threads[0] = new SearchAndAddThread("SAThread" + 0, query, colony, 1);
        threads[0].start();
        colony.updateTopics(topics, rateLimitRemaining);				
        sleep(25000);
      } 
      catch (InterruptedException e) {
        e.printStackTrace();
      } 
      catch (TwitterException e) {
        e.printStackTrace();
      }
    }
  }
}

  import noc.*;
import java.util.HashMap;
import processing.core.PApplet;
import processing.core.PFont;
import processing.core.PImage;

int WINDOW_WIDTH = 1000;
int WINDOW_HEIGHT = 600;

Util util;
HashMap hm;

Colony colony;

PFont font;
PFont fontMenu;
PFont fontCredits;

boolean isLoaded;
boolean background;
PImage bg;
PImage details;
PImage help;

Feeder fd;
ParadeTimerThread st;
PresenterThread presenter;

void setup() {
  size(1000, 600);
  colorMode(RGB,255,255,255,100);

  this.util = new Util();
  this.hm = new HashMap();

  this.colony = new Colony(hm, util);
  fd = new Feeder(colony);
  fd.start();

  //this.font = loadFont("CourierNewPSMT-15.vlw");//createFont("comfortaa.ttf", 15);
  this.fontMenu = createFont("comfortaa.ttf", 14);
  this.font = fontMenu;
  this.fontCredits = loadFont("fontCredits.vlw");
  background = true;

  st = new ParadeTimerThread("ParadeTimer");
  st.start();
  
  presenter = new PresenterThread("PresenterThread", colony);
  presenter.start();

  bg = loadImage("background3.png");
  details = loadImage("details-menu2.png");
  help = loadImage("about-menu2.png");
  //smooth();
}

void draw() {
  if(background){
    background(0,0,127,50);
    image(bg, 0, 0);
  } 
  if(!util.isLoaded){
    textFont(this.font,15);
    text("Loading images...", 100, 100);
    this.util.preloadImages(hm);			
  }
  line(800,0,800,600);
  this.colony.loop();
}

void mousePressed() {
  //this.colony.addBoid(new Vector3D(mouseX,mouseY));
  //println(mouseX + " | " + mouseY);
  if(mouseX < 800){
    colony.menuSelection = "0";
  }
  if(this.colony.menuSelection.equals("1")){
    colony.drawS[1] = !colony.drawS[1];
  } 
  else if(this.colony.menuSelection.equals("2")){
    colony.drawS[2] = !colony.drawS[2];
  } 
  else if(this.colony.menuSelection.equals("3")){
    colony.drawS[3] = !colony.drawS[3];
  } 
  else if(this.colony.menuSelection.equals("4")){
    colony.drawS[4] = !colony.drawS[4];
  } 
  else if(this.colony.menuSelection.equals("5")){
    colony.drawS[5] = !colony.drawS[5];
  } 
  else if(this.colony.menuSelection.equals("6")){
    colony.drawS[6] = !colony.drawS[6];
  } 
  else if(this.colony.menuSelection.equals("7")){
    colony.drawS[7] = !colony.drawS[7];
  } 
  else if(this.colony.menuSelection.equals("8")){
    colony.drawS[8] = !colony.drawS[8];
  } 
  else if(this.colony.menuSelection.equals("9")){
    colony.drawS[9] = !colony.drawS[9];
  } 
  else if(this.colony.menuSelection.equals("10")){
    colony.drawS[10] = !colony.drawS[10];
  }
  else if(this.colony.menuSelection.equals("help")){
    colony.drawHelp = !colony.drawHelp;
    colony.drawDetails = false;
  }
  else if(this.colony.menuSelection.equals("details")){
    colony.drawDetails = !colony.drawDetails;
    colony.drawHelp = false;
  } 
  
  else {

  } 
}

void mouseReleased(){
  colony.menuSelection = "0";
}

void keyPressed(){
  if(key == 'a' || key == 'A'){
    this.colony.setAction("organize");
  } 
  else if (key == 's' || key == 'S'){
    this.colony.setAction("stopAll");
  } 
  else if(key == 'e' || key == 'E'){
    this.colony.setAction("follow");
  } 
  else if(key == 'd' || key == 'D'){
    this.colony.setAction("wander");
  } 
  else if(key == 'w' || key == 'W'){
    this.colony.setAction("goRound");
  } 
  else if(key == 'q' || key == 'Q'){
    this.colony.setAction("followPath");
  } 
  else if(key == 'r' || key == 'R'){
    background = !background;
  } 
  else if(key == 'f' || key == 'F'){
    this.colony.setAction("killAll");
  } 
  else if(key == '1'){
    colony.drawS[1] = !colony.drawS[1];
  } 
  else if(key == '2'){
    colony.drawS[2] = !colony.drawS[2];
  } 
  else if(key == '3'){
    colony.drawS[3] = !colony.drawS[3];
  } 
  else if(key == '4'){
    colony.drawS[4] = !colony.drawS[4];
  } 
  else if(key == '5'){
    colony.drawS[5] = !colony.drawS[5];
  } 
  else if(key == '6'){
    colony.drawS[6] = !colony.drawS[6];
  }
  else if(key == '7'){
    colony.drawS[7] = !colony.drawS[7];
  }
  else if(key == '8'){
    colony.drawS[8] = !colony.drawS[8];
  }
  else if(key == '9'){
    colony.drawS[9] = !colony.drawS[9];
  }
  else if(key == '0'){
    colony.drawS[10] = !colony.drawS[10];
  }
}

  import java.util.HashMap;

import noc.Vector3D;
import processing.core.PApplet;
import processing.core.PImage;


//Seek_Arrive
// Daniel Shiffman <http://www.shiffman.net>

// The "Boid" class

// Created 2 May 2005

/**
 * Class Boid created by Daniel Shiffman <http://www.shiffman.net>
 * 
 * Class Boid modified by Filipe Calegario <http://filipecalegario.com>
 * @author fcac
 */
public class Organism {

  private static final boolean AGING_ENABLE = true;

  public String text;

  Vector3D location;
  Vector3D lastLocation;
  Vector3D velocity;
  Vector3D acceleration;
  float r;
  float wandertheta;
  float maxforce;    // Maximum steering force
  float maxspeed;    // Maximum speed

    PImage img;
  int choose;
  String group;
  int subspecie;
  int age;
  boolean stopped = false;
  boolean selected = false;

  public long pseudoTimer = 0;

  HashMap preloadedImgs;

  public boolean isLabelEnable;

  public Organism(Vector3D l, float ms, float mf, String g, int s, HashMap hm) {
    this.acceleration = new Vector3D(0,0);
    this.velocity = new Vector3D(0,0);
    this.location = l.copy();
    this.r = 2.0f;
    this.wandertheta = 0.0f;
    this.maxspeed = ms;
    this.maxforce = mf;

    this.choose = 1;
    this.group = g;
    this.subspecie = s;
    this.age = 0;

    this.preloadedImgs = hm;		
    this.text = "waiting      information...";
    this.img = loadImage("new_species/" + group + "-1.png");
  }

  public void run() {
    update();
    if(AGING_ENABLE){
      age++;
    }
    borders();
    render();
  }

  // Method to update location
  public void update() {
    // Update velocity
    velocity.add(acceleration);
    // Limit speed
    velocity.limit(maxspeed);
    lastLocation = location.copy();
    location.add(velocity);
    // Reset acceleration to 0 each cycle
    acceleration.setXYZ(0,0,0);
  }

  public void seek(Vector3D target) {
    acceleration.add(steer(target,false));
  }

  public void arrive(Vector3D target) {
    acceleration.add(steer(target,true));
  }

  public void follow(Organism followee){
    acceleration.add(steer(followee.location, true));
  }

  // This function implements Craig Reynolds' path following algorithm
  // http://www.red3d.com/cwr/steer/PathFollow.html
  public void follow(Path p) {

    // Predict location 25 (arbitrary choice) frames ahead
    Vector3D predict = velocity.copy();
    predict.normalize();
    predict.mult(25);
    Vector3D predictLoc = Vector3D.add(location, predict);

    // Now we must find the normal to the path from the predicted location
    // We look at the normal for each line segment and pick out the closest one
    Vector3D target = null;
    Vector3D dir = null;
    float record = 1000000;  // Start with a very high record distance that can easily be beaten

    // Loop through all points of the path
    for (int i = 0; i < p.points.size()-1; i++) {

      // Look at a line segment
      Vector3D a = (Vector3D) p.points.get(i);
      Vector3D b = (Vector3D) p.points.get(i+1);

      // Get the normal point to that line
      Vector3D normal = getNormalPoint(predictLoc,a,b);

      // Check if normal is on line segment
      float da = Vector3D.distance(normal,a);
      float db = Vector3D.distance(normal,b);
      Vector3D line = Vector3D.sub(b,a);
      // If it's not within the line segment, consider the normal to just be the end of the line segment (point b)
      if (da + db > line.magnitude()+1) {
        normal = b.copy();
      }

      // How far away are we from the path?
      float d = Vector3D.distance(predictLoc,normal);
      // Did we beat the record and find the closest line segment?
      if (d < record) {
        record = d;
        // If so the target we want to steer towards is the normal
        target = normal;

        // Look at the direction of the line segment so we can seek a little bit ahead of the normal
        dir = line;
        dir.normalize();
        // This is an oversimplification
        // Should be based on distance to path & velocity
        dir.mult(10);
      }
    }

    // Draw the debugging stuff
    if (false) {
      // Draw normal location
      fill(0);
      noStroke();
      line(predictLoc.x,predictLoc.y,target.x,target.y);
      ellipse(target.x,target.y,4,4);
      stroke(0);
      // Draw actual target (red if steering towards it)
      line(predictLoc.x,predictLoc.y,target.x,target.y);
      if (record > Path.RADIUS) fill(255,0,0);
      noStroke();
      ellipse(target.x+dir.x, target.y+dir.y, 8, 8);
    }

    // Only if the distance is greater than the path's radius do we bother to steer
    if (record > Path.RADIUS) {
      target.add(dir);
      seek(target);			
    }
  }

  public void stop(){
    velocity.limit(0);
    acceleration.limit(0);
    this.stopped = true;
  }

  public void wander() {
    float wanderR = 16.0f;         // Radius for our "wander circle"
    float wanderD = 60.0f;         // Distance for our "wander circle"
    float change = 0.25f;
    wandertheta += random(-change,change);     // Randomly change wander theta

    // Now we have to calculate the new location to steer towards on the wander circle
    Vector3D circleloc = velocity.copy();  // Start with velocity
    circleloc.normalize();            // Normalize to get heading
    circleloc.mult(wanderD);          // Multiply by distance
    circleloc.add(location);               // Make it relative to boid's location

      Vector3D circleOffSet = new Vector3D(wanderR*PApplet.cos(wandertheta),wanderR*PApplet.sin(wandertheta));
    Vector3D target = Vector3D.add(circleloc,circleOffSet);
    acceleration.add(steer(target,false));  // Steer towards it		
  }  

  private Vector3D steer(Vector3D target, boolean slowdown) {
    Vector3D steer;  // The steering vector
    Vector3D desired = Vector3D.sub(target,location);  // A vector pointing from the location to the target
    float d = desired.magnitude(); // Distance from the target is the magnitude of the vector
    if (d > 0) {
      desired.normalize();
      if ((slowdown) && (d < 100.0f)) {
        desired.mult(maxspeed*(d/100.0f)); // This damping is somewhat arbitrary
      } 
      else {
        desired.mult(maxspeed);
      }
      steer = Vector3D.sub(desired,velocity);
      steer.limit(maxforce);  // Limit to maximum steering force
    } 
    else {
      steer = new Vector3D(0,0);
    }
    return steer;
  }

  public void goRound(Organism b){
    this.acceleration.add(roundVec(b));
  }



  public void render() {
    float theta = velocity.heading2D() + PApplet.radians(90);
    fill(255);
    stroke(255);
    //    if(choose == 26){
    //      choose = 1;
    //    }
    pushMatrix();
    if(checkCollisionWithMouse() && mousePressed){
        selected = !selected;
    }
    if(checkCollisionWithMouse() || isLabelEnable || selected){
      highlight();      
    }
    

    translate(location.x,location.y);
    //rotate(PApplet.radians(-90));
    rotate(theta);
    String animation = animation();
    //println(animation);
    PImage img = (PImage)preloadedImgs.get(animation);
    //PImage img = loadImage("new_species/1-1.png");
    image(img, -img.width/2, -img.height/2);
    popMatrix();
  }

  private Vector3D roundVec(Organism b){
    Vector3D direct = Vector3D.sub(b.location, this.location);
    Vector3D side = Vector3D.rotate2D(direct, PApplet.radians(90));
    side.normalize();
    direct.normalize();
    Vector3D result = Vector3D.add(direct, side);
    result.normalize();
    result.mult(0.4f);
    return result;
  }

  private void highlight(){
    float recWidth = 30;
    float recHeight = 30;
    float lineM = 40;
    //noFill();
    //fill(color(0, 255, 0, 80));
    
    String[] pieces = this.text.split(" ");
    String finalText = "";
    for(int i = 0; i < pieces.length; i++){
      finalText = finalText + pieces[i] + " "; 
      if(i == (pieces.length/2 - 1)){
        finalText = finalText + "\n";
      }
    }
    
    fill(color(35,64,245,90));
    strokeWeight(4);
    ellipse(location.x, location.y, 70, 70);
    strokeWeight(1);
    Vector3D edge4 = new Vector3D(location.x + lineM, location.y - lineM);
    Vector3D edge1 = new Vector3D(edge4.x, edge4.y + recHeight);
    Vector3D edge2 = new Vector3D(edge1.x + recWidth, edge1.y);
    Vector3D edge3 = new Vector3D(edge1.x + recWidth, edge1.y + recHeight);
    line(location.x, location.y, edge1.x, edge1.y);
    line(edge1.x, edge1.y, edge4.x, edge4.y);
    line(edge1.x, edge1.y, edge2.x, edge2.y);
    rect(edge4.x, edge4.y - 30, this.text.length()*5, 60);
    fill(255);
    textFont(font, 15);
    text(finalText, edge1.x + 15, edge1.y - 40);
  }

  private String animation(){
    if(choose == 4){
      choose = 1;
    }
    choose++;
    return group + "-" + choose; 
  }

  //  private String animation(){
  //    String imgFile = "";
  //    int limit = 26;
  //    if(subspecie == 3){
  //      limit = 6;
  //    }
  //    if(choose == limit){
  //      choose = 1;
  //    }
  //    if(choose < 10){
  //      imgFile = "0" + choose + ".png";
  //    } 
  //    else {
  //      imgFile = choose + ".png";
  //    }
  //    String ageAppear = "";
  //    if(age > 1000){
  //      ageAppear = "5";
  //    } 
  //    else if (age > 800){
  //      ageAppear = "4";
  //    } 
  //    else if (age > 600){
  //      ageAppear = "3";
  //    } 
  //    else if (age > 400){
  //      ageAppear = "2";
  //    } 
  //    else {
  //      ageAppear = "1";
  //    }
  //    if(AGING_ENABLE){
  //      age++;
  //    }
  //    choose++;
  //    String ret = "species/" + group + "/" + subspecie + "/" + ageAppear + "/" + imgFile;
  //    return ret;
  //  }

  private Vector3D getNormalPoint(Vector3D p, Vector3D a, Vector3D b) {
    Vector3D ap = Vector3D.sub(p,a);
    Vector3D ab = Vector3D.sub(b,a);
    ab.normalize(); 
    ab.mult(ap.dot(ab));
    Vector3D normalPoint = Vector3D.add(a,ab);
    return normalPoint;
  }

  private boolean checkCollisionWithMouse() {
    boolean ret = false;
    float boundXR = location.x + 22;
    float boundXL = location.x - 22;
    float boundYU = location.y - 22;
    float boundYD = location.y + 22;
    if(mouseX > boundXL && 
      mouseX < boundXR && 
      mouseY > boundYU &&
      mouseY < boundYD){
      ret = true;
    }
    return ret;
  }

  private void borders() {
    float width = 800;
    float height = 600;
    if (location.x < -r) location.x = width+r;
    if (location.y < -r) location.y = height+r;
    if (location.x > width+r) location.x = -r;
    if (location.y > height+r) location.y = -r;
    //    if ((location.y > height) || (location.y < 0))  {
    //     			velocity.y *= -1;
    //     		}
    //     		if ((location.x < 0) || (location.x > width)) {
    //     			velocity.x *= -1;
    //     		}
  }
}

  public class ParadeTimerThread extends Thread {

  public boolean blockade = true;

  public ParadeTimerThread(String name) {
    super(name);
  }

  public void run() {
    while(true){
      try {
        sleep(700);
        this.blockade = true;
        sleep(700);
        this.blockade = false;
      } 
      catch (InterruptedException e) {
        e.printStackTrace();
      }
      blockade = true;
    }	
  }
}

  import java.util.ArrayList;

import noc.Vector3D;
import processing.core.PApplet;

// Path Following
// Daniel Shiffman <http://www.shiffman.net>
// The Nature of Code, Spring 2009

class Path {

  private static final boolean DEBUG = false;
  public static final float RADIUS = 8;

  ArrayList points;
  boolean first;
  public Vector3D initialPoint;

  public Path() {
    points = new ArrayList();
    first = true;
  }

  public void addPoint(float x, float y) {
    Vector3D point = new Vector3D(x,y);
    if(first){
      initialPoint = point.copy();
      first = false;
    }
    points.add(point);
  }

  // Draw the path
  public void display() {
    // Draw the radius as thick lines and circles
    if (DEBUG) {
      // Draw end points
      for (int i = 0; i < points.size(); i++) {
        Vector3D point = (Vector3D) points.get(i);
        fill(175);
        noStroke();
        ellipse(point.x,point.y,RADIUS*2,RADIUS*2);
      }

      // Draw Polygon around path
      for (int i = 0; i < points.size()-1; i++) {
        Vector3D start = (Vector3D) points.get(i);
        Vector3D end = (Vector3D) points.get(i+1);
        Vector3D line = Vector3D.sub(end,start);
        Vector3D normal = new Vector3D(line.y,-line.x);
        normal.normalize();
        normal.mult(RADIUS);

        // Polygon has four vertices
        Vector3D a = Vector3D.add(start, normal);
        Vector3D b = Vector3D.add(end, normal);
        Vector3D c = Vector3D.sub(end, normal);
        Vector3D d = Vector3D.sub(start, normal);

        fill(175);
        noStroke();
        beginShape();
        vertex(a.x,a.y);
        vertex(b.x,b.y);
        vertex(c.x,c.y);
        vertex(d.x,d.y);
        endShape();
      }

      // Draw Regular Line
      stroke(0);
      noFill();
      beginShape();
      for (int i = 0; i < points.size(); i++) {
        Vector3D loc = (Vector3D) points.get(i);
        vertex(loc.x,loc.y);
      }
      endShape();
    }

  }

}

  public class PresenterThread extends Thread {

  public Colony colony;
  public final int WANDER_TIME = 20000;
  public final int PARADE_TIME = 40000;
  public final int SELECTION_TIME = 60000;
  public final int HELP_TIME = 15000;
  public final int DETAILS_TIME = 15000;

  public PresenterThread(String name, Colony colony) {
    super(name);
    this.colony = colony;
  }

  public void run() {
    try {
      while(true){
        //----------------------
        colony.action = "wander";
        sleep(WANDER_TIME);
        //----------------------
        colony.drawDetails = false;
        colony.action = "followPath";
        sleep(PARADE_TIME);
        //----------------------
        colony.action = "wander";
        colony.drawS[2] = false;
        colony.drawS[3] = false;
        colony.drawS[4] = false;
        colony.drawS[5] = false;
        colony.drawS[6] = false;
        colony.drawS[7] = false;
        colony.drawS[8] = false;
        colony.drawS[9] = false;
        colony.drawS[10] = false;
        sleep(SELECTION_TIME);
        colony.drawS[2] = true;
        colony.drawS[3] = true;
        colony.drawS[4] = true;
        colony.drawS[5] = true;
        colony.drawS[6] = true;
        colony.drawS[7] = true;
        colony.drawS[8] = true;
        colony.drawS[9] = true;
        colony.drawS[10] = true;
        //----------------------
        util.duplicateControl = new Vector();
        colony.organisms.clear();
        //----------------------
        colony.drawHelp = true;
        sleep(HELP_TIME);
        //----------------------
        colony.drawHelp = false;
        colony.drawDetails = true;        
        sleep(DETAILS_TIME);
        //----------------------
        util.duplicateControl = new Vector();
        colony.organisms.clear();
      }	
    }
    catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }

}

  import java.util.List;
import java.util.Vector;

import noc.Vector3D;
import twitter4j.Query;
import twitter4j.QueryResult;
import twitter4j.Tweet;
import twitter4j.Twitter;
import twitter4j.TwitterException;

public class SearchAndAddThread extends Thread {

  private String query;
  private Colony colony;
  private int group;
  private Twitter twitter;
  private Vector previousTweets;

  public SearchAndAddThread(String name, String query, Colony colony, int group) {
    super(name);
    this.query = query;
    this.colony = colony;
    this.group = group;
    this.twitter = new Twitter();
    this.previousTweets = new Vector();
  }

  public void run() {
    QueryResult result;
    try {
      this.query = this.query.replaceAll("\"", "");
      this.query = this.query.replaceAll("#", "");
      result = twitter.search(new Query(this.query));
      List tweets = result.getTweets();
      for (int i = 0; i < tweets.size(); i++) {
        Tweet tw = (Tweet)tweets.get(i);
        String text = tw.getText();
        if(this.getName().equals("SAThread0")){
          text = "@" + tw.getFromUser() + " " + text;
        }
        if(!util.duplicateControl.contains(text)){
          util.duplicateControl.add(text);
          Organism b = colony.addBoid(new Vector3D(0,0), util.getGroup(this.group));
          b.text = text;
        }
        Thread.sleep(10000);        
      }
    } 
    catch (TwitterException e1) {
      // TODO Auto-generated catch block
      e1.printStackTrace();
    } 
    catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    };
  }	
}

  import java.util.HashMap;

import noc.Vector3D;
import processing.core.PApplet;
import processing.core.PImage;

public class Util {

  boolean isLoaded;
  
  public Vector duplicateControl;

  public Util() {
    duplicateControl = new Vector();  
    isLoaded = false;
  }

  private String format(int animation){
    String imgFile = "";
    if(animation < 10){
      imgFile = "0" + animation + ".png";
    } 
    else {
      imgFile = animation + ".png";
    }
    return imgFile;
  }

public void preloadImages(HashMap hm){
  for(int i = 1; i <= 10; i++){
    for(int j = 1; j<= 4; j++ ){
      String imgPath = "new_species/" + i + "-" + j + ".png";
      //println(imgPath);
      PImage img = loadImage(imgPath);
      hm.put(i + "-" + j, img);
    }
    String imgPath = "new_species/ic" + i + ".png";
    PImage img = loadImage(imgPath);
    hm.put("ic" + i, img);
  }
  isLoaded = true;
}

//  public void preloadImages(HashMap hm){
//    String group = "";
//    String imgPath = "";
//    for(int i = 1; i <= 6; i++){
//      switch(i){
//      case 1:
//        group = "familie";
//        break;
//      case 2:
//        group = "job";
//        break;
//      case 3:
//        group = "orders";
//        break;
//      case 4:
//        group = "school";
//        break;
//      case 5:
//        group = "spam";
//        break;
//      case 6:
//        group = "unclass";
//        break;
//      }
//      for(int s = 1; s <= 3; s++){
//        for (int a = 1; a <= 5; a++){
//          switch(s){
//          case 1:
//          case 2:
//            for(int animation = 1; animation <=25; animation++){
//              imgPath = "species/" + group + "/" + s + "/" + a + "/" + format(animation);
//              PImage img = loadImage(imgPath);
//              hm.put(imgPath, img);
//            }
//            break;
//          case 3:
//            for(int animation = 1; animation <=5; animation++){
//              imgPath = "species/" + group + "/" + s + "/" + a + "/" + format(animation);
//              PImage img = loadImage(imgPath);
//              hm.put(imgPath, img);
//            }
//            break;
//          }
//        }
//      }
//
//    }
//    isLoaded = true;
//  }

  public String randomGroup(){
//      int i = PApplet.floor(random(1.0f,7.0f));
//      String rt = "";
//      if(i == 1){
//        rt = "familie";
//      } 
//      else if(i == 2){
//        rt = "job";
//      } 
//      else if(i == 3){
//        rt = "orders";
//      } 
//      else if(i == 4){
//        rt = "school";
//      } 
//      else if(i == 5){
//        rt = "spam";
//      } 
//      else {
//        rt = "unclass";
//      }
    String ret = "" + floor(random(1,11));
  // println(ret); 
    return ret;
  }

  public void drawVector(Vector3D vector, Vector3D location, float scayl) {
    pushMatrix();
    float arrowsize = 4;
    // Translate to location to render vector
    translate(location.x,location.y);
    stroke(255);
    // Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
    rotate(vector.heading2D());
    // Calculate length of vector & scale it to be bigger or smaller if necessary
    float len = vector.magnitude()*scayl;
    // Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
    line(0,0,len,0);
    line(len,0,len-arrowsize,+arrowsize/2);
    line(len,0,len-arrowsize,-arrowsize/2);
    popMatrix();
  }

  public String getGroup(int i) {
    String ret = "";
    switch (i) {
    case 1:
      ret = "1";
      break;
    case 2:
      ret = "2";
      break;
    case 3:
      ret = "3";
      break;
    case 4:
      ret = "4";
      break;
    case 5:
      ret = "5";
      break;
    case 6:
      ret = "6";
      break;
    case 7:
      ret = "7";
      break;
    case 8:
      ret = "8";
      break;
    case 9:
      ret = "9";
      break;
    default:
      ret = "10";
      break;
    }
    return ret;
  }

}