have lines follow boids? (its an easy question... i just cant get the answer!)

Programming Questions

mattklynch

have lines follow boids? (its an easy question... i just cant get the answer!)

in Programming Questions • 2 years ago

i hav ebeen playing around with the original flocking script and am trying to get the fill of the boids to leave a trail behind them. any help?

THANKS

Flock flock;

void setup() {

  size(640, 360);

  flock = new Flock();

  // Add an initial set of boids into the system

  for (int i = 0; i < 250; i++) {

   flock.addBoid(new Boid(new PVector(width/2,height/2), 3.0, 0.05));

  }

  smooth();

}

void draw() {

  background(255);

  flock.run();

}

// Add a new boid into the System

void mousePressed() {

  flock.addBoid(new Boid(new PVector(mouseX,mouseY),23.0f,0.05f));

}

// The Boid class

class Boid {

  PVector loc;

  PVector vel;

  PVector acc;



  float r;

  float maxforce; // Maximum steering force

  float maxspeed; // Maximum speed

   Boid(PVector l, float ms, float mf) {

   acc = new PVector(0,0);

   vel = new PVector(random(-.5,.5),random(-.5,.5));

   loc = l.get();

   r = 4;

   maxspeed = ms;

   maxforce = mf;

  }

  void run(ArrayList boids) {

   flock(boids);

   update();

   borders();

   render();

  }

  // We accumulate a new acceleration each time based on three rules

  void flock(ArrayList boids) {

   PVector sep = separate(boids); // Separation

   PVector ali = align(boids); // Alignment

   PVector coh = cohesion(boids); // 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) {

   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;

  }

  void render() {

   // Draw a triangle rotated in the direction of velocity

   float theta = vel.heading2D() + PI/2;

   fill(100,100,100,100);

   //stroke(1); //255

   //strokeWeight(1);

   pushMatrix();

   translate(loc.x,loc.y);

   rotate(theta);

   ellipse(0, 0, .5, .5);

   // point (loc.x,loc.y);

   popMatrix();

  }

  // 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 boids) {

   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 < boids.size(); i++) {

   Boid other = (Boid) boids.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 boids) {

   float neighbordist = 25.0;

   PVector steer = new PVector(0,0,0);

   int count = 0;

   for (int i = 0 ; i < boids.size(); i++) {

   Boid other = (Boid) boids.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 boids) {

   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 < boids.size(); i++) {

   Boid other = (Boid) boids.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;

  }

}

// The Flock (a list of Boid objects)

class Flock {

  ArrayList boids; // An arraylist for all the boids

  Flock() {

   boids = new ArrayList(); // Initialize the arraylist

  }

  void run() {

   for (int i = 0; i < boids.size(); i++) {

   Boid b = (Boid) boids.get(i);

   b.run(boids); // Passing the entire list of boids to each boid individually

   }

  }

  void addBoid(Boid b) {

   boids.add(b);

  }



}

Replies(5)

PhiLho

Re: have lines follow boids? (its an easy question... i just cant get the answer!)

2 years ago

What kind of lines? Perpendicular, in the direction of move? What length?
I don't see a line() call in the code you show (just the original one?), so we can't say what is wrong with your attempts.

mattklynch

Re: have lines follow boids? (its an easy question... i just cant get the answer!)

2 years ago

yeah, i really didnt fully explain myself. I am trying to get the residual path of the boids to show, but can't figure out how to get that to happen.

an example would be like this that I wrote:

http://mysite.pratt.edu/~mlynch4/processing/FINAL_/applet/

as the ellipses approach the attractors they are calling every position they have been in. Do I need to call out the location in the void update() section?

here is the code if that link doesnt work

Ball[] ballies = new Ball[75];
attractor[] attractor = new attractor[25];



// setup
//........................................................


void setup() {
  size(800, 800);
  background(255);



  for (int i=0; i<ballies.length; i++) {
    ballies[i] = new Ball(
    random(width), random(height), random(0,2),random(0,0),25);
  }
  for (int p=0; p < attractor.length; p++) {
    attractor[p] = new attractor( width/8 + random(width), height/8 + random(height)  );
    smooth();
  }
}

void mousePressed() {
  setup();
}


//........................................................

void draw() {

  for (int i=0; i<ballies.length; i++) { 
    ballies[i].update();
  }


  for (int p=0; p < attractor.length; p++) {
    attractor[p].update();
  }
}

//........................................................ 

class Ball {
  // ball fields
  float x;
  float y;
  float speedX;
  float speedY;
  int normSize;
  float angA;
  float angV = 0;
  boolean dead = false; 
  PVector a; 
  PVector v, p, standardV, offsetV; 


  // ball constructor



  Ball(float _x, float _y, float _speedX, float _speedY, int _normSize) {
    p = new PVector(_x, _y);
    v = new PVector(_speedX, _speedY);
    standardV = new PVector(_speedX, _speedY);
    normSize  = _normSize;
  }


  // ball methods
/*
  void update() {
    position();
    checkCollisions();
    drawBall();
  }
  */
  ///////////////////////////////    
  void update() {
 
    if (!dead) {

      a = new PVector(); 
      for (int i = 0; i < attractor.length; i++) {
        if (dist(p.x, p.y, attractor[i].x, attractor[i].y) < 200) { 
          stroke(#ff0000, 1);
          line(p.x, p.y, attractor[i].x, attractor[i].y);
          a.add(attractor[i].getAccel(p.x,p.y));
        }
      }
      angA = a.heading2D();
      angV +=  angA/.25;
      // render();
      v = new PVector( standardV.x, standardV.y); 
      a.normalize();
      a.mult(v.mag());
      a.mult(0.9);
      v.add(a);
      checkCollisions(); 
      p.add(v);
      angV  *= .9;
    }
    drawBall();
  }


  /////////////////////////////////////      



  void drawBall() {
    stroke(0);
    strokeWeight(1);
    //ellipse(p.x, p.y, 25, 25);
    point  (p.x, p.y);
}

  void checkCollisions() {
    if(p.x +  v.x > width || p.x + v.x < 0) {
      v.x *= -1;
      standardV.x *= -1; 
    }
    if(p.y + v.y > height || p.y + v.y < 0) {
      v.y *= -1;
    }
  }
}

////////////////////////////////////////////////////////////////////


class attractor {
  float x,y;

  attractor(float _x, float _y ) {
    x = _x;
    y = _y;
  }

  void update() {
    render();
  }
  void render() {
    stroke(255,0,0);
  }
  PVector getAccel(float px, float py) {
    PVector a = new PVector(0,0,0); 
    float d2 = sq(dist(px,py,x,y));
    if (d2 > 10) {
      a.x = G * (x-px) / d2;
      a.y = G * (y-py) / d2;
    }
    return a;
  }
}

epatterns

Re: have lines follow boids? (its an easy question... i just cant get the answer!)

2 years ago

a general concept could be smthn like this:

create an array in your Boid class that would hold each trail vertex position. ( the bigger the array the longer the trail )
as the boid travels it will store its position coordinates into this array.
each loop you then update the current position and shit the other values.

like (pls note that this is more to illustrate the concept and may not work)

PVector[] position = new PVector[num_trails];
void updatePosition() {
    for( int i=num_trails-1; i>0; i-- ){
      position[i].set( position[i-1] );
    }
    position[0].add(vel);
}

then render your trails with a LINE_STRIP like

```
beginShape(LINE_STRIP);
```
```
for (int i=0 ; i<num_trails ; i++) {
```
vertex( position[i].x, position[i].y );
}
```
endShape();
```

hope that helped

mattklynch

Re: have lines follow boids? (its an easy question... i just cant get the answer!)

2 years ago

I'll try that momentarily. I know in the other code i posted it's as easy as just changing the stroke weight for the ball class, is there not something as simple in the boid class?

*update*

couldn't get that to work. rats.

mattklynch

Re: have lines follow boids? (its an easy question... i just cant get the answer!)

2 years ago

**bump. anyone else?

Top Reply