Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

[diderot] View of /examples/boids/boids.diderot
 [diderot] / examples / boids / boids.diderot

# View of /examples/boids/boids.diderot

Tue Mar 12 23:58:04 2013 UTC (8 years, 8 months ago) by lamonts
File size: 4001 byte(s)
`Fixed the sepeartion bug where boids were always on top of each other`
```/*! \file flock.diderot
*
* \author Lamont Samuels
*
* This example is an implementation of Chris Reynolds Boids algorithm. It represents an example of using Spatial communication
*/
/*
* COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
*/
int numBoids = length(initVelocities)/2;
int DESIRED_SEPARTION = 30;
int MAX_SPEED = 2;
real MAX_FORCE = 0.05;
real boundsFactor = 10.0;
input int width;
input int height;
int NORTH = 0;
int SOUTH  = 1;
int WEST = 2;
int EAST =  3;
real threshold = 0.02;

vec2 xDom = [0,width];
vec2 yDom = [height,0];

real xSamples = floor((xDom[1] - xDom[0])/cellSize);
real ySamples = floor((yDom[0] - yDom[1])/cellSize);

vec4 qWinDim = [xDom[0],xDom[1],yDom[0],yDom[1]];
vec2 qGridDim = [xSamples ,ySamples];
vec2 qCellDim = [cellSize,cellSize];

strand Boid(int i,real vx, real vy, real px, real py) {
vec2 pos = [px,py];
vec2 vel = [vx,vy];
int id = i;
output vec4 boidInfo = [pos[0],pos[1],vel[0],vel[1]];
update {

vec2 cohereVec = [0.0,0.0];
vec2 alignVec = [0.0,0.0];
vec2 seperateVec = [0.0,0.0];
vec4 wrapDimensions = [-boundsFactor,
height + boundsFactor,
-boundsFactor,
width + boundsFactor];
int count = 0;
int count2 = 0;
real d  =  |pos - neighbor.pos|;
cohereVec += neighbor.pos;
alignVec += neighbor.vel;
count+=1;

if(d < DESIRED_SEPARTION) {
seperateVec = seperateVec + (normalize(pos-neighbor.pos)/d);
count2+=1;
}
}

if(count > 0) {
cohereVec /= real(count);
alignVec /= real(count);
}
if(count2 > 0) {
seperateVec /= real(count2);
}

real isZero = alignVec • alignVec;

// limit the force
if ( isZero != 0 && |alignVec| > MAX_FORCE) {
alignVec = normalize(alignVec);
alignVec *= MAX_FORCE;
}

vec2 diff = cohereVec - pos;
isZero = cohereVec • cohereVec;

if(|diff| > 0 && isZero != 0){

cohereVec = normalize(cohereVec);

if(|diff| < 100.0) {
cohereVec *= (MAX_SPEED*(|diff|/100.0));
}else {
cohereVec *= MAX_SPEED;
}

cohereVec -= vel;

// limit the force
if (|cohereVec| > MAX_FORCE) {
cohereVec = normalize(cohereVec);
cohereVec *= MAX_FORCE;
}
}
else{
cohereVec = [0.0,0.0];
}

vec2 acceleration = cohereVec + alignVec + seperateVec;
vel += acceleration;

if (|vel| > MAX_SPEED){
vel = normalize(cohereVec);
vel *= MAX_SPEED;
}

pos += vel;

//Wrapping Code, if a boid goes outside the window
real posX = wrapDimensions[EAST] if pos[0] < wrapDimensions[WEST]
else wrapDimensions[WEST] if pos[0] > wrapDimensions[EAST]
else pos[0];

real posY = wrapDimensions[SOUTH] if pos[1] < wrapDimensions[NORTH]
else wrapDimensions[NORTH] if pos[1] > wrapDimensions[SOUTH]
else pos[1];

pos = [posX,posY];

boidInfo = [pos[0],pos[1], vel[0], vel[1]];
}
}

initially {Boid(i,initVelocities{i*2},initVelocities{i*2+1},initPosns{i*2},
initPosns{i*2+1}) | i in 0 .. numBoids-1 };
```