def setup():
    size(640, 640)


def draw():
    background(255)
    translate(width/2, height/2)
    location = PVector(200, 200)
    mouse = PVector(mouseX, mouseY)

    mouse.sub(location) # vector from mouse to point
    mouse.normalize()
    mouse.mult(50)
    line(0, 0, mouse.x, mouse.y)

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).

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);
            }
          }
        }
      }
    }
  }

PVector walker;
PVector start;
PVector seek;
float count;


void setup() {
  size (900, 900);

  walker= new PVector (width/2, height-10);
  start= new PVector(0, -1);
  seek=new PVector(random(-1, 1), random( 1));

  count=0;
}

void draw() {
  background(53, 111);

  count++;

  stroke(0, 0, 255);
  rect(width/2, height-10, 10, 10);

  noStroke();
  fill(255, 0, 0);
  ellipse(walker.x, walker.y, 5, 5);

  startt();
  limits();
  println(count);
}

void startt() {
  if (walker.y>=150 && count<50) {
    walker.add(start);
  } else {
    walker.add(seek);
  }
}
// once the condition is reached (count=1000) ,  walker "walks back" to its original position.


void limits() {
  if (walker.x>width || walker.x <0) {
    seek.x = -seek.x;
  } else if (walker.y>height || walker.y <0) {
    seek.y = -seek.y;
  }
}

` PVector mouse, center; int scalar;

void setup(){
  size(500,500);
  pixelDensity(2);

  background(255);
  scalar=20;
  color(255,0,0);
  strokeWeight(0.5);

}


void draw(){
    background(255);
    mouse = new PVector(mouseX,mouseY);
    center = new PVector(width/2,height/2);
    mouse.sub(center);
    mouse.normalize();
    mouse.mult(15);
    for(int i=0; i<width; i+=scalar-5){
    for(int j=0; j<height; j+=scalar+10){
    pushMatrix();
    translate(i,j);
  line(0, 0, mouse.x, mouse.y);
  translate(mouse.x,mouse.y);
  //float a = PVector.angleBetween(center, mouse);
   float angle = atan2(mouseY-100, mouseX-100);

  rotate(angle);
  line(0, 0, -4, -4);
  line(0, 0, +4, -4);
  popMatrix();
    }
  }

}`

In this situation, I am trying to calculate the angle between a stick and a ball. However, first off, the angle is only between 0 and 180 degrees when using a PVector for the points and the angleBetween() function. Secondly, the degrees don't correspond to my expectations, since 180 degrees is more like northwest than straight, and zero degrees is southeast etc.

Calculating a precise angle is important because I am creating this pool game, and I am using the angle between the stick and pool ball to calculate the x and y components of velocity using cos and sin respectively. I've been trying to do a myriad of things but it just doesn't work.

This is a slightly modified version of the "VectorMath" example provided on Porcessing's website. While this isn't my pool program, it uses the exact same processes as this example. So the fixes to this program to get it to work will be directly applicable to my code. What can be done to get the angles to correspond properly to conventional direction? (180 degree is west, 90 is south for processing... etc. ), and just in general, how can I get cos and sin in this situation to get the exact results that would be needed in a pool program, when calculating the x component with cos and y component with sin? Would atan2() offer a better solution?

float angle;
void setup() {
  size(640,360);
}

void draw() {
  background(0);

  // A vector that points to the mouse location
  PVector mouse = new PVector(mouseX,mouseY);
  // A vector that points to the center of the window
  PVector center = new PVector(width/2,height/2);
  // Subtract center from mouse which results in a vector that points from center to mouse
  mouse.sub(center);

  // Normalize the vector
  mouse.normalize();

  // Multiply its length by 150 (Scaling its length)
  mouse.mult(150);

  angle = PVector.angleBetween(center,mouse);
  println(degrees(angle));

  translate(width/2,height/2);
  // Draw the resulting vector
  stroke(255);
  strokeWeight(4);
  line(0,0,mouse.x,mouse.y);

}

Thank you!

I am trying to make a game with an ellipse (= antiballistic missile) which takes off from 1 of 3 spots and flies towards a mouse-clicked target leaving a trail and then disappears, along with the trail. I am creating a class called Amiss and was going to construct it as follows:

Amiss(color fillTemp, color strokeTemp, int widthTemp, int heightTemp, int speedTemp, int startXtemp, int startYtemp, int targXtemp, int targYtemp) {

I then figured I would use a move() method to animate the missile toward its target, something like this:

// "vP" stands for the vector path the missile will follow.
vP = new PVector(targX - startX, targY - startY);
vP.normalize();

xPos = xPos + speed * vP.x;
yPos = yPos + speed * vP.y;
ellipse(xPos, yPos, amWidth, amHeight);

It strikes me that having the program calculate the animating vector each time the missile moves is a waste of processing and that each missile should calculate its own normalized vP once when it is created and then store that vector amongst its parameters for quick, repeated use whenever move() is called.

Is this a good impulse?

Can you include an empty parameter within a constructor and then populate it with a value calculated from its other parameters?

If so, how do you do that?

While I'm at it, am I using method/parameter correctly for Processing?

Thanks for any help!

how do I calculate the limit of a vector? here is the exercise.

void limit(float max) {
  if (_______ > _______) {
    _________();
    ____(max);
  }
}

i am trying to accomplish something like this

velocity.add(acceleration);
velocity.limit(topspeed);

to get some background here is the link to said exercise. http://natureofcode.com/book/chapter-1-vectors/

ANSWER EDIT:

void limitt(float max){
    if(max > 10){
      velocity.normalize();
      velocity.mult(max);
    }
  }

Thank you in advance :)

Here is my code:

ArrayList mikroplastikParticles; // set of Mikroplastik Particles
int numOfMikroplastikPerField = 1;
int boardSize = 7; // board to be filled with vectors
int board [][] = new int [boardSize][boardSize]; 
PVector vectorSet [][] = new PVector [boardSize][boardSize];
int cellWidth; // Size of the fields
final int mikroplastikSize = 10;
final int VectorSize = 10;
int randomVectorPosition;
float mikroplastikSpeed = 1.;

void setup() {
  // basic Setup
  size(700, 700);
  smooth();
  rectMode(CORNER);
  ellipseMode(CENTER);
  cellWidth = width/boardSize; // width of the cell dependens on the size of the board 
  mikroplastikParticles = new ArrayList();

  // visualization of the board (understanding purpose only)
  fill(255, 255, 255);
  stroke(0);
  for (int r = 0; r<boardSize; r++) {
    for (int c = 0; c<boardSize; c++) {  
      rect(r * cellWidth, c * cellWidth, cellWidth, cellWidth);
    }
  }

  // now we start to initialize the particles
  for (int r = 0; r<boardSize; r++) // we want to fill every single field
    for (int c = 0; c<boardSize; c++) 
      for (int anz = 0; anz < numOfMikroplastikPerField; anz++) // we can choose how many particles per field we want with "numOfMikroplastikPerField"
        mikroplastikParticles.add(new Mikroplastik(r*cellWidth+random(cellWidth), c*cellWidth+ random(cellWidth))); // mikroplastik per field gets added

  // setting up the vectors
  for (int x = 0; x<boardSize; x++) {
    for (int y = 0; y<boardSize; y++) {
      randomVectorPosition = (int)random(2);
      if (randomVectorPosition == 0)
      vectorSet[x][y] = new PVector(0, random(cellWidth));
      else
      vectorSet[x][y] = new PVector(random(cellWidth), 0);
    }
  }
}

void draw() {
  background(255);
  for (int i=0; i < boardSize*boardSize*numOfMikroplastikPerField; i++) { 
    Mikroplastik myMikroplastik = (Mikroplastik)mikroplastikParticles.get(i); // getting all vectors from the array
    myMikroplastik.display(); // assigning a "to do" for the vectors
  }
}

class Mikroplastik  { // the actual mikroplastik class

  PVector mikroplastik = new PVector(0, 0); // the mikroplastik is a vector object
  PVector sum = new PVector(0, 0);

  Mikroplastik(float tempX, float tempY) {
    mikroplastik.set(tempX, tempY);
  }

  void display() 
{ // how the mikroplastik looks like 
    fill(#FF0000);
    noStroke();
    ellipse(mikroplastik.x, mikroplastik.y, mikroplastikSize, mikroplastikSize);

    // PVector mouse = Vector.vector(tempX, tempY);
    PVector mouse = new PVector(mouseX, mouseY);
    mouse.sub(mikroplastik);
    mouse.mult(0.05);
    sum.add(mouse);
    sum.normalize();
    sum.mult(mikroplastikSpeed);
    mikroplastik.add(sum);

  }
}

int num=100;
int diameter=10;
int limit=20;
float step=0.01;


PVector[] positions=new PVector[num];
float [] lookup=new float[num];

void setup() {
  size(1000, 1000);
  colorMode(HSB, 360, 100, 100);
  background(0);

  for (int i=0; i<num; i++) {
    float x=random(0, width);
    float y=random(0, height);
    positions[i]= new PVector();
    positions[i].set(x, y);
  }
  makeTable(lookup);
}

void draw() {
  background(0);

  for (int m=0; m<num; m++) {

    float ex=positions[m].x;
    float wy=positions[m].y;
    float h=m*360/num;
    noStroke();
    fill(h, 100, 100);
    ellipse(ex, wy, diameter, diameter);

  }

  move(positions, lookup);

}

void move(PVector[] places, float[]table) {
  for (int q=0; q<places.length; q++) {

    int next=q+1;
    if (next==places.length) {
      next=0;
    }

    PVector v=new PVector();
    v=PVector.sub(places[next], places[q]);

    float adjust=(v.mag()-limit)/v.mag();

    v.mult(adjust);
    v.mult(step);

    PVector v2=new PVector();
    v.normalize(v2);

    float multiplier=table[q];

    PVector v3=new PVector();
    v3.x=v2.y*multiplier;
    v3.y=-v2.x*multiplier;
    v.add(v3);

    places[q].add(v);
    places[q].x=constrain(places[q].x, 0.01*width, 0.99*width);
    places[q].y=constrain(places[q].y, 0.01*height, 0.99*height);
  }
}

void makeTable(float[] calculations) {

  for (int r=0; r<calculations.length; r++) {
    float angle=TWO_PI*float(r)/num;
    float a=sin(angle);

    calculations[r]=0.1*a;
  }
}