Processing Forum

grab viewport as pdf file of custom size

[5 Replies]
- 04-May-2013 12:51 AM
- Forum: Core Library Questions
Hey guys!

I have a processing script with multiple 3D animated spheres in OpenGL. I am getting rid of the background() in order to pan or zoom the camera and have the trails of the spheres drawn on the canvas.

So, I would like to capture the drawing created as I already described, as a PDF file. However the options that I have already tried based on the create PDF file found here: http://processing.org/reference/libraries/pdf/

do not seem to function.

Do you have any idea what can I do? It's more or less something like a print screen but with kind of huge resolution...

3D sphere mapping

[2 Replies]
- 26-Dec-2012 05:35 AM
- Forum: Contributed Library Questions
Hey guys!

I have coded a simple autonomous agents 3D environment and I trigger some events based on a "counter" a variable that takes integer values from 0 to 180. There is a public class for the basics and some subclasses that define some additional parameters for each group of agents. Every agent is being represented as a 3D shere.

What I want to do is to create something like a trail of spheres (for each agent) that depicts its path while flying. Something like this but in 3D:

import controlP5.*;

ControlP5 controlP5;

int time;

boolean playPause = true; // true = play, false = pause

void play() { playPause = !playPause; } // toggle

void setup() {

size(500,500);

frameRate(30);

smooth();

controlP5 = new ControlP5(this);

controlP5.addSlider("time",0,width,10,height-30,width-75,20);

controlP5.addButton("play",0,width-40,height-30,30,20);

}

void draw() {

background(125);

if (playPause) { time++; controlP5.controller("play").setLabel("Pause"); }

else { controlP5.controller("play").setLabel("Play"); }

if (time >= width) { time = 0; } // reset when right side is reached (only useful for this particular sketch)

controlP5.controller("time").setValue(time); // set the slider to time value

randomSeed(1); // controls the randomness, to get the same output every time

for (int i=0; i<time; i++) { // the time variable controls the output

float c = map(i,0,time,0,255);

fill(c,c);

ellipse(i%width,random(height),40,40);

}

}

So I tried to implement the map() function but the results are wrong. Any ideas how I can use it? Here is one of the subclasses and the public class:

class FW1 extends Capsule { // subclass: female_worker_single

FW1(float x_fw1, float y_fw1, float z_fw1, color c_fw1, int nam_fw1) {

super(x_fw1,y_fw1,z_fw1,c_fw1,nam_fw1);

}



void displayINFO() {

advance();

shapes2D();

}



void advance(){

angle += angleVel;

}



void display() {

fill(0,255,0);

noStroke();

pushMatrix();

translate(location.x, location.y, location.z);

sphere(r/2);



float c = map(counter,0,180,0,255);

translate(counter%location.x, counter%location.y, counter%location.z);

fill(c,c);

sphere(r/2);



popMatrix();

}



void shapes2D(){



fill(0,255,0);

noStroke();

pushMatrix();

translate(location.x, location.y, location.z);

sphere(r/2);

float[] rota = cam.getRotations();

rotateX(rota[0]);

rotateY(rota[1]);

rotateZ(rota[2]);



fill(160);

String myText = "ID: female-worker-single" + "\nx: " + location.x + "\ny: " + location.y + "\nz: " + location.z;

textSize(3);

text(myText,location.x/4,location.y/6, location.z/10);



stroke(160); fill(0,0,0,0);strokeWeight(1);

ellipse(0,0,8,8);



stroke(0,255,0); fill(0,255,0);strokeWeight(0.3);

line(-4,-6,-10,-12);

line(-10,-12,-16,-12);

ellipse(-4,-6,1,1);

text("buffer zone", -25, -12);



rotate(angle);

stroke(0,255,0); fill(0,0,0,15);strokeWeight(0.3);

ellipse(0,0,18,18);

line(0,10,0,12);

line(0,-8,0,-10);

line(-8,0,-10,0);

line(8,0,10,0);

popMatrix();

}

}

abstract class Capsule { //the super-class that defines the chararacteristics of the agents

PVector location;

PVector velocity;

PVector acceleration;

float r; // the radius of the circles-spheres/ agents

float wandertheta, wanderphi, wanderpsi;

float maxforce; // Maximum steering force

float maxspeed; // Maximum speed

color fillColor; // differentiation of agent types are based on complementary coloring

int name; // gives an ID - number to each different agent

float angle, angleVel;



Capsule(float x, float y, float z, color c, int nam) { // the class constructor

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

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

location = new PVector(x,y,z);

r = 6;

wandertheta = 0;

wanderphi = 0;

wanderpsi = 0;

maxspeed = 0.5;

maxforce = 0.05;

fillColor = c;

name = nam;

angle=random(0, 6.28);

angleVel = random(-0.1,0.1);

}

void update() { // Method to update location

velocity.add(acceleration); // Update velocity

velocity.limit(maxspeed); // Limit speed

location.add(velocity); // Reset accelertion to 0 each cycle

acceleration.mult(0);

}

void wander() { // Method that makes the agent float into 2D space

float wanderR = 25; // Radius for our "wander circle"

float wanderD = 200; // Distance for our "wander circle"

float change = 0.05;

wandertheta += random(-change,change); // Randomly change wander theta

// calculating the new location to steer towards on the wander circle

PVector circleloc = velocity.get(); // Start with velocity

circleloc.normalize(); // Normalize to get heading

circleloc.mult(wanderD); // Multiply by distance

circleloc.add(location); // Make it relative to boid's location



float h = velocity.heading2D(); // We need to know the heading to offset wandertheta

PVector circleOffSet = new PVector(wanderR*cos(wandertheta+h),wanderR*sin(wandertheta+h));

PVector target = PVector.add(circleloc,circleOffSet);

seek(target);

}



PVector wander3D() {

float wanderR = 30.0; // Radius for our "wander circle"

float wanderD = 30.0; // Distance for our "wander circle"

float change = 0.5;

wandertheta += random(-change, change); // Randomly change wander theta

wanderphi += random(-change, change); // Randomly change wander phi

wanderpsi += random(-change, change); // Randomly change wander psi

PVector circleloc = velocity.get(); // Start with velocity

circleloc.normalize(); // Normalize to get heading

circleloc.mult(wanderD); // Multiply by distance

circleloc.add(location); // Make it relative to boid's location

PVector circleOffSet = new PVector(wanderR*cos(wandertheta),wanderR*sin(wanderphi), wanderR*cos(wanderpsi));

PVector target = PVector.add(circleloc,circleOffSet);

return target;

}

void applyForce(PVector force) { // Newton's second law; We could add mass here if we want A = F / M

acceleration.add(force);

}

// A method that calculates and applies a steering force towards a target

// STEER = DESIRED MINUS VELOCITY

void seek(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

desired.normalize(); // Normalize desired and scale to maximum speed

desired.mult(maxspeed);

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(maxforce); // Limit to maximum steering force

applyForce(steer);

}



// Method that lowers the speed of the agent by the time he reaches the target - see: "buffer zone"

void arrive(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

float d = desired.mag();

desired.normalize(); // Normalize desired and scale with arbitrary damping within 100 pixels

if (d < r) {

float m = map(d,0,15,0,maxspeed);

desired.mult(m);

} else {

desired.mult(maxspeed);

}

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(5*maxforce); // Limit to maximum steering force

applyForce(steer);

}



void displayINFO() {

advance();

shapes2D();

}



void advance(){ // animates rotation for the buffer zone ellipse

angle += angleVel;

}



void display() { // Draws an ellipse that represents an agent-capsule

fill(fillColor);

noStroke();

pushMatrix();

translate(location.x, location.y, location.z);

sphere(r/2);

popMatrix();

}



void shapes2D() {

/////////////////////////billboarding/////////////////////////

fill(0,0,0);

noStroke();

pushMatrix();

translate(location.x, location.y, location.z);

sphere(r/2);

float[] rota = cam.getRotations();

rotateX(rota[0]);

rotateY(rota[1]);

rotateZ(rota[2]);

fill(160);

String myText = "ID: - give agent characteristics -" + "\nx: " + location.x + "\ny: " + location.y + "\nz: " + location.z;

textSize(3);

text(myText,location.x/4,location.y/6, location.z);



stroke(160); fill(0,0,0,0);strokeWeight(1);

ellipse(0,0,8,8);



line(-4,-6,-10,-12); // drawing the Info

line(-10,-12,-16,-12);

stroke(0,255,0); fill(0,255,0);strokeWeight(0.3);

ellipse(-4,-6,1,1);

text("buffer zone", -25, -12);



rotate(angle);

stroke(0); fill(0);strokeWeight(0); // 2D shape representing the buffer zone

ellipse(0,0,0,0);

line(0,0,0,0);

line(0,0,0,0);

line(0,0,0,0);

line(0,0,0,0);



popMatrix();

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

}



// Method that checkes the maximum floating range of the agents - bouncing on the edges of the cube

void boundaries() {

if (location.x < 0 || location.x > worldSize) {

velocity.x *=-1;

}

if (location.y < 0 || location.y > worldSize) {

velocity.y *=-1;

}



if (location.z < 0 || location.z > worldSize) {

velocity.z *=-1;

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separate (ArrayList<Capsule> agent) {

float desiredseparation = r*4; // 4*r = separation ONLY for wandering

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsule v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separateSpecial (ArrayList<Capsule> agent) {

float desiredseparation = r; //

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsule v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Alignment

// For every nearby agent in the system, calculate the average velocity

PVector align (ArrayList<Capsule> agent) {

float neighbordist = 50;

PVector sum = new PVector(0,0);

int count = 0;

for (Capsule v : agent) {

float d = PVector.dist(location,v.location);

if ((d > 0) && (d < neighbordist)) {

sum.add(v.velocity);

count++;

}

}

if (count > 0) {

sum.div((float)count);

sum.normalize();

sum.mult(maxspeed);

PVector steer = PVector.sub(sum,velocity);

steer.limit(maxforce);

return steer;

} else {

return new PVector(0,0);

}

}

}

sliders in fixed positions on canvas

[2 Replies]
- 25-Dec-2012 06:51 AM
- Forum: Contributed Library Questions
Hey guys! Merry Christmas to everyone btw! :)

Here's another noob question.

I have a 3D sketch and I added a timeline slider using controlP5 configurations. However, it seems that the entire slider turns when I turn the camera...

How can I make it "lock" on a specific place on the canvas? What am I doin' wrong?

Here's part of the script with all arrangements for the slider marked in yellow:

import peasy.org.apache.commons.math.*; // imports all 3D related libraries

import peasy.*;

import peasy.org.apache.commons.math.geometry.*;

import processing.opengl.*;

import controlP5.*; // library for the slider - interface

ControlP5 controlP5;

Slider timeline_slider;

PeasyCam cam;

PMatrix3D currCameraMatrix;

PGraphics3D g3;

float worldSize = 300; // the space - rendered as a cube - limiting agents movement

StopWatchTimer sw; // a visual timer-clock implementation on canvas

int time; // a counter for time triggering events

int wait = 1000; // 1 second

Facilities work; // wondering agent -- represents (W)

Facilities retail; // wondering agent -- represents (R)

Facilities school; // wondering agent -- represents (S)

Facilities leisure; // wondering agent -- represents (L)

ArrayList <Capsule> agents;

float d = 25;

int counter=0; // counter inception

int temp=0;

boolean animate = true; // boolean for pausing the animation sequence

void setup() {



size(600,600,OPENGL);

cam = new PeasyCam(this, 300);

cam.lookAt(150, 150, 300);

cam.setMinimumDistance(10);

cam.setMaximumDistance(1500);



time = millis(); // store the current time



smooth(); // setup of visual time clock

println (millis());

sw = new StopWatchTimer();

sw.start();



// Interface Sliders

controlP5 = new ControlP5(this);

timeline_slider = controlP5.addSlider("timeline", 0, 180, 20, 550, 200, 10); // name, min, max, default, x, y, w, h



// creating the facilities

work = new Facilities(50,50,50); // generates a hypothetic invisible agent (W)

retail = new Facilities(30,30,30); // generates a hypothetic invisible agent (R)

school = new Facilities(240,240,240); // generates a hypothetic invisible agent (S)

leisure = new Facilities(90,90,90); // generates a hypothetic invisible agent (L)



agents = new ArrayList<Capsule>(); // creating the agents



// setting the emitter in random positions for each group

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

if (i < 20) agents.add(new MW1(150,150,150,color(255,0,0),i)); // Red

else if (i < 45) agents.add(new FW1(100,100,100,color(0,255,0),i)); // Green

else if (i < 65) agents.add(new MW2(200,200,200,color(0,255,255),i)); // Cyan

else if (i < 85) agents.add(new FnW2(80,80,80,color(0,155,0),i)); // dark Green

else if (i < 95) agents.add(new MW3(130,130,130,color(255,255,0),i)); // Yellow

else if (i < 105) agents.add(new FnW3(60,60,60,color(255,0,255),i)); // Purple

else agents.add(new CS3(10,10,10,color(0,0,255),i)); // Blue

}

}

//--------------configuring the canvas & the counter-------------

void draw() {

background(20);

time(); // reference to the visual timer

gui();

controlP5.controller("timeline").setValue(counter); // set the slider to time value



displayWorldCenter();



noLights();

cam.beginHUD();

cam.endHUD();



cam.setMouseControlled(true);

if(mouseY<80) {

cam.setMouseControlled(false);

}



// check the difference between now and the previously stored time is greater than the wait interval

if (animate) {

if(millis() - time >= wait){

println(counter);// if it is, do something

temp=counter;

time = millis();// also update the stored time

counter++; // counter augmentation



if(counter >180){ // check whether time exceeds 180 sec. aka 24:00 hours - enables looping

counter=0;

}

}

}



//-------------------------------------------------------------



work.Default(); // main-basic functions of (W) facility

retail.Default(); // main-basic functions of (R) facility

school.Default(); // main-basic functions of (S) facility

leisure.Default(); // main-basic functions of (L) facility



PVector vectorOfwork = new PVector(work.location.x, work.location.y, work.location.z); // creates a vector that connects all individual agents with the (W) facility

PVector vectorOfretail = new PVector(retail.location.x, retail.location.y, retail.location.z); // creates a vector that connects all individual agents with the (R) facility

PVector vectorOfschool = new PVector(school.location.x, school.location.y, school.location.z); // creates a vector that connects all individual agents with the (S) facility

PVector vectorOfleisure = new PVector(leisure.location.x, leisure.location.y, leisure.location.z); // creates a vector that connects all individual agents with the (L) facility



int i = 0; // i & j make sure that each agent returns to the family it belongs

int j = 0;



for (Capsule agent : agents) { // instancing - creating objects

//---------------------implementing selection------------------

float sx = screenX(agent.location.x, agent.location.y, agent.location.z);

float sy = screenY(agent.location.x, agent.location.y, agent.location.z);

float diam = map(agent.location.z, -worldSize/2, worldSize/2, 10, 20);

boolean selected = dist(mouseX, mouseY, sx, sy) < diam/2;

if (selected) { fill(255, 0, 0); }

if (selected) {

agent.advance();

agent.displayINFO();

}

//-------------------------------------------------------------



agent.display();



if (animate) {



agent.boundaries(); // basic behavior for ALL the agents

agent.update();

agent.wander();

agent.wander3D();

agent.separateSpecial(agents); // global separation that affects ALL the agents

if (counter>0 && counter<=60) {



if (agent instanceof FnW2){ // females attach&follow males - couples

agent.arrive( agents.get(i-20).location );

}

else if (agent instanceof FnW3) { // females attach&follow males - 3 member family

agent.arrive( agents.get(i-10).location );

}

else if (agent instanceof CS3) { // children attach&follow females - 3 member family

agent.arrive( agents.get(i-10).location );

}



i++;



}



if (counter>60 && counter<=120) { // time reference to 6.00-14.00 hours

agent.separate(agents);



if (agent instanceof MW1){

agent.arrive( vectorOfwork );

}

else if (agent instanceof MW2) {

agent.arrive( vectorOfwork );

}

else if (agent instanceof MW3) {

agent.arrive( vectorOfwork );

}

else if (agent instanceof FW1) {

agent.arrive( vectorOfwork );

}

else if (agent instanceof FnW2) {

agent.arrive( vectorOfretail );

}

else if (agent instanceof FnW3) {

agent.arrive( vectorOfretail );

}

else if (agent instanceof CS3) {

agent.arrive( vectorOfschool );

}

}

if (counter>120 && counter<=180) {



if (agent instanceof FnW2){ // females attach&follow males - couples

agent.arrive( agents.get(j-20).location );

}

else if (agent instanceof FnW3) { // females attach&follow males - 3 member family

agent.arrive( agents.get(j-10).location );

}

else if (agent instanceof CS3) { // children attach&follow females - 3 member family

agent.arrive( agents.get(j-10).location );

}



j ++;



}

}

}

}



void displayWorldCenter(){

pushMatrix();

translate(150,150,150);

stroke(255); noFill(); // stroke of the cube (box)

box(worldSize);

stroke(#209889); noFill(); // stroke of the ellipses(center)

ellipse(0,0,20,20);

rotateY(radians(90));

ellipse(0,0,20,20);

rotateZ(radians(90));

ellipse(0,0,20,20);

rotateX(radians(90));

rotateY(radians(90));

ellipse(0,0,20,20);

popMatrix();

}

//-------------------------------------------------------------

void time() { // visual configuration for the timer-clock

fill(#000000);

textAlign(CENTER);

text(nf(sw.hour(), 2)+":"+nf(sw.minute(), 2)+":"+nf(sw.second(), 2)+":"+nf(sw.hundrensec(), 2), 260, 290);

}

void gui() {

controlP5.draw();

controlP5.setAutoDraw(false);

}

void keyPressed(){

if (key=='a') animate = true;

else if (key=='s') animate = false;

}

3D picking for autonomous agents

[6 Replies]
- 22-Dec-2012 06:54 AM
- Forum: Programming Questions
Hey guys!

I'm gonna need your help for this one. I have scripted a 3D environment with 7 different groups of autonomous agents flocking around. I use a public class and some subclasses for each of the different group of agents. I use an arrayList in order to create them; something like this:

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

if (i < 20) agents.add(new MW1 (150,150,150,color(255,0,0),i)); // Red

else if (i < 45) agents.add(new FW1 (100,100,100,color(0,255,0),i)); // Green

else if (i < 65) agents.add(new MW2 (200,200,200,color(0,255,255),i)); // Cyan

else if (i < 85) agents.add(new FnW2 (80,80,80,color(0,155,0),i)); // dark Green

else if (i < 95) agents.add(new MW3 (130,130,130,color(255,255,0),i)); // Yellow

else if (i < 105) agents.add(new FnW3 (60,60,60,color(255,0,255),i)); // Purple

else agents.add(new CS3 (10,10,10,color(0,0,255),i)); // Blue

}

btw the constructor of the superclass looks like this:

Capsule(float x, float y, float z, color c, int nam) { // the class constructor

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

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

location = new PVector(x,y,z);

r = 6;

wandertheta = 0;

wanderphi = 0;

wanderpsi = 0;

maxspeed = 0.5;

maxforce = 0.05;

fillColor = c;

name = nam;

}

I would like to implement some 3D picking (at this point I do not care if only one agent or its entire group will be picked). I looked at some of the existing libraries that already exist, but I have no clue on how I should procceed or which one of them is the most suitable.

Any help would be much appreciated!

P.S. : if you need to see the entire code just tell me to add it here, it's just to long so I avoid it for now.

2D shape always facing the camera (in 3D)

[2 Replies]
- 21-Dec-2012 02:22 AM
- Forum: General Discussion
Hey guys!

I didn't know how sould I search for this one that is why I am asking you here.

Let's say that we have a 3D processing environment (openGL or whatever).

Is it possible to draw a simple shape (a rectangle for example) so that will always "face" the camera no matter if you turn, move or rotate the camera? So that you always "see" a 2D rectangle and not any perspactive distortions of the shape...

If anyone know any way to do this or a relative example I 'll be glad to hear! :)

3D picker and autonomous agents

[2 Replies]
- 20-Dec-2012 07:03 AM
- Forum: General Discussion
Hey guys!

Is it possible to use a 3D picker (or the "picking library") for selecting separate autonomous agents created with an arryList (in 3D space)?

I have been trying to use the 3d picker with some simple 2D autonomous agents configurations and it does not seem to work, although it might be because of my own scripting mistakes. Are there any examples or references related to this subject?

Thanks in advance

calling separate functions for subclasses

[19 Replies]
- 07-Dec-2012 01:41 PM
- Forum: Programming Questions
Hey guys!

Once again I need your help! I have included the source code below. It's a simple sketch that generates some wandering autonomous agents on a 2D canvas. At this point, there is 1 superclass called "Capsules"and 2 subclasses called MW1 and FW1.

I have succeeded in implementing inheritance and polymorphism (at least I think so) and I generate the agents using this part:

agents = new ArrayList<Capsule>();

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

if (i < 20) agents.add(new MW1(random(width),random(height),color(255,0,0),i));

else agents.add(new FW1(random(width),random(height),color(0,255,0),i));

}

and inside draw() I am able to call some functions included in the superclass. My question is: how can I apply a function (like arrive() for example) only for the MW1 agents and NOT all of them(?) Cause right now, any method I call, is being applied to all of them, no matter how many agents I create, through this:

for( Capsule agent : agents) { // instancing - creating objects

agent.Default(); // default flocking behavior for ALL the agents

agent.separate(agents); // global separation that affects ALL the agents

}

here is the entire code, any kind of help would be much appreciated!

StopWatchTimer sw; // a visual timer-clock implementation on canvas

int time; // a counter for time triggering events

int wait = 1000; // 1 second

Facilities work; // wondering agent -- represents (W)

Facilities retail; // wondering agent -- represents (R)

Facilities school; // wondering agent -- represents (S)

Facilities leisure; // wondering agent -- represents (L)

ArrayList<Capsule> agents;

float d = 25;

int counter=0; // counter inception

int temp=0;

void setup() {



size(300,300); //generates the basic composition canvas

time = millis(); //store the current time



smooth(); //setup of visual time clock

println (millis());

sw = new StopWatchTimer();

sw.start();



// creating the facilities

work = new Facilities(random(width),random(height)); //generates a hypothetic invisible agent (W)

retail = new Facilities(random(width),random(height)); //generates a hypothetic invisible agent (R)

school = new Facilities(random(width),random(height)); //generates a hypothetic invisible agent (S)

leisure = new Facilities(random(width),random(height)); //generates a hypothetic invisible agent (L)



// creating the agents

agents = new ArrayList<Capsule>();

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

if (i < 20) agents.add(new MW1(random(width),random(height),color(255,0,0),i));

else agents.add(new FW1(random(width),random(height),color(0,255,0),i));

}

}

//--------------configuring the canvas & the counter-------------

void draw() {

background(255);

time(); //reference to the visual timer



//check the difference between now and the previously stored time is greater than the wait interval

if(millis() - time >= wait){

println(counter);//if it is, do something

temp=counter;

time = millis();//also update the stored time

counter++; // counter augmentation



if(counter >180){ // check whether time exceeds 180 sec. aka 24:00 hours

counter=0;

}

}



//-------------------------------------------------------------



work.Default(); //main-basic functions of (W) facility

retail.Default(); //main-basic functions of (R) facility

school.Default(); //main-basic functions of (S) facility

leisure.Default(); //main-basic functions of (L) facility



PVector vectorOfwork = new PVector(work.location.x, work.location.y); //creates a vector that connects all individual agents with the (W) facility

PVector vectorOfretail = new PVector(retail.location.x, work.location.y); //creates a vector that connects all individual agents with the (R) facility

PVector vectorOfschool = new PVector(school.location.x, school.location.y); //creates a vector that connects all individual agents with the (S) facility

PVector vectorOfleisure = new PVector(leisure.location.x, leisure.location.y); //creates a vector that connects all individual agents with the (L) facility





for( Capsule agent : agents) { // instancing - creating objects

agent.Default(); // default flocking behavior for ALL the agents

agent.separate(agents); // global separation that affects ALL the agents

}

}

//-------------------------------------------------------------

void time() { //visual configuration for the timer-clock

background(#FFFFFF);

fill(#000000);

textAlign(CENTER);

text(nf(sw.hour(), 2)+":"+nf(sw.minute(), 2)+":"+nf(sw.second(), 2)+":"+nf(sw.hundrensec(), 2), 260, 290);

}

//---------------------------------------------superclass----------------------------------------------------//

class Capsule { //the super-class that defines the chararacteristics of the agents

PVector location;

PVector velocity;

PVector acceleration;

float r; //the radius of the circles-spheres/ agents

float wandertheta;

float maxforce; // Maximum steering force

float maxspeed; // Maximum speed

color fillColor; //differentiation of agent types are based on complementary coloring

int name; // gives an ID - number to each different agent



Capsule(float x, float y, color c, int nam) { //the class constructor

acceleration = new PVector(0,0);

velocity = new PVector(0,0);

location = new PVector(x,y);

r = 6;

wandertheta = 0;

maxspeed = 0.5;

maxforce = 0.05;

fillColor = c;

name = nam;

}



void Default() {

boundaries();

update();

display();

wander();

}

void update() { // Method to update location

velocity.add(acceleration); // Update velocity

velocity.limit(maxspeed); // Limit speed

location.add(velocity); // Reset accelertion to 0 each cycle

acceleration.mult(0);

}

void wander() { // Method that makes the agent float into 2D space

float wanderR = 25; // Radius for our "wander circle"

float wanderD = 200; // Distance for our "wander circle"

float change = 0.05;

wandertheta += random(-change,change); // Randomly change wander theta

// calculating the new location to steer towards on the wander circle

PVector circleloc = velocity.get(); // Start with velocity

circleloc.normalize(); // Normalize to get heading

circleloc.mult(wanderD); // Multiply by distance

circleloc.add(location); // Make it relative to boid's location



float h = velocity.heading2D(); // We need to know the heading to offset wandertheta

PVector circleOffSet = new PVector(wanderR*cos(wandertheta+h),wanderR*sin(wandertheta+h));

PVector target = PVector.add(circleloc,circleOffSet);

seek(target);

}

void applyForce(PVector force) { // Newton's second law; We could add mass here if we want A = F / M

acceleration.add(force);

}

// A method that calculates and applies a steering force towards a target

// STEER = DESIRED MINUS VELOCITY

void seek(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

desired.normalize(); // Normalize desired and scale to maximum speed

desired.mult(maxspeed);

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(maxforce); // Limit to maximum steering force

applyForce(steer);

}



// Method that lowers the speed of the agent by the time he reaches the target - see: "buffer zone"

void arrive(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

float d = desired.mag();

desired.normalize(); // Normalize desired and scale with arbitrary damping within 100 pixels

if (d < 6) {

float m = map(d,0,15,0,maxspeed);

desired.mult(m);

} else {

desired.mult(maxspeed);

}

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(5*maxforce); // Limit to maximum steering force

applyForce(steer);

}



void display() { // Draws an ellipse that represents an agent-capsule

fill(fillColor);

stroke(0);

pushMatrix();

translate(location.x, location.y);

ellipse(0, 0, r, r);

popMatrix();

}



//Method that checkes the maximum floating range of the agents

void boundaries() {

PVector desired = null;

if (location.x < d) {

desired = new PVector(maxspeed, velocity.y);

}

else if (location.x > width -d) {

desired = new PVector(-maxspeed, velocity.y);

}

if (location.y < d) {

desired = new PVector(velocity.x, maxspeed);

}

else if (location.y > height-d) {

desired = new PVector(velocity.x, -maxspeed);

}

if (desired != null) {

desired.normalize();

desired.mult(maxspeed);

PVector steer = PVector.sub(desired, velocity);

steer.limit(2*maxforce);

applyForce(steer);

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separate (ArrayList<Capsule> agent) {

float desiredseparation = r*4; //4*r = separation ONLY for wandering

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsule v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separateSpecial (ArrayList<Capsule> agent) {

float desiredseparation = r; //

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsule v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Alignment

// For every nearby agent in the system, calculate the average velocity

PVector align (ArrayList<Capsule> agent) {

float neighbordist = 50;

PVector sum = new PVector(0,0);

int count = 0;

for (Capsule v : agent) {

float d = PVector.dist(location,v.location);

if ((d > 0) && (d < neighbordist)) {

sum.add(v.velocity);

count++;

}

}

if (count > 0) {

sum.div((float)count);

sum.normalize();

sum.mult(maxspeed);

PVector steer = PVector.sub(sum,velocity);

steer.limit(maxforce);

return steer;

} else {

return new PVector(0,0);

}

}

}

//--------------------------------------------------------subclasses-----------------------------------------------------------------------//

class MW1 extends Capsule { // subclass: male_worker_single

MW1(float x_mw1, float y_mw1, color c_mw1, int nam_mw1) {

super(x_mw1,y_mw1,c_mw1,nam_mw1);

}



void display() {

fill(255,0,0);

stroke(0);

pushMatrix();

translate(location.x, location.y);

ellipse(0, 0, r, r);

popMatrix();

}



}

class FW1 extends Capsule { // subclass: female_worker_single

FW1(float x_fw1, float y_fw1, color c_fw1, int nam_fw1) {

super(x_fw1,y_fw1,c_fw1,nam_fw1);

}



void display() {

fill(0,255,0);

stroke(0);

pushMatrix();

translate(location.x, location.y);

ellipse(0, 0, r, r);

popMatrix();

}

}

//----------------------------------------------rest parts------------------------------------------------------//

class Facilities { //the class that defines the chararacteristics of institutions



PVector location;

PVector velocity;

PVector acceleration;

float r; //the radius of the circles-spheres/ facilities

float wandertheta;

float maxforce; // Maximum steering force

float maxspeed; // Maximum speed



Facilities(float x, float y) { //the class constructor

acceleration = new PVector(0,0);

velocity = new PVector(0,0);

location = new PVector(x,y);

r = 6;

wandertheta = 0;

maxspeed = 1;

maxforce = 0.05;

}



void Default() { // the basic, default functions for the facility

wander();

run();

boundaries();

}



void run() {

update();

display();

}



void update() { // Method to update location

velocity.add(acceleration); // Update velocity

velocity.limit(maxspeed); // Limit speed

location.add(velocity);

acceleration.mult(0); // Reset accelertion to 0 each cycle

}

void wander() { // Method that makes the agent float into 2D space

float wanderR = 25; // Radius for our "wander circle"

float wanderD = 30; // Distance for our "wander circle"

float change = 2;

wandertheta += random(-change,change); // Randomly change wander theta

// calculating the new location to steer towards on the wander circle

PVector circleloc = velocity.get(); // Start with velocity

circleloc.normalize(); // Normalize to get heading

circleloc.mult(wanderD); // Multiply by distance

circleloc.add(location); // Make it relative to boid's location



float h = velocity.heading2D(); // We need to know the heading to offset wandertheta

PVector circleOffSet = new PVector(wanderR*cos(wandertheta+h),wanderR*sin(wandertheta+h));

PVector target = PVector.add(circleloc,circleOffSet);

seek(target);

}

void applyForce(PVector force) { // We could add mass here if we want A = F / M

acceleration.add(force);

}

// A method that calculates and applies a steering force towards a target

// STEER = DESIRED MINUS VELOCITY

void seek(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

desired.normalize(); // Normalize desired and scale to maximum speed

desired.mult(maxspeed);

// Steering = Desired minus Velocity

PVector steer = PVector.sub(desired,velocity);

steer.limit(maxforce); // Limit to maximum steering force

applyForce(steer);

}

void display() { // Draw an ellipse that represents a facility-capsule

fill(255);

stroke(255);

pushMatrix();

translate(location.x, location.y);

ellipse(0, 0, r, r);

popMatrix();

}

//Method that checkes the maximum floating range of the facilities

void boundaries() {

PVector desired = null;

if (location.x < d) {

desired = new PVector(maxspeed, velocity.y);

}

else if (location.x > width -d) {

desired = new PVector(-maxspeed, velocity.y);

}

if (location.y < d) {

desired = new PVector(velocity.x, maxspeed);

}

else if (location.y > height-d) {

desired = new PVector(velocity.x, -maxspeed);

}

if (desired != null) {

desired.normalize();

desired.mult(maxspeed);

PVector steer = PVector.sub(desired, velocity);

steer.limit(2*maxforce);

applyForce(steer);

}

}

}

// class timer -- the visual counting clock on the canvas

class StopWatchTimer {

int startTime = 0, stopTime = 0;

boolean running = false;

void start() {

startTime = millis();

running = true;

}

void stop() {

stopTime = millis();

running = false;

}

int getElapsedTime() {

int elapsed;

if (running) {

elapsed = (millis() - startTime);

}

else {

elapsed = (stopTime - startTime);

}

return elapsed;

}



int hundrensec() // And add in the class before int second() this :

{

return (getElapsedTime() / 10) % 100;

}

int second() {

return (getElapsedTime() / 1000) % 60;

}

int minute() {

return (getElapsedTime() / (1000*60)) % 60;

}

int hour() {

return (getElapsedTime() / (1000*60*60)) % 24;

}

}

reconfiguring the objects array example

[3 Replies]
- 03-Dec-2012 02:18 PM
- Forum: Programming Questions
Hey there!

I 'm trying to reconfigure the example of Array Objects found here:

http://processing.org/learning/basics/arrayobjects.html

with another class and even though it is compiling, it doesn't preview anything. Probably a silly mistake from a noob... This is the code btw:

int unit = 40;

int count;

Capsules[] agents;

float d;

void setup() {

size(640, 360);

noStroke();

int wideCount = width / unit;

int highCount = height / unit;

count = wideCount * highCount;

agents = new Capsules[count];

d=10;

int index = 0;

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

agents[index++] = new Capsules(random(width),random(height),color(255,0,0),i);

}

}

void draw() {

background(0);

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

agents[i].Default();

}

}

//-----------------------class----------------------------------

class Capsules { //the basic class that defines the chararacteristics of the agents

PVector location;

PVector velocity;

PVector acceleration;

float r; //the radius of the circles-spheres/ agents

float wandertheta;

float maxforce; // Maximum steering force

float maxspeed; // Maximum speed

color fillColor; //differentiation of agent types are based on complementary coloring

int name; // gives an ID - number to each different agent



Capsules(float x, float y, color c, int nam) { //the class constructor

acceleration = new PVector(0,0);

velocity = new PVector(0,0);

location = new PVector(x,y);

r = 6;

wandertheta = 0;

maxspeed = 0.5;

maxforce = 0.05;

fillColor = c;

name = nam;

}



void Default() {

boundaries();

update();

display();

wander();

}

void update() { // Method to update location

velocity.add(acceleration); // Update velocity

velocity.limit(maxspeed); // Limit speed

location.add(velocity); // Reset accelertion to 0 each cycle

acceleration.mult(0);

}

void wander() { // Method that makes the agent float into 2D space

float wanderR = 25; // Radius for our "wander circle"

float wanderD = 200; // Distance for our "wander circle"

float change = 0.05;

wandertheta += random(-change,change); // Randomly change wander theta

// calculating the new location to steer towards on the wander circle

PVector circleloc = velocity.get(); // Start with velocity

circleloc.normalize(); // Normalize to get heading

circleloc.mult(wanderD); // Multiply by distance

circleloc.add(location); // Make it relative to boid's location



float h = velocity.heading2D(); // We need to know the heading to offset wandertheta

PVector circleOffSet = new PVector(wanderR*cos(wandertheta+h),wanderR*sin(wandertheta+h));

PVector target = PVector.add(circleloc,circleOffSet);

seek(target);

}

void applyForce(PVector force) { // Newton's second law; We could add mass here if we want A = F / M

acceleration.add(force);

}

// A method that calculates and applies a steering force towards a target

// STEER = DESIRED MINUS VELOCITY

void seek(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

desired.normalize(); // Normalize desired and scale to maximum speed

desired.mult(maxspeed);

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(maxforce); // Limit to maximum steering force

applyForce(steer);

}



// Method that lowers the speed of the agent by the time he reaches the target - see: "buffer zone"

void arrive(PVector target) {

PVector desired = PVector.sub(target,location); // A vector pointing from the location to the target

float d = desired.mag();

desired.normalize(); // Normalize desired and scale with arbitrary damping within 100 pixels

if (d < 200) {

float m = map(d,0,800,0,4*maxspeed);

desired.mult(m);

} else {

desired.mult(maxspeed);

}

PVector steer = PVector.sub(desired,velocity); // Steering = Desired minus Velocity

steer.limit(5*maxforce); // Limit to maximum steering force

applyForce(steer);

}



void display() { // Draws an ellipse that represents an agent-capsule

fill(fillColor);

stroke(0);

pushMatrix();

translate(location.x, location.y);

ellipse(0, 0, r, r);

popMatrix();

}



//Method that checkes the maximum floating range of the agents

void boundaries() {

PVector desired = null;

if (location.x < d) {

desired = new PVector(maxspeed, velocity.y);

}

else if (location.x > width -d) {

desired = new PVector(-maxspeed, velocity.y);

}

if (location.y < d) {

desired = new PVector(velocity.x, maxspeed);

}

else if (location.y > height-d) {

desired = new PVector(velocity.x, -maxspeed);

}

if (desired != null) {

desired.normalize();

desired.mult(maxspeed);

PVector steer = PVector.sub(desired, velocity);

steer.limit(2*maxforce);

applyForce(steer);

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separate (ArrayList<Capsules> agent) {

float desiredseparation = 4*r; //4*r = separation ONLY for wandering

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsules v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Method that separates the agents from one-another -- see: "buffer zone"

void separateSpecial (ArrayList<Capsules> agent) {

float desiredseparation = r; // r = separation ONLY for clustering

PVector sum = new PVector();

int count = 0;



// For every agent in the system, check if it's too close

for (Capsules v : agent) {

float d = PVector.dist(location, v.location);



// 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(location, v.location);

diff.normalize();

diff.div(d); // Weight by distance

sum.add(diff);

count++; // Keep track of how many

}

}

// Average -- divide by how many

if (count > 0) {

sum.div(count);

sum.normalize(); // Our desired vector is the average scaled to maximum speed

sum.mult(maxspeed);



// Implement Reynolds: Steering = Desired - Velocity

PVector steer = PVector.sub(sum, velocity);

steer.limit(maxforce);

applyForce(steer);

}

}



// Alignment

// For every nearby agent in the system, calculate the average velocity

PVector align (ArrayList<Capsules> agent) {

float neighbordist = 50;

PVector sum = new PVector(0,0);

int count = 0;

for (Capsules v : agent) {

float d = PVector.dist(location,v.location);

if ((d > 0) && (d < neighbordist)) {

sum.add(v.velocity);

count++;

}

}

if (count > 0) {

sum.div((float)count);

sum.normalize();

sum.mult(maxspeed);

PVector steer = PVector.sub(sum,velocity);

steer.limit(maxforce);

return steer;

} else {

return new PVector(0,0);

}

}

}

subclass constructor problem

[9 Replies]
- 02-Dec-2012 02:13 AM
- Forum: Programming Questions
Hey guys!

This is a bit confusing. I have a superclass which looks basically like this:

class Capsule {

PVector location;

PVector velocity;

PVector acceleration;

float r;

float wandertheta;

float maxforce;

float maxspeed;

color fillColor;

int name;

Capsule(float x, float y, color c, int nam) { //the class constructor

acceleration = new PVector(0,0);

velocity = new PVector(0,0);

location = new PVector(x,y);

r = 6;

wandertheta = 0;

maxspeed = 0.5;

maxforce = 0.05;

fillColor = c;

name = nam;

}

and some subclasses that look like this:

class MW1 extends Capsule {

MW1(float x_mw1, float y_mw1, color c_mw1, int nam_mw1) {

super(x_mw1,y_mw1,c_mw1,nam_mw1);

}

when I try to run the code I get the message that:

the constructor "file_name".MW1() is undefined

and a yellow line here:

ArrayList<Capsule> agents = new ArrayList<Capsule>();

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

if (i < 20) agents.add(new MW1());

...

Does anyone know what am I doing wrong? where exactly is the problem with the subclass constructor?

problem with subclasses

[6 Replies]
- 01-Dec-2012 08:31 AM
- Forum: Programming Questions
Hey there!

So I have a superclass called Capsule with a constructor that looks like this:

Capsule(float x, float y, color c, int nam)

Afterwards I created 2 more subclasses:

class MW1 extends Capsule {

MW1() {

super();

}

when I try to run the code I get the message:

"the constructor "file_name".Capsule() is undefined while the line: super(); gets marked like that

I m really new to the program so any halp would be much appreciated. :)

a time loop

[5 Replies]
- 25-Nov-2012 03:36 AM
- Forum: Programming Questions
Hey guys!

I have a simple time-counter that counts seconds and prints them on the panel. 180 sec. represent a day and between these seconds I trigger some events. Here is the general configuration:

...

int time; // a counter for time triggering events

int wait = 1000;

...

void setup() {

time = millis();//store the current time

...

void draw() {

...

//check the difference between now and the previously stored time is greater than the wait interval

if(millis() - time >= wait){

println(time/1000);//if it is, do something

time = millis();//also update the stored time

}

...

if (time/1000>30 && time/1000<90) {

"statement"

}

...etc

the thing is that AFTER the 180 sec. I want to go back to time/1000 = 0 and start counting from the beginning, in order to loop the events.

Does anyone know how am I supposed to do that? I think I might use an int day = 180 and an int loop = 0 (representing the amount of days passed) but I 'm not sure... :(

a problem with a simple timer / counter

[2 Replies]
- 20-Nov-2012 12:47 AM
- Forum: Programming Questions
Hey there! This is a simple timer that counts in seconds infinately. The this is that when it comes to print the seconds on the panel, it does this but in "millis". How can I fix it and print the elapsed time in "seonds"?

here is the code:

int time;

int wait = 1000;

void setup(){

time = millis();//store the current time

}

void draw(){

//check the difference between now and the previously stored time is greater than the wait interval

if(millis() - time >= wait){

println(time);//if it is, do something

time = millis();//also update the stored time

}

}

any help would be much appreciated. :)

problems with timer and triggered events

[9 Replies]
- 09-Nov-2012 04:03 PM
- Forum: Programming Questions
Hey there!

I have a simple script with a circle floating (wandering) in 2D space and one timer that counts hours till milliseconds throughout the animation. I tried to implement a while function inside of which I wanted to make the sphere seek the "mouse" (mouse is the target) and come close to it from the 30th till the 60th second.

while (sw.second()>=30 && sw.second()<=60) {

PVector mouse = new PVector(mouseX, mouseY);

vehicle.seek(mouse);

}

However, it seems that when the timer reaches the 30 sec. the canvas freezes and then it continues from the 60th second and beyond.

Any help? If you need the code or any other info just inform me.

a simple flock configuration and a few problems

[3 Replies]
- 06-Nov-2012 04:42 AM
- Forum: Programming Questions
Hey guys!

I 'm totally new to the entire processing concept so sorry any kind of help here is much appreciated!

I have a simple code here with an ArrayList of 5 circles that sould (normally) attract to each other and come together.

Although there are some problems popping up. Here is the entire configuration:

//main-----------------------------------------------------------------------------------------------------------------------------

capsule[] agents = new capsule[5];

void setup() {

size(300,300);

smooth();



for (int i = 0; i < agents.length; i++) { //create capsule objects

agents[i] = new capsule();

}

}

void draw() {

background(200);



for (int i = 0; i < agents.length; i++) {

agents[i].update(); //Call functions on Capsule object

agents[i].applyForce();

agents[i].seek();

agents[i].arrive();

agents[i].checkEdges();

agents[i].display();

}

}

-------------------------------------------------------------------------------------------------------------------------------------

//class---------------------------------------------------------------------------------------------------------------------------

class capsule {

PVector location;

PVector velocity;

PVector acceleration;



float maxforce;

float maxspeed;

capsule(float x, float y) {

acceleration = new PVector(0,0);

velocity = new PVector(0,0);

location = new PVector(random(1,0),random(0,0));



maxspeed = 4;

maxforce = 0.1;

}

void update() {

velocity.add(acceleration);

velocity.limit(maxspeed);

location.add(velocity);

acceleration.mult(0);

}



void applyForce(PVector force) { //Newton’s second law; we could divide by mass if we wanted.

acceleration.add(force);

}



void seek(PVector target) { //seek steering force algorithm

PVector desired = PVector.sub(target,location);

desired.normalize();

desired.mult(maxspeed);

PVector steer = PVector.sub(desired,velocity);

steer.limit(maxforce);

applyForce(steer);

}



void arrive(PVector target) {

PVector desired = PVector.sub(target,location);

float d = desired.mag(); //The distance is the magnitude of the vector pointing from location to target.

desired.normalize();

if (d < 100) { //If we are closer than 100 pixels...

float m = map(d,0,100,0,maxspeed); //...set the magnitude according to how close we are

desired.mult(m);

} else {

desired.mult(maxspeed); //Otherwise, proceed at maximum speed.

}

PVector steer = PVector.sub(desired,velocity);

steer.limit(maxforce);

applyForce(steer);

}

void display() {

stroke(0);

fill(255);

ellipse(location.x,location.y,20,20);

pushMatrix();

translate(location.x,location.y);

popMatrix();

}

void checkEdges() {

if (location.x > width) {

location.x = 0;

} else if (location.x < 0) {

location.x = width;

}

if (location.y > height) {

location.y = 0;

} else if (location.y < 0) {

location.y = height;

}

}

}

--------------------------------------------------------------------------------------------------------------------------------

the problem is that: the constructor stage_01_vectors_array_steering.capsule() is undefined...

any sollutions?

:)

Activity Trend