And I would like to know what if I have different attract point? Now the program are attract all balls to center, but if there are three or more point as the attractor? Let say if balls are 1-10(in the arraylist number) will attract to point one.....and so on.

Thank you very much!!You already help me a lot!!!Thank you!!!

I hate math actually-_- But math really needed in programming. I have to understand what they are calculating abt, then I can be able to use it. Thanks for those website, I will keep reading those sites.:)

I have seen the pic in your tumblr, those pic are beautiful@@ I love things like ball, and those colorful ball come together really beautiful!! Those triangles are also amazing, you have done something about the alignment of those triangles right? They form a great shape when they come together!!!

Btw, I have read your code again today, and I would like to ask " for (PVector p : targets) " this line, I don't understand it. Is it a for loop or..??

Thank you so much!!!

loc = new PVector(random(10,20), random(10,20));

Also, I have added this function on the code(which is your code actually), but it is a little bit wried when the program start-_-. I guess is the starting position wrong, so have this result...?Can you tell how can I improve it? (I think balls can generate at the center, or 0,0 is fine, but now is just like error in the program-0-)

2. ArrayList <Ball> balls = new ArrayList <Ball> ();
3. ArrayList <PVector> targets = new ArrayList <PVector> ();
4.  
5. int numBalls = 750;
6. float friction = -0.9;
7. float spring = 0.025;
8. float damp = 0.99;
9.  
10. void setup() {
11.   size(1280, 720);
12.   smooth();
13.   reset();
14. }
15.  
16. void draw() {
17.   background(255);
18.   for (Ball b : balls) {
19.     b.update();
20.     b.display();
21.   }
22.   noFill();
23.   stroke(0);
24.   for (PVector p : targets) {
25.     ellipse(p.x, p.y, 100, 100);
26.   }
27. }
28.  
29. void keyPressed() {
30.   if (key == ' ') { reset(); }
31. }
32.  
33. void reset() {
34.   targets.clear();
35.   balls.clear();
36.   PVector target = new PVector();
37.   for (int i=0; i<numBalls; i++) {
38.     if (iP==0) { target = randomTarget(); targets.add(target); }
39.     balls.add(new Ball(target));
40.   }
41. }
42.  
43. PVector randomTarget() {
44.   PVector t = new PVector(random(60, width-60), random(60, height-60));
45.   while (withinDistance(t, 150)) {
46.     t = new PVector(random(60, width-60), random(60, height-60));
47.   }
48.   return t;
49. }
50.  
51. boolean withinDistance(PVector v, float distance) {
52.   for (PVector p : targets) {
53.     if (p.dist(v) < distance) {
54.       return true;
55.     }
56.   }
57.   return false;
58. }
59.  
60. class Ball {
61.   float diameter;
62.   PVector loc, vel, target;
63.   float centerSpeed;
64.   int id;
65.   
66.   Ball(PVector t) {
67.     id = balls.size();
68.     diameter = random(5, 25);
69.     loc = new PVector(random(10, 10), random(10, 10));
70.     while (loc.mag() < 1500) { loc.mult(10); }
71.     vel = new PVector();
72.     centerSpeed = random(0.005, 0.01);
73.     target = t.get();
74.   }
75.   
76.   void update() {
77.     ballCollision();
78.     move();
79.     centralize();
80.     vel.mult(damp);
81.     loc.add(vel);
82.   }
83.   
84.   void display() {
85.     color c = color((loc.x+id) % 255, (loc.y+id) % 255, (125+id)%5);
86.     noStroke();
87.     fill(c);
88.     ellipse(loc.x, loc.y, diameter, diameter);
89.   }
90.   
91.   void centralize() {
92.     PVector dif = PVector.sub(target, loc);
93.     dif.mult(centerSpeed);
94.     loc.add(dif);
95.   }
96.   
97.   void ballCollision() {
98.     for (int i=id+1; i<balls.size(); i++) {
99.       Ball other = balls.get(i);
100.       float distance = PVector.dist(other.loc, loc);
101.       float minDist = other.diameter/2 + diameter/2;
102.       if (distance < minDist) {
103.         PVector dif = PVector.sub(other.loc, loc);
104.         float angle = atan2(dif.y, dif.x);
105.         float targetX = loc.x + cos(angle) * minDist;
106.         float targetY = loc.y + sin(angle) * minDist;
107.         float ax = (targetX - other.loc.x) * spring;
108.         float ay = (targetY - other.loc.y) * spring;
109.         vel.x -= ax;
110.         vel.y -= ay;
111.         other.vel.x += ax;
112.         other.vel.y += ay;
113.       }
114.     }   
115.   }
116.  void move() {
117. 
     
118. 
     
119.     loc.x += vel.x;
120. 
     
121.     loc.y += vel.y;
122. 
     
123.     if (loc.x + diameter/2 > width) {
124. 
     
125.       loc.x = width - diameter/2;
126. 
     
127.       vel.x += -0.1; 
128. 
     
129.     }
130. 
     
131.     else if (loc.x - diameter/2 < 0) {
132. 
     
133.       loc.x = diameter/2;
134. 
     
135.       vel.x *= -0.1;
136. 
     
137.     }
138. 
     
139.     if (loc.y + diameter/2 > height) {
140. 
     
141.       loc.y = height - diameter/2;
142. 
     
143.       vel.y *= -0.1; 
144. 
     
145.     } 
146. 
     
147.     else if (loc.y - diameter/2 < 0) {
148. 
     
149.       loc.y = diameter/2;
150. 
     
151.       vel.y *= -0.1;
152. 
     
153.     }
154. 
     
155.   }
156.   
157.   
158.   
159. }