​

let moveSpeedSlider,turnSpeedSlider,diffuseSpeedSlider,evapSpeedSlider,SensorDstSlider,SensorSizeSlider,SensorSpacingSlider;

​

let moveSpeed;// = 0.5; 

let turnSpeed;// = 2;

let diffuseSpeed;// = 0.5;

let evapSpeed;// = 1;

​

let SensorDst;// = 0.1;

let SensorSize;//= 3;

let sensorSpacing;//= 30;

​

let agents = [];

let locations = [];

let population = 100;

let size = 1;

​

function getIndex(pos){

  return (floor(pos.x) + floor(pos.y) * width) * 4;

}

​

function setup() {

  createCanvas(100, 100);

  pixelDensity(1);

  background(0);

  for(let i = 0; i < population; i++){

    agents.push(new Agent(width/2,height/2,random(2*PI)));

  }

  moveSpeedSlider = createSlider(0.1, 30, 0.5, 0.1);

  moveSpeedSlider.position(10,height+10);

  turnSpeedSlider = createSlider(0.1, 30, 2, 0.1);

  turnSpeedSlider.position(10,height+30);

  diffuseSpeedSlider = createSlider(0.1,30,0.5,0.1)

  diffuseSpeedSlider.position(10,height+50);

  evapSpeedSlider = createSlider(0.1, 30, 1, 0.1);

  evapSpeedSlider.position(10,height+70);

  SensorDstSlider = createSlider(0.1, 30, 0.1, 0.1);

  SensorDstSlider.position(10,height+90);

  SensorSizeSlider = createSlider(0.1, 30, 3, 0.1);

  SensorSizeSlider.position(10,height+110);

  SensorSpacingSlider = createSlider(0.1, 30, 10, 0.1);

  SensorSpacingSlider.position(10,height+130);

}

​

function draw() {

  loadPixels();

  moveSpeed = moveSpeedSlider.value(); 

  turnSpeed = turnSpeedSlider.value();

  diffuseSpeed = diffuseSpeedSlider.value();

  evapSpeed = evapSpeedSlider.value();

  SensorDst = SensorDstSlider.value();

  SensorSize = SensorSizeSlider.value();

  sensorSpacing = SensorSpacingSlider.value();

  print(moveSpeed,turnSpeed,diffuseSpeed,evapSpeed,SensorDst,SensorSize,sensorSpacing)

  //noLoop();

  //get locations 

  for(let a of agents){

    a.turn();

    a.move();

    let location = a.getPosition();

    let index = getIndex(location);

    pixels[index] = 255;

    pixels[index+1] = 255;

    pixels[index+2] = 255;

  }

  //blur effect

  for(let x = 0; x < width; x++){

    for(let y = 0; y < height; y++){

      let index = getIndex(createVector(x,y));

      let orignalValue = pixels[index]; 

      let sum = 0;

      for(let xOff = -size; xOff <= size; xOff++){

        for(let yOff = -size; yOff <= size; yOff++){

​

          let sampleX = x + xOff;

          let sampleY = y + yOff;

          if(sampleX >= 0 && sampleX < width && sampleY >= 0 && sampleY < height){

            let sampleIndex = getIndex(createVector(sampleX,sampleY));

            sum += pixels[sampleIndex];

          }

        }

      }

​

      let blur = sum/9;

      let diffusedValue = lerp(orignalValue,blur,diffuseSpeed * dt);

      let evapValue = max(0,diffusedValue - evapSpeed * dt);

      pixels[index] = evapValue;  

      pixels[index+1] = evapValue;  

      pixels[index+2] = evapValue;  

    }

  }

  updatePixels();

}

​

class Agent{

  constructor(x,y,a){

    this.pos = createVector(x,y);

    this.angle = a;

    this.sensorAngle = 10;

  }

  steer(offSet){

    let sensor = this.sensorAngle + offSet;

    let sensorDir = createVector(cos(sensor),sin(sensor));

    let centre = this.pos.add(sensorDir.mult(SensorDst));

    let sum = 0;

    for(let xOff = -SensorSize; xOff <= SensorSize; xOff++){

      for(let yOff = -SensorSize; yOff <= SensorSize; yOff++){

        let pos = centre.add(createVector(xOff,yOff));

        if(pos.x >= 0 && pos.x < width && pos.y >= 0 && pos.y < height){

          let index = getIndex(pos);

          sum += pixels[index];

        }

      }  

    }

    return sum;

  }

  turn(){

    let weightForward = this.steer(0);

    let weightLeft = this.steer(sensorSpacing);

    let weightRight = this.steer(-sensorSpacing);

    let randomSteer = random(1);

    //forward

    if(weightForward > weightLeft && weightForward > weightRight){

      this.angle += 0;

    }

    //random

    else if(weightForward < weightLeft && weightForward < weightRight){

      this.angle += (randomSteer - 0.5) * 2 * turnSpeed * dt;

    }

    //right 

    else if(weightRight > weightLeft){

      this.angle -= randomSteer * turnSpeed * dt;

    }

    //left

    else if(weightLeft > weightRight){

      this.angle += randomSteer * turnSpeed * dt;

    }

  }

  move(){

    let dir = createVector(cos(this.angle),sin(this.angle));

    let newPos = this.pos.add(dir.mult(moveSpeed).mult(dt));

​

    //border check

    if(newPos.x < 0 || newPos.x >= width || newPos.y < 0 || newPos.y >= height){

      newPos.x = min(width-0.01, max(0, newPos.x));

      newPos.y = min(height-0.01, max(0, newPos.y));

      this.angle = random(0,1) * 2 * PI;

    }

    this.pos = newPos; 

  } 

  getPosition(){

    return this.pos;

  }

}