My Sketch

let automaton;

let particles = [];

let flowField;

let crazyIvanInterval;

let lastCrazyIvanTime = 0;

let bgColor;

let saveGenerations = true;

​

function setup() {

  //pixelDensity(2);

  createCanvas(random(400, 800), random(400, 800));

  randomSeed(floor(random(1000)));

  noiseSeed(floor(random(1000)));

​

  bgColor = color(random(50, 255), random(50, 255), random(50, 255));

  background(bgColor);

​

  let caWidth = width/2//random(50, 300);

  let caHeight = height/2//random(50, 300);

  let cellWidth = random(1, 5);

  let cellHeight = random(1, 5);

  automaton = new CellularAutomaton(caWidth, caHeight, cellWidth, cellHeight);

​

  let resolution = random(5, 200);

  flowField = new FlowField(resolution);

  flowField.generateNoiseField();

​

  for (let i = 0; i < width / cellWidth; i++) {

    particles.push(new Particle(i * cellWidth, 0));

  }

​

  crazyIvanInterval = floor(random(200, 600));

  console.log("Setup generativo completato.");

}

​

function draw() {

  let currentTime = frameCount;

​

  automaton.update();

​

  if (currentTime - lastCrazyIvanTime > crazyIvanInterval) {

    crazyIvan();

    lastCrazyIvanTime = currentTime;

  }

​

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

    particles[i].follow(flowField);

    particles[i].update(automaton.cells[i]);

    particles[i].display();

  }

​

  if (saveGenerations && frameCount % 500 === 0) {

    saveCanvas("generation_" + frameCount, "jpg");

  }

}

​

function crazyIvan() {

  console.log("Crazy Ivan attivato!");

​

  // Cambia lo sfondo

  bgColor = color(random(50, 255), random(50, 255), random(50, 255),50);

  background(bgColor);

​

  // Cambia il flow field in modo radicale

  flowField.randomize();

​

  // Aggiungi variazioni estreme agli angoli del flow field

  flowField.modifyAngles();

​

  // Cambia l'automa cellulare

  automaton.randomize();

​

  // Cambia tutte le particelle

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

    particles[i].randomize();

  }

​

  crazyIvanInterval = floor(random(200, 600));

}

​

class CellularAutomaton {

  constructor(wid, hei, altezz, largh) {

    this.wid = wid;

    this.hei = hei;

    this.cellHeight = altezz;

    this.cellWidth = largh;

    this.cells = Array(floor(wid / largh)).fill(0);

    this.cells[floor(this.cells.length / 2)] = 1;

    this.generation = 0;

    this.ruleset = this.generateRandomRules();

  }

​

  update() {

    let nextGen = Array(this.cells.length).fill(0);

​

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

      let left = this.cells[i - 1];

      let me = this.cells[i];

      let right = this.cells[i + 1];

      nextGen[i] = this.rules(left, me, right);

    }

​

    this.cells = nextGen;

    this.generation++;

  }

​

  rules(a, b, c) {

    if (a === 1 && b === 1 && c === 1) return this.ruleset[0];

    if (a === 1 && b === 1 && c === 0) return this.ruleset[1];

    if (a === 1 && b === 0 && c === 1) return this.ruleset[2];

    if (a === 1 && b === 0 && c === 0) return this.ruleset[3];

    if (a === 0 && b === 1 && c === 1) return this.ruleset[4];

    if (a === 0 && b === 1 && c === 0) return this.ruleset[5];

    if (a === 0 && b === 0 && c === 1) return this.ruleset[6];

    if (a === 0 && b === 0 && c === 0) return this.ruleset[7];

    return 0;

  }

​

  generateRandomRules() {

    return Array(8)

      .fill(0)

      .map(() => (random() < 0.5 ? 0 : 1));

  }

​

  randomize() {

    this.ruleset = this.generateRandomRules();

    console.log("Automa casualizzato:", this.ruleset);

  }

}

​

class Particle {

  constructor(x, y) {

    this.pos = createVector(x, y);

    this.prevPos = createVector(x, y);

    this.vel = createVector();

    this.acc = createVector();

    this.maxSpeed = random(0.5, 5);

    this.size = random(0.5,1);

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

  }

​

  follow(flow) {

    let x = floor(this.pos.x / flow.resolution);

    let y = floor(this.pos.y / flow.resolution);

    let index = x + y * flow.cols;

    let force = flow.field[index];

    this.applyForce(force);

  }

​

  applyForce(force) {

    this.acc.add(force);

  }

​

  update(state) {

    this.vel.add(this.acc);

    this.vel.limit(this.maxSpeed);

    this.pos.add(this.vel);

    this.acc.mult(0);

​

    if (this.pos.y > height) {

      this.pos.y = 0;

    }

    if (this.pos.y < 0) {

      this.pos.y = height;

    }

    if (this.pos.x < 0) {

      this.pos.x = width;

    }

    if (this.pos.x > width) {

      this.pos.x = 0;

    }

​

    this.color = state === 1 ? this.color: color(0);

  }

​

  display() {

    fill(this.color);

    noStroke();

    ellipse(this.pos.x, this.pos.y, this.size, this.size);

  }

​

  randomize() {

    this.maxSpeed = random(1, 5);

    this.size = random(0.5, 1);

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

  }

}

​

class FlowField {

  constructor(resolution) {

    this.resolution = resolution;

    this.cols = floor(width / this.resolution);

    this.rows = floor(height / this.resolution);

    this.field = [];

  }

​

  generateNoiseField() {

    this.field = [];

    for (let y = 0; y < this.rows; y++) {

      for (let x = 0; x < this.cols; x++) {

        let angle = noise(x * 0.001, y * 0.01) * TWO_PI;

        let v = p5.Vector.fromAngle(angle);

        this.field.push(v);

      }

    }

  }

​

  modifyAngles() {

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

      let newAngle = random(TWO_PI); // Cambia angolo casualmente

      this.field[i] = p5.Vector.fromAngle(newAngle).mult(random(0.5, 2)); // Modifica ampiezza del vettore

    }

    console.log("Flow field angoli modificati!");

  }

​

  randomize() {

    this.resolution = random(50, 200);

    this.cols = floor(width / this.resolution);

    this.rows = floor(height / this.resolution);

    this.generateNoiseField();

    console.log("Flow field casualizzato: risoluzione =", this.resolution);

  }

}