Worms 3

let particles;

const minRadius = 15;

const maxRadius = 20;

const friction = 0.9;

const speedLimit = 5;

const margin = 10;

let worms;

const wormCount = 20;

const wormLength = 20;

const playerRadius = 120;

​

function mouse() {

  return {

    pos: createVector(mouseX - width / 2, mouseY - height / 2),

    acc: createVector(0, 0),

    radius: playerRadius,

​

    show() {

      push();

      fill("ghostwhite");

      translate(this.pos);

      sphere(this.radius / 3);

      pop();

    },

  };

}

​

function setup() {

  createCanvas(720, 720, WEBGL);

  colorMode(HSB, 360, 360, 360);

  [particles, worms] = makeParticles();

}

​

function draw() {

  background("black");

  noStroke();

  directionalLight(color("white"), 0, 0, -1);

  directionalLight(color(64), 0, 0, -1);

​

  mutualRepulsion();

  worms.forEach((e) => e.moveHead());

  worms.forEach((e) => e.seek());

  particles.forEach((e) => e.update());

  particles.forEach((e) => e.wrap());

  worms.forEach((e) => e.show());

}

​

function makeParticles() {

  let arr = [];

  let worms = [];

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

    const hsbColor = (360 * i) / wormCount;

    let group = [];

    for (let j = 0; j < wormLength; j++) {

      let p = new particle();

      arr.push(p);

      group.push(p);

    }

    worms.push(new worm(group, hsbColor));

  }

  return [arr, worms];

}

​

function mutualRepulsion() {

  const player = mouse();

  player.show();

  const all = particles.concat(player);

​

  for (let i = all.length; i--; ) {

    const current = all[i];

    for (let j = i; j--; ) {

      const target = all[j];

      const delta = current.pos.copy().sub(target.pos);

      const distance = delta.mag();

      const sumRadii = current.radius + target.radius;

      if (distance < sumRadii) {

        const multi = pow(2, -distance / 4);

        const force = delta.mult(multi);

        current.radius == playerRadius && force.mult(10000);

        current.acc.add(force);

        target.acc.sub(force);

      }

    }

  }

}

​

function worm(arrayOfParticles, hsbColor) {

  this.parts = arrayOfParticles;

  this.color = color(hsbColor, 360, 360);

  this.direction = random(2 * PI);

  this.rotation = random(2) < 1 ? -0.01 : 0.01;

​

  this.moveHead = () => {

    const head = this.parts[0];

    this.direction += this.rotation;

    const unitVector = createVector(1, 0).rotate(this.direction);

    head.vel.add(unitVector);

  };

  this.seek = () => {

    for (let i = 1; i < this.parts.length; i++) {

      const current = this.parts[i];

      const prev = this.parts[i - 1];

      const delta = current.pos.copy().sub(prev.pos);

      const distance = delta.mag();

      k = pow(1.25, -(distance / 10));

      const force = delta.mult(k * 0.2);

      current.acc.sub(force);

      prev.acc.add(force);

    }

  };

  this.show = () => {

    fill(this.color);

    this.parts.forEach(p=>{

      push();

      translate(p.pos);

      sphere(p.radius);

      let a = atan2(p.vel.y, p.vel.x);

      rotate(a + PI / 2);

      box(p.radius * 3, 3);

      pop();      

    })

  };

}

​

function particle() {

  this.pos = createVector(0, 0);

  this.vel = createVector(0, 0);

  const angle = random(PI * 2);

  this.acc = createVector(1, 0).rotate(angle);

  this.radius = random(minRadius, maxRadius);

​

  this.update = () => {

    this.vel.add(this.acc);

    this.vel.mult(friction);

    this.vel.limit(speedLimit);

    this.pos.add(this.vel);

    this.acc.mult(0);

  };

​

  this.wrap = () => {

    const r = this.radius + margin;

    if (this.pos.x < r - width / 2 || this.pos.x > width / 2 - r) {

      this.pos.sub(this.vel);

      this.vel.x *= -1;

    }

    if (this.pos.y < r - height / 2 || this.pos.y > height / 2 - r) {

      this.pos.sub(this.vel);

      this.vel.y *= -1;

    }

  };

}

​