ArrayList<Mover> movers;

void setup() {
  size(640, 360);
  movers = new ArrayList<Mover>();
  for (int i = 0; i < 4; i++) {
    movers.add(new Mover());
  }
}

void draw() {
  background(255);

  for (int i = 0; i < movers.size(); i++) {
    Mover m = movers.get(i);
    float alpha = i*85;

    m.follow(movers);
    m.update();
    m.display(alpha);
    m.boundary();
  }
}

class Mover {
  PVector location;
  PVector velocity;
  PVector acceleration;
  float mass;
  float radius;
  float maxspeed;
  float maxforce;
  float damping;

  Mover() {
    location = new PVector(random(width), random(height));
    velocity = new PVector();
    acceleration = new PVector();
    radius = 20;
    maxspeed = 2;
    maxforce = 0.3;
    damping = 0.98;
  }

  void follow(ArrayList<Mover> movers) {
    for (int i = 0; i < movers.size()-1; i++) {
      Mover other = movers.get(i+1);
      PVector neighbour = PVector.sub(other.location, location);
      neighbour.setMag(maxspeed);
      PVector steer = PVector.sub(neighbour, velocity);
      steer.limit(maxforce);
      applyForce(steer);
    }
  }
  void applyForce(PVector force) {
    force.copy();
    acceleration.add(force);
  }

  void update() {
    velocity.add(acceleration);
    velocity.limit(maxspeed);
    velocity.mult(damping);
    location.add(velocity);
    acceleration.mult(0);
  }

  void display(float alpha) {
    fill(alpha);
    stroke(0);
    strokeWeight(1);
    ellipse(location.x, location.y, radius, radius);
  }

  void boundary() {
    if (location.x < 0) { 
      location.x = width;
    }
    if (location.x > width) { 
      location.x = 0;
    }  
    if (location.y < 0) { 
      location.y = height;
    }
    if (location.y > height) { 
      location.y = 0;
    }
  }
}

I've recently found this article from Zachary Lieberman where he provides some insights on his work. I'm particularly interested in his "recipe" to make a blob moving "organically" (almost like a fluid).

This is a 2-step process:

• connect particles with springs (and connect the last particle to the first particle, making a loop)
• give the particles a repulsion force from each other that is proportional to distance (stronger force when closer) and has a maximum radius for interaction (i.e., if particles are beyond this distance, they don’t have an impact on each other)

I made both a particle and a spring class but got lost when trying to implement the repulsion force. What should I change (add ?) in the following snippet (a spring class using basic Hooke's law) to "give the particles a repulsion force from each other that is proportional to distance" ?

spring class

class Spring(object):

def __init__(self, x, y, l):
    self.startpoint = PVector(x, y)
    self.constant = .2
    self.lngth = l
    self.g = 10
    self.mass = 4

def connect(self, p):    # p refers to the particle_class
    force = PVector.sub(p.location, self.startpoint)
    distance = force.mag()
    stretch = distance - self.lngth

    force.normalize()
    force *= -1 * self.constant * stretch   # Hooke's law
    force.limit(.4) 
    p.applyForce(force) 


def displayLine(self, p):  
    stroke(255)
    strokeWeight(1)
    line(p.location.x, p.location.y, self.startpoint.x, self.startpoint.y) 

On a side note, I'm also curious to know how to display particles following a splatter shape (GIF above).

here is the code:

void draw() {
  background(0);
  for (Particle p : particles) {
    p.update();
  }
}

class Particle {

  PVector position, velocity;

  void update() {
    PVector mouse = new PVector(map(mouseX, 0, width, -width / 2, width / 2), map(mouseY, 0, height, -height / 2, height / 2), 0);
    PVector acc = PVector.sub(mouse, position);


    acc.limit(FULL_ACC);
    velocity.add(acc);
    velocity.limit(FULL_VEL);
    position.add(velocity);
  }

  void oscEvent(OscMessage theOscMessage) {
    if (theOscMessage.checkAddrPattern("/output_1")==true) {
      update(); //problem is here, what is the proper way in order for the OSC to pick up this info? 
      println("mouseMoved");
    } else if (theOscMessage.checkAddrPattern("/output_2")==true) {
      update();
      println("mouseMoved");
    } else if (theOscMessage.checkAddrPattern("/output_3") == true) {
      update();
      println("mouseMoved");
    } else {
      println("Unknown OSC message received");
    }
  }
}

ellipse(280,165,28,28); //Left Eye
ellipse(310,165,28,28); //Right Eye
fill(0);
ellipse(278,162,3,3);   //Left Pupil
ellipse(315,167,3,3);   //Right Pupil

how would I limit movement to within the eyes?

void separate (Sphere[]planets) {
    float desiredDist = radius*6;
    PVector sum = new PVector();
    int count = 0;
    if (planets != null) {
      if (level > 0 ) {
        for (int i = 0; i <planets.length; i++) {
          int j=1;
          for (j+=i; j<planets.length; j++) {
            float d = PVector.dist(planets[i].location, planets[j].location);
            if ((d >0) && (d<desiredDist)) {
              PVector diff = PVector.sub(planets[i].location, planets[j].location);
              diff.normalize();
              diff.div(d);
              sum.add(diff);
              count++;
            }

            if (count > 0) {
              sum.div((float)count);
            }
            if (sum.mag() > 0) {
              sum.setMag(maxSpeed);
              PVector steer = PVector.sub(sum, velocity);
              steer.limit(maxForce);
              applyForce(steer);
            }
          }
        }
      }
    }
  }

void update() {
target.sub(location);
target.normalize();
target.mult (.1);

velocity.add(acceleration);
velocity.limit(20);
location.add(velocity);

}

target is a PVector that contains a random x/y the velocity add and the location add get the circle moving but I cannot get it to move to the target :( Help thanks

    Pacman pacman = new Pacman(75); 

   void setup() {
  size(500, 500); //set the size of the page to 500pixels by 500pixels
  ellipseMode(CENTER); //set ellipse mode to center
  }

  void draw() {

  background(0); //set background to black
  pacman.update(); //use the function update() as written in class Pacman                               
  pacman.transmit(); //use the function transmit() as written in class Pacman 
  pacman.drawTrail(); //use the function drawTrail() as written in class Pacman
  pacman.collideTrail(); //use the function collideTrail() as written in class Pacman
  pacman.checkEdges();
  pacman.draw(); //use the function draw() as written in class Pacman
  }

  class Pacman {

  PVector location; 
  PVector velocity;                                                     
  PVector acceleration;                                                    
  PVector target; 
  float topspeed; 
  float tolerance = 15;      
  float direction = 0;

  float diameter; //declare diameter as float
  float MouthAngle = 0; //set MouthAngle to 0 (starting position closed)
  float OpeningAngle = PI * 2 / 180; 
  boolean MouthMovement = true; //set variable for MouthMovement
  ArrayList trail; // declare the use of trail as an Arraylist
  boolean MousePressed = false;


  Pacman(float dia) {

    diameter = dia;  
    trail = new ArrayList(); // assign trail as a function to create a new Arraylist
    location = new PVector(250,250);            
    velocity = new PVector(0, 0); 
    target = new PVector(width/2, height/2);                              
    topspeed = 3; //top speed is assigned a value of 3
  }

  void update() {


    PVector dir = PVector.sub(target, location);
    float distance = dist(location.x, location.y, target.x, target.y); 



    if (topspeed > tolerance) {                                           
      topspeed *= 0.9;
    } else {
      topspeed = distance*0.05;
    }

    dir.normalize(); //normalize
    direction = dir.mag(); 
    acceleration = dir; // acceleration = direction                                               
    velocity.add(acceleration); 
    velocity.limit(topspeed);   //limit velocity to topspeed


    if (distance<tolerance) { 
      target.x = random(width -100, width +100); 
      target.y = random(height -100, height +100);
    } else { //if the target hasn't been reached 
      location.add(velocity); //continue to move as normal

      if (mousePressed) {
        target.x = mouseX;
        target.y = mouseY;
      }
    }
  }

  void draw() {

    float dX = location.x - target.x; 
    float dY = location.y - target.y; 


    float angle = radians((atan2(dY, dX) * 180 / PI));


    if (dist(target.x, target.y, location.x, location.y) > 0) {
      cherries();

      pushMatrix();
      translate(location.x, location.y);
      rotate(angle);
      if (MouthMovement == true) MouthAngle += OpeningAngle; 
      else MouthAngle -= OpeningAngle; 
      if (MouthAngle > TWO_PI / 8 || MouthAngle < 0) MouthMovement = ! MouthMovement;
      stroke(0);
      fill(255, 255, 0); // set fill to yellow
      arc(0, 0, diameter, diameter, HALF_PI*-2 + MouthAngle, HALF_PI*2 -MouthAngle); 
      fill (0); //set fill to black
      ellipse(0, 0 - diameter / 4, diameter/8, diameter/8);
      popMatrix();
    }
  }

  void checkEdges() {
    if (location.x  > width -diameter/2 || location.x  <0 +diameter/2 ) { 
      velocity.x *= -2; //its velocity is multiplied by -0.1
      target.x = random(width); 
      target.y = random(height);
    } 
    if (location.y +diameter/2> height || location.y  <0 +diameter/2 ) { 
      velocity.y *= -2; //its velocity is multiplied by -0.1
      target.x = random(width); 
      target.y = random(height);
    }
  }

  void transmit() {


    for (int i=0; i<trail.size (); i++) { 
      if (trail.size() != 0) { 
        crumbs t = (crumbs) trail.get(i); 
        t.draw();
      }
    }
  }
  void drawTrail() {


    trail.add(new crumbs(new PVector(location.x, location.y), 10));
  }

  void collideTrail() {

    PVector crumbPos; 
    for (int i=0; i<trail.size (); i++) {
      crumbs drop = (crumbs) trail.get(i);
      crumbPos = drop.loc;
      float d = location.dist(crumbPos); 
      if (d < diameter/2) { //if Pacman is touching the crumbs                                
        trail.remove(i);
        // target.x = random(width); 
        //  target.y = random(height); 
        //velocity.x *= -2;
        //velocity.y *= -2;
      }
    }
  }


  void cherries() {
    stroke(0, 255, 0); //set stroke to green
    line (target.x -5, target.y+1, target.x-2.5, target.y-25); //draw line
    line (target.x +5, target.y-1, target.x-2.5, target.y-25); //draw line

    stroke(0);
    fill(255, 0, 0); //set fill to red
    ellipse(target.x-5, target.y-1, 15, 15); //draw ellipse 
    ellipse(target.x+5, target.y+1, 15, 15); //draw ellipse
   }
  }

   class crumbs { 

  PVector loc; //declare loc as a PVector 
  float diameter; //declare diameter as a float 



  crumbs(PVector loc_, float dia) {
    loc = loc_; 
    diameter=dia;
  }

  void draw () { 
    fill (255, 255, 0); 
    noStroke(); 

    ellipse(loc.x, loc.y, diameter, diameter);
    }
  }

PVector location = new PVector (400,400);
PVector velocity = new PVector (0,0);
PVector acceleration = new PVector (0,0);
PVector mouse = new PVector (0,0);
float accelerationMax = 0.5;
int speedMax = 5;
int a = 40;
int b = 80;

void setup() {
size (800,800);
noCursor();
}
void draw() {
background (40);
fill(255,0,0);
ellipse(mouseX,mouseY,10,10);
line(mouseX,mouseY-15,mouseX,mouseY+15);
line(mouseX+15,mouseY,mouseX-15,mouseY);
mouse.set(mouseX, mouseY);
acceleration = PVector.sub(mouse,location);
acceleration.limit(accelerationMax);
location.add(velocity);
velocity.limit(speedMax);
velocity.add(acceleration);
if (mousePressed) {
accelerationMax = 0.01;
speedMax = 0;
}
else {
  accelerationMax = 0.5;
  speedMax = 5;
} 
pushMatrix();
rectMode(CENTER);
translate (location.x, location.y);
rotate (PI/2 + velocity.heading());
fill(0,0,0);
beginShape();
vertex(30,10);
vertex(45,35);
vertex(35,30);
vertex(38,40);
vertex(45,45);
vertex(15,45);
vertex(22,40);
vertex(25,30);
vertex(15,35);
endShape();
popMatrix();
}

The problem (probably?) revolves around getFinalVec() which checks if vecBuffer[] (an ArrayList of PVectors) isn't empty and is valid (not too close to a certain point). I also included computeNextVector() just in case as its called from within getFinalVec()

Assume RSol-RIst is basically (0,0,0) As far as I understand it, vecBuffer[] is acting weirdly. When I checked nextDistance (which should be a PVector close to vecBuffer.get(0) ) I found it to alternate between the correct value and a wildly different one. So even though I input 18 PVectors in to vecBuffer[] I was seeing 36, but .size() was never greater than 18. The superflous PVector would trigger (nextDistance.mag() < cullDistance) and so remove an element from vecBuffer every other pass until it was empty :(

I've only done the basics with ArrayLists and PVectors so I'm assuming that I've messed up in some really simple (but hopefully immediately recognizable) way with one of them that some one can see?

Thanks in advance.

import java.util.*;
import hypermedia.net.*;
import controlP5.*;

ArrayList<PVector> vecBuffer = new ArrayList();

//...

void draw() {
  background(0);

  if (kukaBuffer!="") {
    kukaRef = splitTokens(kukaBuffer, "=");   //load kuka data
    extractVectors();                         //extract RIst/RSol
    getFinalVec();                            //defines finalVec and ensures valid input

    extractIPOC();
    sendtoKuka();
  }
}

void getFinalVec() {
  boolean check = false;
  while (check==false) {
    if (vecBuffer.size()==0) {
      finalVec = nullVec;
      check = true;      //get out of check, null vec
    } else {
      PVector nextDistance = PVector.sub(RSol, RIst);
      nextDistance.add(vecBuffer.get(0));
      println(nextDistance);
      println("{n="+vecBuffer.size());
      println(nextDistance.mag()<cullDistance);
      if (nextDistance.mag() < cullDistance) {
        vecBuffer.remove(0);
        println("removed!!");
        check = false;   //redo check
      } else {
        finalVec = computeNewVector();
        check = true;    //get out of check, new vec
      }
    }
  }
}

PVector computeNewVector() {
  //travel vector
  PVector nextDistance = PVector.sub(RSol, RIst);
  nextDistance.add(vecBuffer.get(0));
  //println("distance: "+nextDistance.mag());
  if (nextDistance.mag() < slowLim) {
    println("reached point");
    prevVec = currVec;
    currVec = nullVec;
    vecBuffer.remove(0);
  }

  float prevScalar = prevVec.mag() - acc;
  if (prevScalar<=0) {
    prevVec = nullVec;
  } else {
    prevVec.setMag(prevScalar);
  }

  float currScalar = currVec.mag() + acc;
  currVec = vecBuffer.get(0);
  if (currScalar >= spd) {
    currVec.setMag(spd);
  } else {
    currVec.setMag(currScalar);
  }

  //println(vecBuffer.get(0));
  PVector newVec = PVector.add(currVec, prevVec);
  newVec.limit(spd);
  return newVec; //finalVec
}

Spawnball sb = new Spawnball(50);
Spawnball sb2 = new Spawnball(30);
void setup() {
  size(850, 650);
  noCursor();
}

void draw() {
  background(0);
  sb.update();
  sb.display();
  noFill();
  stroke(200);
  ellipse(mouseX, mouseY, 8, 8);
}

class Spawnball {
  int dia;
  PVector loc;
  PVector vel;
  PVector acc;

  Spawnball(int d) {
    dia = d;
    loc = new PVector(0, 0);
    vel = new PVector(0, 0);
    acc = new PVector(0, 0);
  }

  void update() {
    PVector pos = new PVector(mouseX, mouseY);
    pos.sub(loc);
    pos.setMag(.1);
    acc = pos;
    vel.add(acc);
    loc.add(vel);
    acc.mult(0);
    vel.limit(3);
  }

  void display() {
    fill(10, 175, 3*dia);
    noStroke();
    ellipse(loc.x, loc.y, dia, dia);
  }
}

I've created a grid of eyes and I'm trying to get each pupil to follow the mouse without it coming out of the ellipse. As I understand multiplying the vector by a factor of 0.5 would half the size of my line, unfortunately this is not the case.

Could anyone help me out?!

Thanks :)

Ps: Of course, if there's is a more efficient way of doing this please feel free to point it out.

int nEyes = 20;
PVector[] eyes = new PVector[nEyes*5];
PVector[] mouse = new PVector[nEyes*5];

void setup() {
  size(600, 400);
  noFill();
  smooth();

  // Creating an array of points
  int i = 0;
  for (int x = 1; x < nEyes; x++) {
    for (int y = 1; y < nEyes; y++) {
      eyes[i] = new PVector((width/nEyes) * x, (height/nEyes) * y);
      y ++;
      i ++;
    }
    x ++;
  }
}

void draw() {

  background(255);

  for (int i = 0; i < eyes.length; i++) {
    noFill();
    ellipse(eyes[i].x, eyes[i].y, 50, 25); // This is the eye

    mouse[i] = new PVector(mouseX, mouseY);

    //mouse[i].sub(eyes[i]); // These won't work
    //mouse[i].mult(0.1);
    //mouse[i].limit(20);


    fill(0);
    ellipse(mouse[i].x, mouse[i].y, 10, 10); // This is the pupil
    line(eyes[i].x, eyes[i].y, mouse[i].x, mouse[i].y);
  }
}