hi all,
I've noticed that since the last update every time I run a sketch the following message is displayed:
" java_home: unrecognized option `--request' "
Although the sketch runs without problems I wonder what the reason is.
If anyone could provide an explanation I would greatly appreciate it.

PS. I'm not sure if I should be posting this question on this forum

Hello,

I'm trying to get my head around inheritance. All goes well up to the point where I create an ArrayList of objects and need to provide the right argument(s) to get all of its members methods properly initiated.

The  'Bumper' class  has the method separate. i don't know where i should be calling this method from and how to provide the ArrayList it is expecting. I'm assuming i should be doing it from the 'Universe' class, since the superclass of 'Bumper' is being called from there.

Hopefully the question and code are clear.

any comments/reference/help will be appreciated.
Thanks in advance

tzl

1. Universe universe;
2. int numBoids = 100;
3. void setup() {
4.   size(600, 400);
5.   smooth();
6.   universe = new Universe();
7.   for (int i = 0; i<numBoids; i++)
8.     universe.add(new Agent(universe));
9.   for (int i = 0; i<(numBoids*2); i++)
10.     universe.add(new Bumper(universe));
11. }
12. void draw() {
13.   background(255);
14.   universe.update();
15.   universe.display();
16. }

1. class Agent extends Element {
2.   Agent(Universe universe) {
3.     super(universe);
4.   }
5.   void update() {
6.     super.update();
7.     keepInside(universe, 0.5);
8.   }
9.   void keepInside(Universe universe, float efficiency) {
10.     // efficiency ~ 10 : boids immediately rejected
11.     // efficiency ~ .1  : boids slowly change direction
12.     float maxX = universe.x + universe.w;
13.     float maxY = universe.y + universe.h;
14.     // When a boid approach a side, an opposite vector is added to velocity (bounce)
15.     PVector v = new PVector();
16.     if (loc.x  <= universe.x + rad )       v.x = (universe.x + rad  - loc.x) * efficiency;
17.     else if (loc.x >= maxX - rad) v.x = (maxX - rad- loc.x) * efficiency;
18.     if (loc.y<= universe.y + rad)       v.y = (universe.y + rad- loc.y) * efficiency;
19.     else if (loc.y >= maxY - rad) v.y = (maxY- rad  - loc.y) * efficiency;
20.     vel.add(v);
21.   }
22.   void display() {
23.     super.display();
24.     noFill();
25.     stroke(5);
26.     ellipseMode(CENTER);
27.     ellipse(loc.x, loc.y, rad, rad);
28.   }
29. }

1. class Bumper extends Element {
2.   float maxspeed;
3.   float maxforce;
4.   Bumper(Universe universe) {
5.     super(universe);
6.     maxspeed = 0.75;
7.     maxforce = 0.25;
8.   }
9.   void applyForce(PVector force) {
10.     // We could add mass here if we want A = F / M
11.     acc.add(force);
12.   }
13.   // Separation
14.   // Method checks for nearby vehicles and steers away
15.   void separate (ArrayList<Bumper> bumpers) {
16.     float desiredseparation = rad*2;
17.     PVector sum = new PVector();
18.     int count = 0;
19.     // For every boid in the system, check if it's too close
20.     for (Bumper other : bumpers) {
21.       float d = PVector.dist(loc, other.loc);
22.       // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
23.       if ((d > 0) && (d < desiredseparation)) {
24.         // Calculate vector pointing away from neighbor
25.         PVector diff = PVector.sub(loc, other.loc);
26.         diff.normalize();
27.         diff.div(d);        // Weight by distance
28.         sum.add(diff);
29.         count++;            // Keep track of how many
30.       }
31.     }
32.     // Average -- divide by how many
33.     if (count > 0) {
34.       sum.div(count);
35.       // Our desired vector is the average scaled to maximum speed
36.       sum.normalize();
37.       sum.mult(maxspeed);
38.       // Implement Reynolds: Steering = Desired - Velocity
39.       PVector steer = PVector.sub(sum, vel);
40.       steer.limit(maxforce);
41.       applyForce(steer);
42.     }
43.   }
44.   void update() {
45.     super.update();
46.     // Limit speed
47.     vel.limit(maxspeed);
48.     loc.add(vel);
49.     // Reset accelertion to 0 each cycle
50.     acc.mult(0);
51.   }
52.   void display() {
53.     noStroke();
54.     fill(255, 20, 36);
55.     ellipseMode(CENTER);
56.     ellipse(loc.x, loc.y, rad, rad);
57.   }
58. }

1. class Element {
2.   Universe universe;
3.   PVector loc, vel, acc;
4.   float rad;
5.   Element(Universe universe)
6.   {
7.     this(universe, universe.randomPos());
8.   }
9.   Element(Universe universe, PVector loc)
10.   {
11.     this.universe = universe;
12.     this.loc = loc;
13.     vel = new PVector(random(-2, 2), random(-2, 2));
14.     acc = new PVector(0, 0);
15.     rad = random(4, 5);
16.   }
17.   void display() {
18.   }
19.  
20.   void update() {
21.     loc.add(vel);
22.   }
23.  
24. }

1. class Universe {
2.   int x, y, w, h;
3.   ArrayList <Element> element;
4.   Universe() {
5.     x = 0;
6.     y = 0;
7.     w = width;
8.     h = height;
9.     element = new ArrayList<Element>();
10.   }
11.   PVector randomPos() {
12.     return new PVector(random(x, x+w), random(y, y+h));
13.   }
14.   Element getIt(int i)
15.   {
16.     return (Element)element.get(i);
17.   }
18.   void add(Element e)
19.   {
20.     element.add(e);
21.   }
22.   void add(Element e, int n)
23.   {
24.     for (int i=0; i < n; i++)
25.       element.add(e);
26.   }
27.   void update() {
28.     for (int i = 0; i<element.size(); i++) {
29.       Element el = (Element) element.get(i);
30.       el.update();
31.     }
32.   }
33.   void display() {
34.     for (int i = 0; i<element.size(); i++)
35.       ((Element)getIt(i)).display();
36.   }
37. }

Hi everyone,

Came across a couple of examples where the class Float (not float) is used,
After reading the java reference for Float, I didn't quite understand why it is convenient to use it.

Could anyone pls provide a quick explanation and, if time allows, an example of when it may be handy to use it?

thanks..

tzl