let snakeCount = 5;

let distanceConstraint = 30;

​

function setup() {

  createCanvas(800, 600);

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

    let speed = random(2, 6);

    let smoothness = random(0.2, 0.5);

    let bodyColor = color(random(255), random(255), random(255));

    let edgeColor = color(random(255), random(255), random(255));

    snakes.push(new Snake(random(width), random(height), 20, distanceConstraint, speed, smoothness, bodyColor, edgeColor));

  }

}

let t = 0;

let dt = 0.01; // Smaller dt for smoother movement

let angleOffset = 0;

​

function draw() {

  background(30);

​

  var i = 0;

  for (let snake of snakes) {

    // Use a combination of Perlin noise and trigonometric functions for smoother target points

    let angle = angleOffset + i * TWO_PI / snakeCount;

    let radius = width * 0.3 * noise(i * 10 + t);

    let px = width / 2 + radius * cos(angle);

    let py = height / 2 + radius * sin(angle);

​

    // Ensure the target point is not too close to the snake's head

    let head = snake.segments[0];

    let target = createVector(px, py);

    while (target.dist(head.pos) < distanceConstraint) {

      angleOffset += 0.1;

      angle = angleOffset + i * TWO_PI / snakeCount;

      radius = width * 0.3 * noise(i * 10 + t + 1000);

      px = width / 2 + radius * cos(angle);

      py = height / 2 + radius * sin(angle);

      target = createVector(px, py);

    }

​

    snake.update(target);

    snake.draw();

    i += 1;

  }

  t += dt;

  angleOffset += 0.01; // Increment angle offset for continuous movement

}

​

​

class Snake {

  constructor(x, y, segmentCount, distanceConstraint, speed, smoothness, bodyColor, edgeColor) {

    this.segments = [];

    this.segmentCount = segmentCount;

    this.distanceConstraint = distanceConstraint;

    this.speed = speed;

    this.smoothness = smoothness;

    this.bodyColor = bodyColor;

    this.edgeColor = edgeColor;

​

    // Initialize the segments with proper spacing

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

      this.segments.push(new Segment(x + i * distanceConstraint, y, random(10, 30)));

    }

  }

​

  update(target) {

    // Move head towards target with smoothing

    let head = this.segments[0];

    let dir = p5.Vector.sub(target, head.pos);

    if (dir.mag() > 5) {

      dir.setMag(this.speed);

      head.pos.add(p5.Vector.mult(dir, this.smoothness));

    }

​

    // Update segment positions

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

      let prev = this.segments[i - 1];

      let curr = this.segments[i];

      let direction = p5.Vector.sub(prev.pos, curr.pos);

      let distance = direction.mag();

      let difference = distance - this.distanceConstraint;

      direction.normalize();

      direction.mult(difference);

      curr.pos.add(direction);

    }

  }

​

  draw() {

    // Find points on the sides of each segment

    let leftPoints = [];

    let rightPoints = [];

    for (let i = 0; i < this.segments.length; i++) {

      let curr = this.segments[i];

      let angle = (i == 0) ? p5.Vector.sub(this.segments[1].pos, curr.pos).heading() : p5.Vector.sub(curr.pos, this.segments[i - 1].pos).heading();

      let left = p5.Vector.fromAngle(angle - HALF_PI).setMag(curr.size / 2).add(curr.pos);

      let right = p5.Vector.fromAngle(angle + HALF_PI).setMag(curr.size / 2).add(curr.pos);

      leftPoints.push(left);

      rightPoints.push(right);

    }

​

    // Draw hull

    fill(this.bodyColor);

    stroke(this.edgeColor);

    beginShape();

    for (let p of leftPoints) {

      vertex(p.x, p.y);

    }

    for (let p of rightPoints.reverse()) {

      vertex(p.x, p.y);

    }

    endShape(CLOSE);

  }

}

​

class Segment {

  constructor(x, y, size) {

    this.pos = createVector(x, y);

    this.size = size;

  }

}

​