Game of Life (p5.js)

/*******************************************************************************

​

Il “Gioco della vita” di John Conway

Versione p5.js di Antonio Belluscio

​

Caratteristiche:

- spazio toroidale 

  (le celle a destra confinano con quelle a sinistra e viceversa e

  le celle in alto confinano con quelle in basso e viceversa);

- possibilità di cambiare lo stato delle celle cliccando o disegnando

  sul canvas;

- uso delle scambio di array bidimensionali creati in anticipo per

  velocizzare le operazioni.

​

*******************************************************************************/

​

let arrA = [];      // Array bidimensionali utilizzati alternativamente per

let arrB = [];      // memorizzare gli stati delle celle

let celle;          // Riferimento all'array con i valori delle celle correnti (da visualizzare)

let nuoveCelle;     // Riferimento all'array con i valori delle nuove celle (da elaborare)

let colonne = 200;

let righe = 120;

let dimensione = 5;

​

function setup()

{

  createCanvas(colonne*dimensione, righe*dimensione);

  noStroke();

  fill(0);

                                     // CREA I 2 ARRAY E RIEMPI IL 1° 

  for (let c=0;  c<colonne;  c++) {  // per ogni colonna...

    arrA[c] = [];                    // crea le righe  

    arrB[c] = [];

    for (let r=0;  r<righe;  r++) {  // per ogni cella della colonna...

      arrA[c][r] = random() < 0.25;  // cella viva con il 25% di probabilità

      arrB[c][r] = false;  

    }

  }

  celle = arrA;       // arrA è inizialmente l'array con le celle da visualizzare 

  nuoveCelle = arrB;  // arrB è inizialmente l'array in cui memorizzare i nuovi stati

  frameRate(30);

  cursor(HAND);

}

function draw()

{

  background(255);

  for (let c=0;  c<colonne;  c++) {            // per ogni colonna...

    for (let r=0;  r<righe;  r++) {            // per ogni cella della colonna...

      if (celle[c][r]) {                       // se la cella nella posizione corrente e' viva ...

        square( c*dimensione, r*dimensione, dimensione );  // colora la cella di nero

      }

​

      let quanteVive = 0;                      // RICAVA IL NUMERO DI CELLE VIVE INTORNO A QUELLA CORRENTE

      for (let dc=-1;  dc <= 1;  dc++) {       // dalla colonna precedente a quella successiva ...

        for (let dr=-1;  dr <= 1;  dr++) {     // dalla riga superiore a quella inferiore ...

          if (dc != 0 || dr != 0) {            // se il riferimento non e' alla cella corrente ... 

            if (celle[ (c+dc+colonne)%colonne ][ (r+dr+righe)%righe ]) {   // se la cella analizzata(*) e' viva ...

              quanteVive++;                    // incrementa il valore di quanteVive  

            }

          }

        }

      }

                                               // APPLICA LE REGOLE SEMPLIFICATE  

      if (quanteVive < 2 || quanteVive > 3) {  // se le celle vive sono meno di 2 o piu' di 3 ...

        nuoveCelle[c][r] = false;              //   la cella corrente muore (o rimane morta)

      } else if (quanteVive == 3) {            // altrimenti, se le celle vive sono esattamente 3 ...

        nuoveCelle[c][r] = true;               //   la cella nasce (o rimane viva)

      } else {                                 // altrimenti, in tutti gli altri casi ... 

        nuoveCelle[c][r] = celle[c][r];        //   la cella mantiene il proprio stato

      }

    }

  } 

                                               // SCAMBIA I RIFERIMENTI AGLI ARRAY

  if (celle == arrA) {                         // se le celle da visualizzare sono in 'arrA' 

    celle = arrB;                              //   scambia con 'arrB' 

    nuoveCelle = arrA;                        

  } else {                                     // altrimenti (se le celle da visualizzare son in 'arrB') ... 

    celle = arrA;                              //   scambia con 'arrA'

    nuoveCelle = arrB;

  } 

}

​

function mousePressed()       // alla pressione del tasto del mouse ...

{

  cambiaStato();

}

​

function mouseDragged()       // allo spostamento del mouse con il tasto premuto ...

{

  cambiaStato();

}

​

function cambiaStato()        // cambia stato della cella sotto il cursore del mouse

{

  if (mouseX >= 0 && mouseX < width && mouseY >= 0 && mouseY < height) {  // se il cursore è sopra il canvas ...

    let c = int(mouseX / dimensione);    // ricava la posizione della cella sottostante

    let r = int(mouseY / dimensione);

    celle[c][r] = !celle[c][r]; // inverti il valore booleano corrente (se la cella è viva muore e viceversa)

  } 

}

​

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

// (*)     [ (c+dc+colonne)%colonne ]

//

// c+dc     -> per ottenere il riferimento alla cella da 

//             analizzare rispetto a quella corrente

// +colonne -> per evitare indici di array con valori

//             negativi (se c==0 e dc==-1)

// %colonne -> uso del resto della divisione per 'colonne', 

//             per evitare indici di array con valori

//             superiori al massimo

//

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