-
Notifications
You must be signed in to change notification settings - Fork 0
/
Boid.pde
196 lines (180 loc) · 6.07 KB
/
Boid.pde
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
// The Boid class
class Boid {
Flock flock;
PVector location;
PVector velocity;
PVector acceleration;
float r;
color c;
// maxspeed and maxforce are now universally controlled by Flock
Boid(float x, float y, Flock f) {
flock = f;
location = new PVector(x, y);
//float angle = random(TWO_PI);
//velocity = new PVector(cos(angle), sin(angle)); // will work in Processing.js
velocity = PVector.random2D();
acceleration = PVector.random2D();//new PVector(0, 0);
r = flock.default_size + random(-flock.default_size*0.5, flock.default_size*0.5);
c = lerpColor(color(0,255,255), color(0,0,255), random(0,1));
// 2nd color: color(0,145,255) more subtle
// color(0,0,255) more variation
}
void run() {
flock();
update();
borders();
render();
}
void applyForce(PVector force) {
// We could add mass here if we want A = F / M
acceleration.add(force);
}
// We accumulate a new acceleration each time based on three rules
void flock() {
PVector sep = separate(); // Separation
PVector ali = align(); // Alignment
PVector coh = cohesion(); // Cohesion
// Arbitrarily weight these forces
sep.mult(1.5);
ali.mult(1.0);
coh.mult(1.0);
// Add the force vectors to acceleration
applyForce(sep);
applyForce(ali);
applyForce(coh);
applyForce(flock.flow_dir);
// Apply human control
acceleration.mult(1 + flock.flow_speed + flock.additional_speed);
}
// Method to update location
void update() {
velocity.add(acceleration); // a -> v; Update velocity
velocity.limit(flock.maxspeed); // Limit speed
location.add(velocity); // v -> x
acceleration.mult(0); // Reset accelertion to 0 each cycle
}
// A method that calculates and applies a steering force towards a target
// STEER = DESIRED MINUS VELOCITY
PVector seek(PVector target) {
PVector desired = PVector.sub(target, location); // A vector pointing from the location to the target
// Scale to maximum speed
//desired.normalize();
//desired.mult(flock.maxspeed); // will work in Processing.js
desired.setMag(flock.maxspeed);
// Steering = Desired minus Velocity
PVector steer = PVector.sub(desired, velocity);
steer.limit(flock.maxforce); // Limit to maximum steering force
return steer;
}
void render() {
// Draw a triangle rotated in the direction of velocity
//float theta = velocity.heading2D() + radians(90); // will work in Processing.js
float theta = velocity.heading() + radians(90);
fill(c);
noStroke();
pushMatrix();
translate(location.x, location.y);
rotate(theta);
if(flock.shape == 0) {
beginShape(TRIANGLES);
vertex(0, -r*flock.size_multiplier*2);
vertex(-r*flock.size_multiplier*0.5, 0);
vertex(r*flock.size_multiplier*0.5, 0);
endShape();
}
else if(flock.shape == 1) {
ellipse(0, 0, r*flock.size_multiplier, r*flock.size_multiplier);
}
else if(flock.shape == 2) {
shape(bird0, 0, 0, 64, 64);
}
popMatrix();
}
// Wraparound
void borders() {
if (location.x < -r*flock.size_multiplier) location.x = width+r*flock.size_multiplier;
if (location.y < -r*flock.size_multiplier) location.y = height+r*flock.size_multiplier;
if (location.x > width+r*flock.size_multiplier) location.x = -r*flock.size_multiplier;
if (location.y > height+r*flock.size_multiplier) location.y = -r*flock.size_multiplier;
}
// Separation
// Method checks for nearby boids and steers away
PVector separate() {
float desiredseparation = r*flock.size_multiplier*flock.seperation_multiplier;
PVector steer = new PVector(0, 0, 0);
int count = 0;
// For every boid in the system, check if it's too close
for (Boid other : flock.boids) {
float d = PVector.dist(location, other.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, other.location);
diff.normalize();
diff.div(d); // Weight by distance
steer.add(diff);
count++; // Keep track of how many
}
}
// Average -- divide by how many
if (count > 0) {
steer.div((float)count);
}
// As long as the vector is greater than 0
if (steer.mag() > 0) {
// Implement Reynolds: Steering = Desired - Velocity
//steer.normalize();
//steer.mult(flock.maxspeed); // will work in Processing.js
steer.setMag(flock.maxspeed);
steer.sub(velocity);
steer.limit(flock.maxforce);
}
return steer;
}
// Alignment
// For every nearby boid in the system, calculate the average velocity
PVector align() {
PVector sum = new PVector(0, 0);
int count = 0;
for (Boid other : flock.boids) {
float d = PVector.dist(location, other.location);
if ((d > 0) && (d < flock.neighbordist)) {
sum.add(other.velocity);
count++;
}
}
if (count > 0) {
sum.div((float)count);
// Implement Reynolds: Steering = Desired - Velocity
//sum.normalize();
//sum.mult(flock.maxspeed);
sum.setMag(flock.maxspeed); // will work in Processing.js
PVector steer = PVector.sub(sum, velocity);
steer.limit(flock.maxforce);
return steer;
}
else {
return new PVector(0, 0);
}
}
// Cohesion
// For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
PVector cohesion() {
PVector sum = new PVector(0, 0); // Start with empty vector to accumulate all locations
int count = 0;
for (Boid other : flock.boids) {
float d = PVector.dist(location, other.location);
if ((d > 0) && (d < flock.neighbordist)) {
sum.add(other.location); // Add location
count++;
}
}
if (count > 0) {
sum.div(count);
return seek(sum); // Steer towards the location
}
else {
return new PVector(0, 0);
}
}
}