Autonomous Behavior: A Processing Compendium New York, Spring 2012 Claus Rytter Bruun De Neergaard
processing compendium
2
Introduction Mine tanker med de heri samlede algoritmiske øvelser er først og fremmest at, forstå hvordan det er at arbejde i en digital proces inden for et kreative felt (kunst og arkitektur). Men det handler også om forståelsen af potentialet i værktøjet og om at se koden eller algoritmen som et ‘materiale’ der kan formes og tilpasses, og om at blive klogere på begrænsningerne hvis ikke den tekniske snilde er tilstrækkelig. Det præsenterede arbejde er en del af resultatet fra et semester i New York, hvor jeg, gennem cirka halvdelen af forløbet har haft work-sessions og diskussioner med både Marius Watz (www. mariuswatz.com) og Brandt Graves (www.thefuturefuture.com) drejende sig om emner som generativ kunst, formidling af digitale øvelser og digital kunstform generelt, algoritmen som materiale og – ikke mindst – digital fabrikation eller fra-digital-til-fysisk. Indledningsvist vil jeg gerne forklare hvordan fascinationen med krativ kodning startede. Forestil dig et rum, ikke nødvendigvis helt defineret i sin afgrænsning, men et stort rum med plads til at manøvrere. Vi indsætter, i dette rum, hundredvis eller tusindvis af entiteter, som hver især er bygget op omkring et, to eller tre regelsæt, og flere variabler til at værdisætte de enkelte regelsæt, samt en sanse-radius. Nu trykker vi på ‘play’-knappen, og ser scenariet udfolde sig. Alle entiteterne bevæger sig i rummet. Alle entiteterne er på ethvert givent tidspunkt opmærksom på alle andre entiteter i rummet. Dog bliver alle entiter uden for entitetens sanse-radius dømt irrelevante. Sker det at, en anden entitet kommer tættere på en sanse-radius, aktiveres et, to eller tre regelsæt. + Det første regelsæt fortæller entiteten, at den skal dreje væk fra alle andre entiteter der befinder sig inden for dens sanse-radius (findes flere entiteter inden for sanseradius, vælg da den gennemsnitligt bedste retning væk fra alle andre). + Det andet regelsæt fortæller entiteten, at den skal styre mod alle andre entiteter der befinder sig inden for dens sanse-radius (findes flere entiteter inden for sanse-radius, vælg da retning af det gennemsnitlige punkt). + Det tredje regelsæt fortæller entiteten, at den skal skal finde samme retning som alle andre entiteter der befinder sig inden for dens sanse-radius (findes flere entiteter inden for sanse-radius, styr da i den gennemsnitlige retning). Nu ser vi, i rummet, at alle entiteter manøvrerer denne fiktive verden, samtidig med konstant at være opmærksom på alle andre entiteter. Hver enste gang en entitet trænger ind i en anden entitets sanse-radius, aktiveres reglerne, og der etableres et forhold mellem de to. Dette forhindrer overfyldte områder, samtidig med at fordre klyngedannelser og fælles retningsmønstre. Sakker en entitet bagud i en klynge, forsvinder den ud af sanse-radius, og vil påtage sig at vandre hvileløst rundt, til den træder ind i en anden sanse-radius. På denne måde er det muligt at simulere uforudsigelige møndstre og adfærd via relativt simple algortimer. Der vil, fra stramt definerede strukturer, vokse selvorganiserende adfærdsmønstre, som vi ikke ville kunne forudsige eller beregne. Grundstenene er de tre regelsæt der definerer interaktionen mellem entiteterne. De følgende sider viser resultater fra den samme algoritme, som skrevet i Processing (www. processing.org), omend med små ændringer ved skift fra to dimensioner til tre dimensioner.
processing compendium
3
class Agent { // constructor (runs only once) Agent() { }
// update calls all other functions void update() { animation(); edges(); display(); }
// update location void animate() { separation(); cohesion(); alignment(); }
// check if agent is outside window void edges() { }
// draw agent void display() { }
// separation, PVector separation() {
see page 5
}
// cohesion, PVector cohesion() { steer(); }
see page 6
// alignment, PVector alignment() {
see page 7
}
// steering PVector steer() { }
processing compendium
4
processing compendium
5
processing compendium
6
processing compendium
7
The building blocks Space Space 1: Two dimensional Space 2: Three dimensional Form Form Form Form Form
1: 2: 3: 4:
Circle Point Line Sphere
Rules Rule 1: Separation Rule 2: Cohesion Rule 3: Alignment
processing compendium
8
Scenario 1 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a point (Form 2) in space. Subsequent patterns of movement based on separation (Rule 1). There are no external relations, only internal relations define the movement of each agent.
processing compendium
9
Scenario 1 = S1 + F2 + R1 // number of agents = 1000; range = 10.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 1194.
Scenario 1 = S1 + F2 + R1 // number of agents = 1000; range = 10.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 756.
processing compendium
10
Scenario 1 = S1 + F2 + R1 // number of agents = 1000; range = 10.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 950.
Scenario 1 = S1 + F2 + R1 // number of agents = 1000; range = 50.0; separation scale = 7.5; cohesion scale = 1.5; alignment scale = 2.5; frame number = 164.
processing compendium
11
Scenario 1 = S1 + F2 + R1 // number of agents = 4000; range = 50.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 27.
Scenario 1 = S1 + F2 + R1 // number of agents = 2000; range = 50.0; separation scale = 7.5; cohesion scale = 1.5; alignment scale = 2.5; frame number = 66.
processing compendium
12
Scenario 1 = S1 + F2 + R1 // number of agents = 4000; range = 50.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 55.
Scenario 1 = S1 + F2 + R1 // number of agents = 4000; range = 50.0; separation scale = 2.0; cohesion scale = 1.5; alignment scale = 2.5; frame number = 86.
processing compendium
13
Scenario 2 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a point (Form 2) in space. Subsequent patterns of movement based on separation (Rule 1) and cohesion (Rule 2). There are no external relations, only internal relations define the movement of each agent.
processing compendium
14
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 1500; range = 150.0; separation scale = 20.0; cohesion scale = 0.5; alignment scale = 3.5; frame number = 120.
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 1500; range = 150.0; separation scale = 5.0; cohesion scale = 10.5; alignment scale = 3.5; frame number = 77.
processing compendium
15
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 2000; range = 350.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 14.
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 500; range = 150.0; separation scale = 2.5; cohesion scale = 2.5; alignment scale = 3.5; frame number = 181.
processing compendium
16
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 2000; range = 350.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 43.
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 2500; range = 150.0; separation scale = 2.5; cohesion scale = 2.5; alignment scale = 3.5; frame number = 23.
processing compendium
17
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 2500; range = 150.0; separation scale = 5.0; cohesion scale = 10.5; alignment scale = 3.5; frame number = 88.
Scenario 2 = S1 + F2 + R1 + R2 // number of agents = 500; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 401.
processing compendium
18
Scenario 3 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a point (Form 2) in space. Subsequent patterns of movement based on cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
19
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 181.
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 213.
processing compendium
20
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 256.
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 1500; range = 150.0; separation scale = 2.5; cohesion scale = 7.5; alignment scale = 1.5; frame number = 144.
processing compendium
21
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 53.
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 1500; range = 150.0; separation scale = 2.5; cohesion scale = 7.5; alignment scale = 3.5; frame number = 62.
processing compendium
22
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 341.
Scenario 3 = S1 + F2 + R2 + R3 // number of agents = 800; range = 150.0; separation scale = 2.5; cohesion scale = 5.5; alignment scale = 3.5; frame number = 125.
processing compendium
23
Scenario 4 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a point (Form 2) in space. Subsequent patterns of movement based on separation (Rule 1), cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
24
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 1800; range = 50.0; separation scale = 1.5; cohesion scale = 5.5; alignment scale = 7.5; frame number = 56.
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 1800; range = 50.0; separation scale = 1.5; cohesion scale = 5.5; alignment scale = 7.5; frame number = 20.
processing compendium
25
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 50.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 83.
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 250.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 101.
processing compendium
26
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 250.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 195.
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 250.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 22.
processing compendium
27
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 50.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 160.
Scenario 4 = S1 + F2 + R1 + R2 + R3 // number of agents = 800; range = 50.0; separation scale = 1.5; cohesion scale = 7.5; alignment scale = 5.5; frame number = 23.
processing compendium
28
Scenario 5 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a circle (Form 1) in space. Subsequent patterns of movement based on separation (Rule 1), cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
29
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 1000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 1.5; frame number = 157.
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 1000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 1.5; frame number = 20.
processing compendium
30
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 1.5; frame number = 50.
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 16.
processing compendium
31
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 30.
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 6.
processing compendium
32
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 60.
Scenario 5 = S1 + F1 + R1 + R2 + R3 // number of agents = 2000; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 92.
processing compendium
33
Scenario 6 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Each agent is visualized as a circle (Form 1) in space. All agents located within a defined range of another agent is visually connected by a line (Form 3). Subsequent patterns of movement based on separation (Rule 1), cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
34
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 107.
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 35.
processing compendium
35
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 200; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 108.
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 200; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 17.
processing compendium
36
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 111.
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 200; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 187.
processing compendium
37
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 70.
Scenario 6 = S1 + F1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 8.
processing compendium
38
Scenario 7 Defined number of agents in a two dimensional space (Space 1), random point of initiation. Agents are not visualized, only agents located within a defined range of another agent is visually connected by a line (Form 3). Subsequent patterns of movement based on separation (Rule 1), cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
39
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 122.
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 116.
processing compendium
40
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 51.
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 400; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 51.
processing compendium
41
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 336.
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 422.
processing compendium
42
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 51.
Scenario 7 = S1 + F3 + R1 + R2 + R3 // number of agents = 300; range = 125.0; separation scale = 0.5; cohesion scale = 7.5; alignment scale = 10.5; frame number = 523.
processing compendium
43
Scenario 8 Defined number of agents in a three dimensional space (Space 2), random point of initiation. Each agent is visualized as a sphere (Form 4) in space. All agents located within a defined range of another agent is visually connected by a line (Form 3). Subsequent patterns of movement based on separation (Rule 1), cohesion (Rule 2) and alignment (Rule 3). There are no external relations, only internal relations define the movement of each agent.
processing compendium
44
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 1000; range = 50.0; separation scale = 30.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 126.
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 1000; range = 50.0; separation scale = 30.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 203.
processing compendium
45
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 48.
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 85.
processing compendium
46
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 75.
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 103.
processing compendium
47
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 236.
Scenario 8 = S2 + F3 + F4 + R1 + R2 + R3 // number of agents = 500; range = 150.0; separation scale = 1.0; cohesion scale = 7.5; alignment scale = 13.5; frame number = 134.
processing compendium
48
The algorithm 001 002 003 004 005 006 007 008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106
// VARS /////////////////////////////////////////////////////////////////////// int na = 300; // number of agents float range = 125.0; // range of each agent float sepscale = 0.5; // separation scale float aliscale = 10.5; // alignment scale float cohscale = 7.5; // cohesion scale color acolor = color(100); // agent color float aradius = 1.5; // agent size boolean connect = true;
// determins if connections are drawn
ArrayList agents = new ArrayList();
// an ArrayList to store all agents
// SETUP ///////////////////////////////////////////////////////////////////// void setup() { size(1189, 841); background(230); smooth(); ellipseMode(CENTER);
}
for (int i = 0; i < na; i++) { agents.add(new Agent()); }
// DRAW ////////////////////////////////////////////////////////////////////// void draw() { // create trail for each agent noStroke(); fill(230, 100); rect(-1, -1, width+1, height+1); // calling functions of all of the objects in the ArrayList for (int i = 0; i < agents.size(); i++) { Agent a = (Agent) agents.get(i); a.update(agents); }
}
// draw connections if (connect == true) { for (int i = 0; i < agents.size(); i++) { Agent ca = (Agent) agents.get(i); for (int j = i; j < agents.size(); j++) { Agent oa = (Agent) agents.get(j); if (dist(ca.loc.x, ca.loc.y, oa.loc.x, oa.loc.y) < (range/2)) { stroke(150); strokeWeight(0.5); line(ca.loc.x, ca.loc.y, oa.loc.x, oa.loc.y); } } } }
// KEYPRESSED //////////////////////////////////////////////////////////////// void keyPressed() { // save tif-file if (key == ‘i’) { save(“S7/” + “_na” + na + “_ra” + range + “_sep” + sepscale + “_ali” + aliscale + “_coh” + cohscale + “_fr” + frameCount + “.tif”); }
}
// enable or disable connections if (key == ‘1’) { connect = true; } else if (key == ‘2’) { connect = false; }
class Agent { PVector loc, vel, acc, ploc; float maxforce, maxvel; Agent() { // three vectors to describe agent location, velocity and acceleration loc = new PVector(random(0, width), random(0, height)); vel = new PVector(0, 0); acc = new PVector(0, 0); ploc = loc;
}
// maxforce makes sure that not all agents move with same speed - it creates variation maxforce = random(0.10, 0.75); maxvel = random(3.5, 10.5);
// UPDATE ////////////////////////////////////////////////////////////////// void update(ArrayList pop) { // update the movement animate(pop); // update position vel.add(acc); vel.limit(maxvel);
// add acceleration to velocity (increase speed) // make sure there is a movement speed limit
processing compendium
49
The algorithm (cont.) 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 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
loc.add(vel); acc.set(0, 0, 0);
}
// add velocity to location // make sure we set acceleration back to zero
// standard update functions edges(); display();
// ANIMATE ///////////////////////////////////////////////////////////////// void animate(ArrayList pop) { // calculate the steering vectors PVector sep = separation(pop); PVector coh = cohesion(pop); PVector ali = alignment(pop); // scale all vectors sep.mult(sepscale); coh.mult(cohscale); ali.mult(aliscale);
}
// add all steering vectors to movement acc.add(sep); acc.add(coh); acc.add(ali);
// EDGES /////////////////////////////////////////////////////////////////// void edges() { if (loc.x > width) { loc.x = 0; } else if (loc.x < 0) { loc.x = width; }
}
if (loc.y > height) { loc.y = 0; } else if (loc.y < 0) { loc.y = height; }
// DISPLAY ///////////////////////////////////////////////////////////////// void display() { noFill(); strokeWeight(0.1); stroke(acolor); //ellipse(loc.x, loc.y, maxvel*8.25, maxvel*8.25); //line(ploc.x, ploc.y, loc.x, loc.y); //point(loc.x, loc.y); } // RULE 1 - SEPARATION ///////////////////////////////////////////////////// /* Separation its range. same range separation */
tells the current agent to avoid the neighbors that find themselves within Separation will effectively prevent â&#x20AC;&#x2DC;overcrowdingâ&#x20AC;&#x2122;. Generally we use the variable for all steering behaviors, however, we decrease the range of to ensure cohesion can occur (range/3).
PVector separation(ArrayList pop) { PVector sum = new PVector(); int n = 0; for (int i = 0; i < pop.size(); i++) { Agent a = (Agent) pop.get(i); float d = loc.dist(a.loc);
}
// vector to return // counter
// dist from agent(i) to all other agents
// if dist is within range, and larger than zero (zero being itself) if ((d > 0) && (d < range/3)) { // calculate vector pointing away from neighbor(s) sum = loc.get(); sum.sub(a.loc); sum.normalize(); sum.mult(1/d); n++; }
// calculate average (based on how many agents within range) if (n > 0) { sum.mult(1/float(n)); } }
return sum;
// return the vector
// RULE 2 - COHESION /////////////////////////////////////////////////////// /* Cohesion is the steering towards the average position of all the population members that find themselves within the defined range of the current agent. The result of cohesion is that the population begins to show the effect of group behavior or clustering, imitating that of living creatures. It is often only in combination with rule 1, separation, that we see the full effect of cohesion. Without separation, the agents will cluster up tightly and, at least visually, merge. */ PVector cohesion(ArrayList pop) { PVector sum = new PVector(); int n = 0;
// vector to return // counter
for (int i = 0; i < pop.size(); i++) {
processing compendium
50
The algorithm (cont.) 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 289 290 291 292 293 294 295 296 297 298 299 300 301
Agent a = (Agent) pop.get(i); float d = loc.dist(a.loc);
}
// dist from agent(i) to all other agents
// if dist is within range, and larger than zero (zero being itself) if ((d > 0) && (d < range)) { sum.add(a.loc); n++; }
// calculate average (based on how many agents within range) if (n > 0) { sum.mult(1/float(n)); sum = steer(sum, true); // sum = result of steer()-function }
}
return sum;
// return the vector
// RULE 3 - ALIGNMENT ////////////////////////////////////////////////////// /* Alignment is the averaging of all the directions (velocities) of agents within a given range of the current agent. The result of alignment is that the population begins to flow in a similar manner, resulting in a more recognizeable behavioral pattern. The more we emphasize the alignment, the greater are the chances of creating ‘streams’ of agents, that move in same direction within a certain ‘flow’. */ PVector alignment(ArrayList pop) { PVector sum = new PVector(); int n = 0; for (int i = 0; i < pop.size(); i++) { Agent a = (Agent) pop.get(i); float d = loc.dist(a.loc);
// vector to return // counter
}
// dist from agent(i) to all other agents
// if dist is within range, and larger than zero (zero being itself) if ((d > 0) && (d < range)) { sum.add(a.vel); n++; }
// calculate average (based on how many agents within range) if (n > 0) { sum.mult(1/float(n)); sum.limit(maxforce); }
}
return sum;
// return the vector
// (RULE 4) - STEER //////////////////////////////////////////////////////// /* Steering calculates a steering vector towards a target - the steer function takes a second argument, and if true, it slows down as it approaches the target. */ PVector steer(PVector target, boolean slow) { PVector steerforce; // the steering vector target.sub(loc); float m = target.mag(); // calc the magnitude of the vector // if dist is within range, and larger than zero (zero being itself) if (m > 0 && m < range) { target.normalize(); // calc deceleration if slow is on, else, just continue if ((slow == true) && (m < (range/2))) { target.mult(maxvel * (range/width)); } else { target.mult(maxvel); } target.sub(vel); steerforce = target.get(); steerforce.limit(maxforce);
} else { steerforce = new PVector(0, 0); }
}
}
return steerforce;
// return the vector
processing compendium
51