Worms 2 - OpenProcessing

mySketch
xxxxxxxxxx
 
// Forgive my sloppy physics.
​
let balls = [];
let worms = [];
​
const numOfWorms = 32;
const lengthOfWorm = 12;
const minRadiusOfBall = 16;
const maxRadiusOfBall = 8;
const margin = 10;
const forceOfAttraction = 4;
​
function setup() {
  p5.disableFriendlyErrors = true;
  createCanvas(960, 540, WEBGL);
  bigBang();
}
​
function lightning() {
  directionalLight(color("white"), 0, 0, -1);
  directionalLight(color("gray"), 0, -1, -1);
}
​
function draw() {
  background("black");
  noStroke();
  lightning();
​
  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());
}
​
function bigBang() {
  for (let i = numOfWorms; i--; ) {
    let group = [];
    let radius = random(minRadiusOfBall, maxRadiusOfBall);
​
    for (j = 0; j < lengthOfWorm; j++) {
      const ball = new Ball(j ? radius : radius * 1.5);
      group.push(ball);
      balls.push(ball);
    }
    worms.push(new Worm(group));
  }
}
​
function mouse() {
  return {
    pos: createVector(mouseX - width / 2, mouseY - height / 2),
    acc: createVector(0, 0),
    radius: 100,
    
    show(){
      push();
      fill("ghostwhite");
      translate(this.pos);
      sphere(this.radius / 2);
      pop();    
    }
  }
}
​
function avoidOverlapping() {
  const player = mouse();
  player.show();
  
  const all = balls.concat(player);
  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);
      }
    }
  }
}
​
class Worm {
  constructor(arrayOfBalls) {
    this.parts = arrayOfBalls;
    this.color = color(random(50, 256), random(50, 256), random(50, 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() {
    let prev = this.parts[0];
    for (let i = 1; i < this.parts.length; i++) {
      const current = this.parts[i];
      const delta = current.pos.copy().sub(prev.pos);
      const force = delta.normalize().mult(forceOfAttraction);
      current.acc.sub(force);
      prev.acc.add(force);
      prev = current;
    }
  }
  show() {
    fill(this.color);
    this.parts.forEach((p, index) => {
      push();
      translate(p.pos);
      if (index == 0) {
        torus(p.radius / 1.5, p.radius / 4);
        const signal = 1 >= p.vel.x ** 2 + p.vel.y ** 2;
        if(signal){
          fill("red");
          sphere(p.radius / 3);
        }
      } else {
        sphere(p.radius);
      }
      pop();
    });
  }
}
​
class Ball {
  constructor(radius) {
    this.pos = createVector(random(-1, 1), random(-1, 1));
    this.vel = createVector(0, 0);
    this.acc = createVector(0, 0);
    this.radius = radius;
  }
  update() {
    this.vel.add(this.acc.div(2));
    this.pos.add(this.vel);
    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);
  }
}
​