disappearing blocks

/**

**

** Submitted to curation "Void" 🌚 #WCCChallenge

**

**/

​

const nrings = 40;

const maxfalling = 1000;

let bricks, falling;

let radiusFunc, ringFunc, thickFunc, ring0;

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  generate();

}

​

function mouseClicked() {

  generate()

}

​

function generate() {

  let R = min(width, height);

  ring0 = R / 2 / nrings;

  let ringRatio = (2 * R / ring0 - 1) ** (1 / nrings);

  radiusFunc = (i) => ring0 * (ringRatio ** i);

  ringFunc = (r) => log(r / ring0) / log(ringRatio);

  thickFunc = (i) => (radiusFunc(i + 1) - radiusFunc(i)) * 0.90;

  //print (ringRatio)

  let dring = (min(width, height) * 0.9) / (nrings + 1);

  let segSize = ring0;

  let gap = ring0 / 8;

  bricks = [];

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

    let r = radiusFunc(i);

    let dr = thickFunc(i);

    let perimeter = TAU * r;

    let n = perimeter / segSize;

    segSize *= 1.1;

    let dang = TAU / n;

    let gap = dr / 6;

    let gapAng = gap / perimeter * TAU;

    let angTotal = 0;

    let offset = random(TAU);

    let angVel = random(radians(0.1), radians(0.2));

    for (let ang of randomPartition(TAU, dang)) {

      bricks.push({

        amin: angTotal,

        amax: angTotal + ang - gapAng,

        r,

        dr,

        offset,

        angVel,

        status: 'static',

      });

      angTotal += ang;

    }

​

  }

  falling = [];

}

​

function randomPartition(val = 1, minSize = 0.1, variation = 0.1) {

  const partition = (val) => {

    let d = 0.5 + random(-variation, variation);

    let val0 = val * d,

      val1 = val * (1 - d);

    if (min(val0, val1) >= minSize) return [...partition(val0), ...partition(val1)]

    return [val]

  }

  return partition(val);

}

​

function draw() {

  background(0);

  translate(width / 2, height / 2);

  stroke('#555')

  for (let brick of bricks) {

    let ang = brick.offset;

    brick.offset += brick.angVel;

    noFill();

    strokeWeight(brick.dr * 0.8);

    strokeCap(SQUARE);

    if (brick.status === 'static' &&

      random() < 0.001 &&

      falling.length < maxfalling) {

      brick.status = 'falling';

      brick.rincrement = -0.5;

      brick.angVel *= 2;

      falling.push(brick);

    }

    if (brick.status == 'static')

      arc(0,0, brick.r * 2, brick.r * 2,

        brick.amin + brick.offset, brick.amax + brick.offset, OPEN,10)

  }

  let nextFalling = [];

  stroke('white');

  for (let brick of falling) {

    brick.r += brick.rincrement;

    if (brick.r >= ring0) nextFalling.push(brick);

    else continue;

    strokeWeight(thickFunc(ringFunc(brick.r)) * 0.8);

    if (brick.status == 'falling') {

      arc(0,0, brick.r * 2, brick.r * 2,

        brick.amin + brick.offset, brick.amax + brick.offset, OPEN, 10);

    }

    brick.offset += brick.angVel;

  }

  falling = nextFalling;

}