Worms

// Inspired by Juhani Halkomaki - Particle chunk

// https://openprocessing.org/sketch/1619381

//

// Forgive my sloppy physics.

//////////////////////////////////////////////////

let balls = [];

let worms = [];

let mouseHistory = [];

​

const numOfWorms = 48;

const lengthOfWorm = 7;

const minRadiusOfBall = 7;

const maxRadiusOfBall = 14;

const margin = 10;

​

function setup() {

  p5.disableFriendlyErrors = true;

  createCanvas(960, 540, WEBGL);

  bigBang();

}

​

function draw() {

  background("black");

  noStroke();

​

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

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

  // The light intensity: white + gray = white * 1.5

​

  avoidOverlapping();

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

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

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

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

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

​

  if (!mouseIsPressed) mouseHistory.length = 0;

  drawMouseHistory();

}

​

function bigBang() {

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

    let group = [];

    for (j = lengthOfWorm; j--; ) {

      const ball = new Ball();

      group.push(ball);

      balls.push(ball);

    }

    worms.push(new Worm(group));

  }

}

​

function avoidOverlapping() {

  const all = balls.concat(mouseHistory);

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

    const A = all[i];

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

      const B = all[j];

      const delta = A.pos.copy().sub(B.pos);

      const distance = sqrt(delta.x ** 2 + delta.y ** 2);

      const sumRadius = A.radius + B.radius;

      if (distance < sumRadius) {

        const k = 1 - distance / sumRadius;

        const force = delta.mult(k);

        A.acc.add(force);

        B.acc.sub(force);

      }

    }

  }

}

​

mouseDragged = () => {

  const v = createVector(mouseX - width / 2, mouseY - height / 2);

  mouseHistory.push({

    pos: v,

    acc: createVector(0, 0),

    radius: 15,

    age: 0,

  });

};

​

function drawMouseHistory() {

  stroke("white");

  strokeWeight(3);

  noFill();

  beginShape();

  mouseHistory = mouseHistory.filter((m) => {

    vertex(m.pos.x, m.pos.y);

    ++m.age;

    return m.age < 100;

  });

  endShape();

}

​

class Worm {

  constructor(arrayOfBalls) {

    this.parts = arrayOfBalls;

    this.color = color(random(256), random(256), random(256));

    this.direction = random(2 * PI);

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

  }

  moveHead(){

    const head = this.parts[0];

    this.direction += this.rotation;

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

    head.vel.add(unitVector);    

  }

  attractNeighborParts() {

    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 force = delta.normalize().mult(2);

      current.acc.sub(force);

      prev.acc.add(force);

    }

  }

  show() {

    fill(this.color);

    for (const p of this.parts) {

      push();

      translate(p.pos);

      sphere(p.radius);

      pop();

    }

  }

}

​

class Ball {

  constructor() {

    this.pos = createVector(random(-1, 1), random(-1, 1));

    this.vel = createVector(0, 0);

    this.acc = createVector(0, 0);

    this.radius = random(minRadiusOfBall, maxRadiusOfBall);

  }

  update() {

    this.vel.add(this.acc.mult(0.5));

    this.pos.add(this.vel);

// Prepare for the next frame

    this.acc.mult(0);

    this.vel.mult(0.9);

  }

  wrap() {

    const r = this.radius + margin;

    this.pos.x = constrain(this.pos.x, r - width / 2, width / 2 - r);

    this.pos.y = constrain(this.pos.y, r - height / 2, height / 2 - r);

  }

}

​