Processing: Flocking

This is the Processing code for a flocking algorithm as covered during a workshop on 2/6/2012.

The code used for this example is based on the structure used by Kokkugia (www.kokkugia.com) for it's agent based work. The fall off and range structure is based on Ian Couzin's work (http://icouzin.princeton.edu/) as outlined by Robert Hodgins for a Cinder tutorial on flocking (http://libcinder.org/docs/v0.8.3/hello_cinder.html).

Tab 1(flock):

1. int agentCount = 1000;
2. ArrayList agents;
3. 
   
4. void setup(){
5. smooth();
6. size(1280,720);
7. agents = new ArrayList();
8. for(int i = 0; i < agentCount; i++){
9. PVector startPos = new PVector(random(0,width), random(0,height));
10. PVector startVel = new PVector(random(-1, 1), random(-1,1));
11. startVel.normalize();
12. float startRad = random(2,10);
13. agent a = new agent(startPos, startVel, startRad);
14. agents.add(a);
15. }
16. }
17. 
    
18. void draw(){
19. background(255);
20. for(int i = 0; i < agents.size(); i++){
21. agent a = (agent) agents.get(i);
22. a.update();
23. //a.render();
24. }
25. 
    
26. for(int i = 0; i < agents.size(); i++){
27. agent a = (agent) agents.get(i);
28. // a.update();
29. a.render();
30. }
31. 
    
32. for(int i = 0; i< agents.size(); i++){
33. agent a = (agent) agents.get(i);
34. // a.update();
35. a.renderE();
36. }
37. 
    
38. saveFrame();
39. 
    
40. if(frameCount > 1000){
41. exit();
42. }
43. }

Tab 2: agents

2. class agent{
3. float rad;
4. PVector pos;
5. PVector vel;
6. float range;
7. float lowThresh;
8. float highThresh;
9. 
   
10. agent(PVector _pos, PVector _vel, float _rad){
11. rad = _rad;
12. pos = _pos;
13. vel = _vel;
14. //set values for range here. range is overall distance, and the thresh variables say what percent
15. //of that range we cut off for the different functions.
16. range = 60;
17. lowThresh = .40;
18. highThresh = .60;
19. }
20. 
    
21. void update(){
23. PVector acc = new PVector();
24. //vel = new PVector();
25. PVector coh = cohesion();
26. PVector avd = avoid();
27. PVector ali = align();
28. 
    
29. //adjust the strengths of the behaviors here
30. coh.mult(.3);
31. avd.mult(1);
32. ali.mult(1);
33. 
    
34. acc.add(coh);
35. acc.add(avd);
36. acc.add(ali);
37. 
    
38. vel.add(acc);
39. vel.limit(2);
40. pos.add(vel);
41. borders();
42. }
43. 
    
44. void borders(){
45. if(pos.x < 0){
46. pos.x = width;
47. }
48. if(pos.y < 0){
49. pos.y = height;
50. }
51. if(pos.x > width){
52. pos.x = 0;
53. }
54. if(pos.y > height){
55. pos.y = 0;
56. }
57. }
58. 
    
59. PVector align(){
60. PVector sum = new PVector();
61. float threshDelta = highThresh - lowThresh;
62. 
    
63. for(int i = 0; i < agents.size(); i++){
64. agent other = (agent) agents.get(i);
65. float dis = pos.dist(other.pos);
66. float percent = pow(dis,2)/pow(range,2);
67. 
    
68. if(percent < highThresh && dis > lowThresh){
69. percent = (percent - lowThresh)/threshDelta;
70. float scalar = (.5-cos(percent*2*PI)*.5 + .5) *.1;
71. PVector temp = other.vel.get();
72. temp.normalize();
73. temp.mult(scalar);
74. sum.add(temp);
75. }
76. }
77. return sum;
78. }
79. 
    
80. //this makes agents avoid each other
81. PVector avoid(){
82. PVector sum = new PVector();
83. 
    
84. for(int i = 0; i < agents.size(); i++){
85. agent other = (agent) agents.get(i);
86. float dis = pos.dist(other.pos);
87. dis = pow(dis,2);
88. float percent = dis/pow(range,2);
89. 
    
90. if(dis >0 && percent < lowThresh){
91. float scalar = (lowThresh/ percent - 1)*.01;
92. PVector temp = pos.get();
93. temp.sub(other.pos);
94. temp.normalize();
95. temp.mult(scalar);
96. sum.add(temp);
97. }
98. }
99. return sum;
100. }
101. 
     
102. PVector cohesion(){
103. PVector sum = new PVector();
104. float threshDelta = 1-highThresh;
106. for(int i = 0; i < agents.size(); i++){
107. agent other = (agent) agents.get(i);
108. float dis = pos.dist(other.pos);
109. float percent = pow(dis,2)/( pow(range,2));
111. if(percent > highThresh && percent <= 1){
112. percent = (percent - highThresh)/threshDelta;
113. float scalar = (.5- cos(percent*PI*2)*.5 +.5)*.01;
114. PVector temp = other.pos.get();
115. temp.sub(pos);
116. temp.normalize();
117. temp.mult(scalar);
118. sum.add(temp);
119. }
120. }
121. return sum;
122. }
123. 
     
124. void render(){
125. float closeDist = 99999;
126. strokeWeight(.01);
127. stroke(150);
128. PVector target = new PVector();
129. 
     
130. for(int i = 0; i < agents.size(); i++){
131. agent other = (agent) agents.get(i);
132. float tempDist = pos.dist(other.pos);
133. 
     
134. if(tempDist < .5*range && tempDist > 0){
135. line(pos.x, pos.y, other.pos.x, other.pos.y);
136. }
137. }
138. }
139. 
     
140. void renderE(){
141. fill(0, 0,0);
142. // stroke(150,0,0);
143. noStroke();
144. ellipse(pos.x, pos.y, rad, rad);
145. }
146. }