Loading...
Logo
Processing Forum
  • Screen name:
    mattklynch
mattklynch's Profile
8 Posts
8 Responses
0 Followers

Activity Trend

Last 30 days
Show:
Private Message
  • solution to removing intersecting lines? :S
    I chopped out everything necessary.  I'm trying to solve this in 2d and then move up to 3d with it, so im trying to find a solution that will work for either case.  Essentially I'm trying to create a plane out of connected scattered points, and in order to do so in 3d I have found that the easiest way would be to plot all connection lines, and then run something that wont draw any lines that intersect any other lines, so the result is a triangulated landscape.  So i'm not looking for the intersection  point but how to tell lines are intersecting and boolean them out.

    i really didn't understand what was on the wiki page

    nor could I find any existing examples.  any help would be much appreciated.  thanks!


    **i just realized that it will count the end points as intersections and delete them as well.  anyone have any other suggestions?



    4. Attractor[] attractor = new Attractor[7];


    7. //////////////////////////////////////////////////////////////
    8. void setup() {
    9.   size(800, 800);
    10.   smooth(); 
    11.   for (int i = 0; i < attractor.length; i++) {
    12.     attractor[i] = new Attractor( random(width), random(height) );
    13.   }

    15. }

    17. void draw() {
    18.   //background(0); 
    19.   for (int i=0; i < attractor.length; i++) {
    20.       attractor[i].update();
    21.     }

    23. }

    25. //////////////////////////////////////////////////////////////
    26. class Attractor {
    27.   float x,y;
    28.   
    29.   Attractor(float _x, float _y ) {
    30.     x = _x;
    31.     y = _y;
    32.   }
    33.   
    34.   void update() {
    35.       stroke(255,0,0);
    36.       strokeWeight(.025);
    37.       line(x-4, y, x+4, y);
    38.       line(x, y-4, x, y+4);
    39.       
    40.        for (int i = 0; i < attractor.length; i++) {
    41.          
    42.         
    43.          //if (dist(x, y, attractor[i].x, attractor[i].y) < 100 ) { 
    44.              stroke(#ff0000);
    45.           line(x, y, attractor[i].x, attractor[i].y);

    47.         //}
    48.       }
    49.       
    50.   }

    52. }

  • how to draw a line perpendicular to an atan2() created line?
    **update: i ended up just drawing it with vertex and then rotating the entire object

    I'm playing with vectors and direction of vectors and I can't seem to draw a line perpendicular to the line created in my drawVector() area.  I dont want a rectangle because I need to draw a shape later in another code, but first i need to get down how to get a line perpendicular to the atan2() line (which i have set at rotating to the -atan2() because i want it perpendicular to the force)

    or better yet, if in the drawVector() it WAS a rectangle, say

       translate(l.x, l.y);
           rotate(-atan2(v.y,v.x) );  
           rect(0, 0, 55, 10);
           popMatrix(); 

    how do you call out the corners of those rectangles? Say I want a line that comes from the top left corner of the rectangle, how do i define that point?


      thanks!

    2. float G = 5;
    3. boolean showVectors = true;
    4. Attractor[] attractor = new Attractor[5];
    5. Ball[] balls = new Ball[1]; 

    7. //////////////////////////////////////////////////////////////
    8. void setup() {
    9.   size(800, 800);
    10.   smooth(); 
    11.   for (int i = 0; i < attractor.length; i++) {
    12.     attractor[i] = new Attractor( random(width), random(height) );
    13.   }
    14.   for (int i=0; i <balls.length; i++) {
    15.     balls[i] = new Ball(random(width), random(height) );
    16.   }
    17. }

    19. void draw() {
    20.   background(128); 
    21.   for (int i=0; i < attractor.length; i++) {
    22.       attractor[i].update();
    23.     }
    24.   for (int i = 0; i < balls.length; i++) {
    25.       balls[i].update();
    26.     }
    27. }

    29. void keyPressed() {
    30.   saveFrame("ballForce01_####.png"); 
    31. }

    33. void mousePressed() {
    34.   setup();
    35. }

    37. //////////////////////////////////////////////////////////////
    38. class Ball {
    39.   PVector l, v, a; 
    40.   
    41.   // ball constructor
    42.   Ball(float _x, float _y) {
    43.     l = new PVector(_x,_y);
    44.     v = new PVector();
    45.   }

    47.   // ball functions
    48.   void update() {
    49.     a = new PVector(); 
    50.     for (int i = 0; i < attractor.length; i++) {
    51.       a.add(attractor[i].getAccel(l.x,l.y));
    52.     }
    53.     
    54.     v.add(a);
    55.     l.add(v); 
    56.     render();
    57.   }

    59.   void render() {
    60.     stroke(0);
    61.     strokeWeight(1);
    62.    
    63.     if (showVectors) {
    64.       drawVector();
    65.     }
    66.   }
    67.   
    68.   void drawVector() {

    70.     
    71.      pushMatrix();
    72.        // transform to the velocity vector
    73.        translate(l.x, l.y);
    74.        rotate(-atan2(v.y,v.x) );  
    75.        line(0,0,25,0);
    76.        popMatrix(); 
    77.          

    79.   }
    80. }


    83. //////////////////////////////////////////////////////////////
    84. class Attractor {
    85.   float x,y;
    86.   
    87.   Attractor(float _x, float _y ) {
    88.     x = _x;
    89.     y = _y;
    90.   }
    91.   void update() {
    92.       stroke(255,0,0);
    93.       strokeWeight(1);
    94.       line(x-4, y, x+4, y);
    95.       line(x, y-4, x, y+4);
    96.   }

    98.   PVector getAccel(float px, float py) {
    99.       PVector a = new PVector(0,0,0); 
    100.       float d2 = sq(dist(px,py,x,y));
    101.       if (d2 > 10) {
    102.         a.x = G * (x-px) / d2;
    103.         a.y = G * (y-py) / d2;
    104.       }
    105.       return a; 
    106.    }
    107. }

  • how to export oop objects in dxf?
    I'm running into a problem with exporting multiple objects in one code with a key stroke activated export.  The issue is if I put the record strings in the drawBall() string it will only give me one object, however it yeilds nothing with placed up where the oop instantiation  is, but the other point and image exporters work still.  does anyone have any advice?
    *note: code is a little sloppy looking because i have been cutting and pasting stuff around to get it to work
    1. import peasy.*;
    2. import processing.dxf.*;

    4. boolean record;

    6. PeasyCam cam;

    8. float [] xpos = new float[800];
    9. float [] ypos = new float [800];
    10. float [] zpos = new float [800];
    11. Ball[] ballies = new Ball[5];
    12. attractor[] attractor = new attractor[5];

    14. int counter; 


    17. PrintWriter OUTPUT;   

    19. // setup

    21. void keyPressed(){
    22.   if (key == 'r') record = true;
    23.   switch(key){
    24.     case 'i':
    25.     saveFrame("image"+counter+".jpg");
    26.     break;
    27.     case 'b':
    28.     exportBallPoints2Text();
    29.     break;
    30.     case 'a':
    31.     exportAttractorPoints2Text();
    32.     break;
    33.   }
    34.   counter++;
    35. }



    39. void exportBallPoints2Text(){
    40.   OUTPUT = createWriter("Balls"+counter+".txt");
    41.   for (int i=0; i<ballies.length; i++) {
    42.     OUTPUT.println(ballies[i].p.x + "," +  ballies[i].p.y + "," + ballies[i].p.z); 
    43.   }
    44.    counter++;
    45.   OUTPUT.flush();
    46.   OUTPUT.close();
    47.   println("complete success (balls) !");
    48. }

    50. void exportAttractorPoints2Text(){
    51.   OUTPUT = createWriter("attractor"+counter+".txt");
    52.   for (int p=0; p<attractor.length; p++) {
    53.     OUTPUT.println(attractor[p].x + "," +  attractor[p].y + "," + attractor[p].z); 
    54.   }
    55.    counter++;
    56.   OUTPUT.flush();
    57.   OUTPUT.close();
    58.   println("complete success (attractor) !");
    59.  
    60. }




    65. void setup() {
    66.   size(800, 800, P3D);

    68.   cam = new PeasyCam(this, 100);
    69.   cam.setMinimumDistance(100);
    70.   cam.setMaximumDistance(200);




    75.     
    76.     
    77.  if (record) {
    78.     beginRaw(DXF, "output.dxf");
    79.   }

    81.   for (int i=0; i<ballies.length; i++) {
    82.     ballies[i] = new Ball(
    83.     400, 400, random(-10,10), random(-10,10),random(-10,10), 25);
    84.   }
    85.   
    86.         if (record) {
    87.     endRaw();
    88.     record = false;
    89.   }

    91.     for (int p=0; p < attractor.length; p++) {
    92.     attractor[p] = new attractor( width/8 + random(width), height/8 + random(height),  random(50));
    93.     smooth();
    94.   }
    95. }

    97. //........................................................



    101. //........................................................

    103. void draw() {
    104.   background(0);
    105.   stroke(250,250,250);
    106.   strokeWeight(2);
    107.   point(xpos[0], ypos[0], zpos[0]);


    110.   
    111.   
    112.   for (int g = 1; g <800; g++) {
    113.     point(xpos[g], ypos[g], zpos[g]);
    114.   }

    116.   for (int h = 0; h < 100; h++) {//draw x axis
    117.     stroke(255,h*5,0);
    118.     point(h,0,0);
    119.   }

    121.   for (int h = 0; h < 100; h++) {// draw y axis
    122.     stroke(h*5,255,0);
    123.     point(0,h,0);
    124.   }

    126.   for (int h = 0; h < 100; h++) {// draw z axis
    127.     strokeWeight(3);
    128.     stroke(0,255,h*5);
    129.     point(0,0,h);
    130.   }

    132.   for (int i=0; i<ballies.length; i++) { 
    133.     ballies[i].update();
    134.   }
    135.  for (int p=0; p < attractor.length; p++) {
    136.     attractor[p].update();
    137.   }
    138. }

    140. //........................................................ 

    142. class Ball {
    143.   // ball fields
    144.   float x;
    145.   float y;
    146.   float z;
    147.   float speedX;
    148.   float speedY;
    149.   float speedZ;
    150.   float angA;
    151.   float angV = 0;
    152.   boolean dead = false; 
    153.   PVector a; 
    154.   PVector v, p, standardV, offsetV; 


    157.   // ball constructor



    161.   Ball(float _x, float _y, float _z, float _speedX, float _speedY, float _speedZ) {
    162.     p = new PVector(_x, _y, _z);
    163.     v = new PVector(_speedX, _speedY, speedZ);
    164.     standardV = new PVector(_speedX, _speedY, speedZ);
    165.   }


    168.   // ball methods
    169. /*
    170.   void update() {
    171.     position();
    172.     checkCollisions();
    173.     drawBall();
    174.   }
    175.   */
    176.   ///////////////////////////////    
    177.   void update() {
    178.  
    179.     if (!dead) {

    181.       a = new PVector(); 
    182.       for (int i = 0; i < attractor.length; i++) {
    183.           a.add(attractor[i].getAccel(p.x,p.y,p.z));
    184.       }
    185.       
    186.       angA = a.heading2D();
    187.       angV +=  angA/.25;
    188.       v = new PVector( standardV.x, standardV.y, standardV.z); 
    189.       a.normalize();
    190.       a.mult(v.mag());
    191.       a.mult(0.5);
    192.       v.add(a);
    193.      //checkCollisions(); 
    194.       p.add(v);
    195.       angV  *= .9;
    196.     }
    197.     drawBall();
    198.   }


    201.   /////////////////////////////////////      

    203.  void drawBall() {
    204.      
    205.      
    206.   pushMatrix();
    207.     translate( p.x, p.y, p.z);
    208.     
    209. //front    
    210. beginShape(); 
    211. vertex(p.x+25,p.y,p.z+50);
    212. vertex(p.x+25,p.y,p.z);
    213. vertex(p.x+35,p.y,p.z);
    214. vertex(p.x+35,p.y,p.z+65);
    215. vertex(p.x-35,p.y,p.z+65);
    216. vertex(p.x-35,p.y,p.z);
    217. vertex(p.x-25,p.y,p.z);
    218. vertex(p.x-25,p.y,p.z+50);
    219. endShape(CLOSE);

    221. /*
    222. beginShape(); 
    223. vertex(p.x-35,p.y,p.z+65);
    224. vertex(p.x-35,p.y-random(2,10),p.z+65);
    225. vertex(p.x-35,p.y-random(2,10),p.z);
    226. vertex(p.x-35,p.y,p.z);
    227. endShape(CLOSE);
    228. */
    229.     //sphere(5);
    230.     popMatrix();
    231.     

    233.     
    234. }



    238. /*
    239.   void checkCollisions() {
    240.     if(p.x +  v.x > width || p.x + v.x < 0) {
    241.       v.x *= -1;
    242.       standardV.x *= -1; 
    243.     }
    244.     if(p.y + v.y > height || p.y + v.y < 0) {
    245.       v.y *= -1;
    246.     }
    247.     if(p.y + v.y > height || p.y + v.y < 0) {
    248.       v.y *= -1;
    249.     }
    250.   }
    251.   
    252.  */


    255. }



    259. /////////////////////////////////////////////////////

    261. class attractor {
    262.   float x,y,z;

    264.   attractor(float _x, float _y, float _z ) {
    265.     x = _x;
    266.     y = _y;
    267.     z = _z;
    268.   }


    271.   void update() {
    272.     render();
    273.   }
    274.   void render() {
    275.     stroke(255,0,0);
    276.     pushMatrix();
    277.     translate(x,y,z);
    278.     box(5);
    279.     popMatrix();
    280.   }


    283.   PVector getAccel(float px, float py, float pz) {
    284.     PVector a = new PVector(0,0,0); 
    285.     float d2 = sq(dist(px,py,pz,x,y,z));
    286.     if (d2 > 10) {
    287.       a.x = G * (x-px) / d2;
    288.       a.y = G * (y-py) / d2;
    289.       a.z = G * (z-pz) / d2;
    290.     }
    291.     return a;
    292.   }
    293.   
    294. }

  • can objects orbit attractors in 3D?
    I have been looking at a lot of gravity fields and attractors, but I have yet to see them move in the x,y, and z axis. 

    http://www.openprocessing.org/visuals/?visualID=9151 : this does an awesome job in 2d with 3d representation, and what im looking to do is something similar, but the planets will move in the z direction as well as having fields / attractors scattered about the z axis.

     attached is the code I personally have been working with and creating. My major problem is not knowing how to classify the vectors in 3D, i guess.  I have the attractors scattered in 3D, but the balls keep coming in on 0,0,0 for some reason, and I cannot get any movement to them.

    I have been struggling with this for a few days and so far have gotten nowhere.  if anyone more knowledgeable than me help I will be more than thankful

    import peasy.*;

    PeasyCam cam;

    float [] xpos = new float[800];
    float [] ypos = new float [800];
    float [] zpos = new float [800];
    Ball[] ballies = new Ball[2];
    attractor[] attractor = new attractor[25];


    void setup() {
     size(800, 800, P3D);

     smooth(); 

     cam = new PeasyCam(this, 100);
     cam.setMinimumDistance(100);
     cam.setMaximumDistance(200);
     
       for (int i=0; i<ballies.length; i++) {
        ballies[i] = new Ball(random(width), random(height), random(10), random(20),random(80,2),random(90,2),50);
      }
      
      for (int p=0; p < attractor.length; p++) {
        attractor[p] = new attractor( width/8 + random(width), height/8 + random(height),   random(300));
        smooth();
      }
    }

    void draw() {
     background(0);
     stroke(250,250,250);
     strokeWeight(2);
     point(xpos[0], ypos[0], zpos[0]);

     for (int g = 1; g <800; g++){
       point(xpos[g], ypos[g], zpos[g]);
     }

     for (int h = 0; h < 100; h++){//draw x axis
       stroke(255,h*5,0);
       point(h,0,0);
     }

     for (int h = 0; h < 100; h++){// draw y axis
       stroke(h*5,255,0);
       point(0,h,0);
     }

     for (int h = 0; h < 100; h++){// draw z axis
       strokeWeight(3);
       stroke(0,255,h*5);
       point(0,0,h); 
     }
     
       for (int p=0; p < attractor.length; p++) {
        attractor[p].update();
      }
      
       for (int i=0; i<ballies.length; i++) { 
        ballies[i].update();
      }
      
    }

    class Ball {
      // ball fields
      float x;
      float y;
      float z;
      float speedX;
      float speedY;
      float speedZ;
      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 _z, float _speedX, float _speedY, float _speedZ, int _normSize) {
        p = new PVector(_x, _y, _z);
        v = new PVector(_speedX, _speedY, _speedZ);
        standardV = new PVector(_speedX, _speedY, _speedZ);
        normSize  = _normSize;
      }

      void update() {
     
        if (!dead) {

          a = new PVector(); 
          for (int i = 0; i < attractor.length; i++) {
              a.add(attractor[i].getAccel(p.x,p.y,p.z));
            }
        
          //angA = a.heading2D();
          angV +=  angA/.25;
          v = new PVector( standardV.x, standardV.y, standardV.z); 
          a.normalize();
          a.mult(v.mag());
          a.mult(0.9);
          v.add(a);
          checkCollisions(); 
          p.add(v);
          angV  *= 12;
        }
       drawBall();
      }
      
        void drawBall() {
        pushMatrix();
        translate(x,y,z);
        sphere(1);
        popMatrix();
    }

      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;
        }
         if(p.z + v.z > height || p.z + v.z < 0) {
          v.z *= -1;
        }
      }
    }

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

    class attractor {
      float x,y,z;

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


      void update() {
        render();

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

  • can you help me move this sphere around 3d space?
    So i took a code i had written for a 2D space, and used a peasy cam, and have since brought it to the 3d environment.  The only problem is i cannot get the ball to move around the space towards the attractors.  any help?


    import peasy.*;

    PeasyCam cam;

    float [] xpos = new float[7000];
    float [] ypos = new float [7000];
    float [] zpos = new float [7000];
    Ball[] ballies = new Ball[2];
    attractor[] attractor = new attractor[25];


    void setup() {
     size(800, 800, P3D);

     smooth(); 

      cam = new PeasyCam(this, 100);
     cam.setMinimumDistance(100);
     cam.setMaximumDistance(200);
     
       for (int i=0; i<ballies.length; i++) {
        ballies[i] = new Ball(random(width), random(height), random(300), random(0,2),random(0,2),25,50);
      }
      
      for (int p=0; p < attractor.length; p++) {
        attractor[p] = new attractor( width/8 + random(width), height/8 + random(height),   random(300));
        smooth();
      }
    }

    void draw() {
     background(0);
     stroke(250,250,250);
     strokeWeight(2);
     point(xpos[0], ypos[0], zpos[0]);

     for (int g = 1; g <5000; g++){
       point(xpos[g], ypos[g], zpos[g]);
     }

     for (int h = 0; h < 100; h++){//draw x axis
       stroke(255,h*5,0);
       point(h,0,0);
     }

     for (int h = 0; h < 100; h++){// draw y axis
       stroke(h*5,255,0);
       point(0,h,0);
     }

     for (int h = 0; h < 100; h++){// draw z axis
       strokeWeight(3);
       stroke(0,255,h*5);
       point(0,0,h); 
     }
     
       for (int p=0; p < attractor.length; p++) {
        attractor[p].update();
      }
      
       for (int i=0; i<ballies.length; i++) { 
        ballies[i].update();
      }
      
    }

    class Ball {
      // ball fields
      float x;
      float y;
      float z;
      float speedX;
      float speedY;
      float speedZ;
      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 _z, float _speedX, float _speedY,float _speedZ, int _normSize) {
        p = new PVector(_x, _y, _z);
        v = new PVector(_speedX, _speedY, _speedZ);
        standardV = new PVector(_speedX, _speedY, _speedZ);
        normSize  = _normSize;
      }

      void update() {
     
        if (!dead) {

          a = new PVector(); 
          for (int i = 0; i < attractor.length; i++) {
              a.add(attractor[i].getAccel(p.x,p.y,p.z));
            }
        
          angA = a.heading2D();
          angV +=  angA/.25;
          v = new PVector( standardV.x, standardV.y, standardV.z); 
          a.normalize();
          a.mult(v.mag());
          a.mult(0.9);
          v.add(a);
          checkCollisions(); 
          p.add(v);
          angV  *= .9;
        }
       drawBall();
      }
      
        void drawBall() {
        pushMatrix();
        translate(x,y,z);
        sphere(2);
        popMatrix();
    }

      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;
        }
         if(p.z + v.z > height || p.z + v.z < 0) {
          v.z *= -1;
        }
      }
    }

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

    class attractor {
      float x,y,z;

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


      void update() {
        render();

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

  • exporting points to txt file. Says it's exporting but really isn't.
    Hey all.  Thanks a lot with my last question, I ended up getting that to work.  A
    nyway, have a new one now.  I'm working on splicing a code to export points into the existing code i am working on, and it runs, and it looks right, and it tells me the points have been exported... but in the file folder for the code is a zero kb "exportedpoints.txt"

    anyone offer any help?


    Code:

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


    //........................................................
    ArrayList pointList;     // arraylist to store the points in
    PrintWriter OUTPUT;       // an instantiation of the JAVA PrintWriter object.
                              // This variable reappears in our custom export function 
    //........................................................

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


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

    //........................................................
      pointList = new ArrayList();    // instantiate an ArrayList
    //........................................................

      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();
      }
      //........................................................
         for(int i = 0; i < pointList.size(); ++i){        
        PVector V = (PVector) pointList.get(i);
        ellipse(V.x,V.y, 8.0, 8.0);
      }
    //........................................................ x
    }

     
      
      
    void mousePressed() {
      setup();
    }

    //........................................................
    void keyPressed(){
      switch(key){
        case 's':
        saveFrame("importedPoints.jpg");
        break;
        case 'x':
        exportPoints2Text();
        break;
      }
    }


    void exportPoints2Text(){
      OUTPUT = createWriter("exportedPoints.txt");
      for(int i = 0; i < pointList.size(); ++i){        
        PVector V = (PVector) pointList.get(i);
        OUTPUT.println(V.x + "" + V.y + "," + V.z);  // here we export the coordinates of the vector using String concatenation!
      }
      OUTPUT.flush();
      OUTPUT.close();
      println("points have been exported");
    }
    //........................................................

    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, 2.5);
              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(.05);
        //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;
      }
    }

  • have lines follow boids? (its an easy question... i just cant get the answer!)
    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);
      }
       

    }