Hi Guys,
so I'm preparing an exhibition in two days.  Cutting it close I know.  I've spent most of my time implementing Sphinx4 speech recognition into processing, which I want to share with everyone soon enough.  I'm having some difficulty on the graphics here. 

I've used a bit of code from a previous poster for a wanderer.  What I've done is pass a variable _l in the event Listener that has the keyword that was recognized by the recognizer engine.  That value is going to be one of 4 things "love" "hate" "happy" "sad".  I'm trying to get the particles that are associated with that keyword to move to a coordinate,  if that text is true in the _l.readString() in the void EventListener.

I've tried every which way to get it sorted.  This is where I'm at with it so far.  So everything runs but I just can't get the if statement to work and get the balls to move to a coordinate.

Help is most appreciated!

Twitter myTwitter;
Listen reading;

Particle ball;
Particle arriver;


int max_width = 800;
int max_height = 800;

String s = "";



ArrayList finding = new ArrayList();
ArrayList finding2 = new ArrayList();
ArrayList finding3 = new ArrayList();
ArrayList finding4 = new ArrayList();

void loadTwitter() {
     myTwitter = new Twitter("yourTwitterUserName", "yourTwitterPassword");
  
    try {
        String searchKeys = "love OR hate OR sad OR happy";
         
        // Search twitter for tweets matching the query

        println("Searching Twitter for " + searchKeys);
         
        Query tquery = new Query(searchKeys);
         
        tquery.setRpp(100);
       
        QueryResult result = myTwitter.search(tquery);
       
        for (int i = 0; i < 4; i++)     // Loop though 4 pages of search results
        {
            ArrayList tweets = (ArrayList) result.getTweets();

            println("tweets found : " + tweets.size());
           
            // Set the next page for the search results
            tquery.setPage(tquery.getPage() + 1);
           
            // Create a wanderer class for each of the search results and add it to the array
            for (int k = 0; k < tweets.size(); k++) {
 
                                int colCount = 0;
                                int colRed = 0;
                                int colGreen = 0;
                                int colBlue = 0;
                               
                 Particle ball = new Particle(new PVector(width/2,height/2),random(max_width), random(max_height) );  
                 
                // Get the tweet text
                                String tweetText = tweets.get(k).toString();   
                ball.setTweet(tweetText);   
                // Set the tweet text in the class
               
                                // convert the text to lowercase (for searching)
                tweetText = tweetText.toLowerCase();            
                if (tweetText.contains("love"))
                {
                                        colRed += 216;
                                        colGreen += 20;
                                        colBlue += 20;
                                        colCount++;
                                        finding.add(ball);
                }
                if (tweetText.contains("hate"))
                {
                                        colRed += 129;
                                        colGreen += 160;
                                        colBlue += 162;
                                        colCount++;
                                        finding2.add(ball);
                }
               
                if (tweetText.contains("sad"))
                {
                                        colRed += 84;
                                        colGreen += 151;
                                        colBlue += 180;
                                        colCount++;
                                        finding3.add(ball);
                }
               
                if (tweetText.contains("happy"))
                {
                                        colRed += 229;
                                        colGreen += 212;
                                        colBlue += 16;
                                        colCount++;
                                        finding4.add(ball);
                }

                               if (colCount > 1)
                                {
                                  colRed = colRed / colCount;
                                  colGreen = colGreen / colCount;
                                  colBlue = colBlue / colCount;
                                }
                               
                                ball.setColor(color(colRed, colGreen, colBlue));
               
            }
        }
       
        println("Number of balls: " + finding.size());
    }
    catch (TwitterException te) {
        println("Couldn't connect: " + te);
   
}


}

void setup() {
 size(max_width, max_height);
 background(0);
 noStroke();
 smooth();
 


 reading = new Listen(this,"sample.config.xml");
 frameRate(15);
 loadTwitter();


}

void draw() {
  background(0);
  for (int m = 0; m < finding.size(); m++) {
    Particle ball = (Particle) finding.get(m);
    ball.stayInsideCanvas();
    ball.move();
    fill(ball.getColor());
    ellipse(ball.getX()+300, ball.getY()+300, 20, 20); 
    ball.arrive(new PVector(300,300));
  
  
  }
   for (int m = 0; m < finding2.size(); m++) {
    Particle ball = (Particle) finding2.get(m);
    ball.stayInsideCanvas();
    ball.move();
    fill(ball.getColor());
    ellipse(ball.getX()+300, ball.getY()+300, 20, 20); 
      
  }
   for (int m = 0; m < finding3.size(); m++) {
    Particle ball = (Particle) finding3.get(m);
    ball.stayInsideCanvas();
    ball.move();
    fill(ball.getColor());
    ellipse(ball.getX()+300, ball.getY()+300, 20, 20); 
      
  }
     for (int m = 0; m < finding4.size(); m++) {
    Particle ball = (Particle) finding4.get(m);
    ball.stayInsideCanvas();
    ball.move();
    fill(ball.getColor());
    ellipse(ball.getX()+300, ball.getY()+300, 20, 20); 
   
  }
 
}

  
   void listenEvent(Listen _l) {
   int k = -5;
   int minDistance = 3;
   background(0);
   s = _l.readString();//returns the tweet value of "love" "hate" "angry" "sad" etc
   for (int c = 0; c < finding.size(); c++) { 
   if (s.contains("love")){ //if the Listen passed result = word love
   if (finding.contains("love")){
   ball.arrive(new PVector(0,0));
   }
   }
   }
   for (int c = 0; c < finding2.size(); c++) {
   if (s.contains("hate")){
     if (finding.contains("hate")){
     ball.arrive(new PVector(0,0));
     }
   }
   }
   for (int c = 0; c < finding3.size(); c++) {
   if (s.contains("sad")){
     if (finding.contains("sad")){
     ball.arrive(new PVector(300,300));
     }
   }
   }
 }

class Particle {

  PVector loc;
  PVector vel;
  PVector acc;
  float r;
  float maxforce;    // Maximum steering force
  float maxspeed;    // Maximum speed
  float x;
  float y;
  float wander_theta;
  float wander_radius;
 
  color col;
  String tweet;
   
  // bigger = more edgier, hectic
  float max_wander_offset = 0.3;
 // bigger = faster turns
  float max_wander_radius = 3.5;
 

    Particle(PVector l, float _x, float _y) {
    acc = new PVector(0,0);
    vel = new PVector(random(-1,1),random(-1,1));
    loc = l.get();
    r = 2.0;
    x = _x;
    y = _y;
    wander_theta = random(TWO_PI);
    wander_radius = random(max_wander_radius);
  }

  void run(ArrayList particles) {
    update();
    borders();
    move();
    flock(particles);
  }
 
    void move()
 {
   float wander_offset = random(-max_wander_offset, max_wander_offset);
   wander_theta += wander_offset;
  
   x += cos(wander_theta);
   y += sin(wander_theta);
 }
 
 float getX()
 {
   return x;
 }
 
 float getY()
 {
   return y;
 }
  public void stayInsideCanvas()
 {
    x %= width;
    y %= height;
 }
  // We accumulate a new acceleration each time based on three rules
  void flock(ArrayList particles) {
    PVector sep = separate(particles);   // Separation
    PVector ali = align(particles);      // Alignment
    PVector coh = cohesion(particles);   // Cohesion
    // Arbitrarily weight these forces
    sep.mult(1.5);
    ali.mult(1.0);
    coh.mult(1.0);
    // Add the force vectors to acceleration
    acc.add(sep);
    acc.add(ali);
    acc.add(coh);
  }


  // Method to update location
  void update() {
    // Update velocity
    vel.add(acc);
    // Limit speed
    vel.limit(maxspeed);
    loc.add(vel);
    // Reset accelertion to 0 each cycle
    acc.mult(0);
  }

  void seek(PVector target) {
    acc.add(steer(target,false));
  }

  void arrive(PVector target) {
    acc.add(steer(target,true));
  }

  // A method that calculates a steering vector towards a target
  // Takes a second argument, if true, it slows down as it approaches the target
  PVector steer(PVector target, boolean slowdown) {
    //maxspeed = ms;
    //maxforce = mf;
    PVector steer;  // The steering vector
    PVector desired = target.sub(target,loc);  // A vector pointing from the location to the target
    float d = desired.mag(); // Distance from the target is the magnitude of the vector
    // If the distance is greater than 0, calc steering (otherwise return zero vector)
    if (d > 0) {
      // Normalize desired
      desired.normalize();
      // Two options for desired vector magnitude (1 -- based on distance, 2 -- maxspeed)
      if ((slowdown) && (d < 100.0)) desired.mult(maxspeed*(d/100.0)); // This damping is somewhat arbitrary
      else desired.mult(maxspeed);
      // Steering = Desired minus Velocity
      steer = target.sub(desired,vel);
      steer.limit(maxforce);  // Limit to maximum steering force
    }
    else {
      steer = new PVector(0,0);
    }
    return steer;
  }


  // Wraparound
  void borders() {
    if (loc.x < -r) loc.x = width+r;
    if (loc.y < -r) loc.y = height+r;
    if (loc.x > width+r) loc.x = -r;
    if (loc.y > height+r) loc.y = -r;
  }

  // Separation
  // Method checks for nearby boids and steers away
  PVector separate (ArrayList particles) {
    float desiredseparation = 20.0;
    PVector steer = new PVector(0,0,0);
    int count = 0;
    // For every boid in the system, check if it's too close
    for (int i = 0 ; i < particles.size(); i++) {
      Particle other = (Particle) particles.get(i);
      float d = PVector.dist(loc,other.loc);
      // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
      if ((d > 0) && (d < desiredseparation)) {
        // Calculate vector pointing away from neighbor
        PVector diff = PVector.sub(loc,other.loc);
        diff.normalize();
        diff.div(d);        // Weight by distance
        steer.add(diff);
        count++;            // Keep track of how many
      }
    }
    // Average -- divide by how many
    if (count > 0) {
      steer.div((float)count);
    }

    // As long as the vector is greater than 0
    if (steer.mag() > 0) {
      // Implement Reynolds: Steering = Desired - Velocity
      steer.normalize();
      steer.mult(maxspeed);
      steer.sub(vel);
      steer.limit(maxforce);
    }
    return steer;
  }

  // Alignment
  // For every nearby boid in the system, calculate the average velocity
  PVector align (ArrayList particles) {
    float neighbordist = 25.0;
    PVector steer = new PVector(0,0,0);
    int count = 0;
    for (int i = 0 ; i < particles.size(); i++) {
      Particle other = (Particle) particles.get(i);
      float d = PVector.dist(loc,other.loc);
      if ((d > 0) && (d < neighbordist)) {
        steer.add(other.vel);
        count++;
      }
    }
    if (count > 0) {
      steer.div((float)count);
    }

    // As long as the vector is greater than 0
    if (steer.mag() > 0) {
      // Implement Reynolds: Steering = Desired - Velocity
      steer.normalize();
      steer.mult(maxspeed);
      steer.sub(vel);
      steer.limit(maxforce);
    }
    return steer;
  }

  // Cohesion
  // For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
  PVector cohesion (ArrayList particles) {
    float neighbordist = 25.0;
    PVector sum = new PVector(0,0);   // Start with empty vector to accumulate all locations
    int count = 0;
    for (int i = 0 ; i < particles.size(); i++) {
      Particle other = (Particle) particles.get(i);
      float d = loc.dist(other.loc);
      if ((d > 0) && (d < neighbordist)) {
        sum.add(other.loc); // Add location
        count++;
      }
    }
    if (count > 0) {
      sum.div((float)count);
      return steer(sum,false);  // Steer towards the location
    }
    return sum;
  }
 
    color getColor()
 {
    return col;
 }
 
public void setTweet(String text)
 {
    tweet = text;
 }
 
 
   public void setColor(color c)
 {
  col = c;
 }
}