Neural Game of Life - OpenProcessing

mySketch
colormap
xxxxxxxxxx
 
​
//references
//fighting squares https://openprocessing.org/sketch/799636
​
const DIM = 400,
      STEP = 5,
      SIZE = Math.floor(DIM / STEP),
      CELLS = SIZE * SIZE;
​
let grid = [];
let indexer = [0, 1];
let coords = [];
let peers = [];
let colormap;
​
function setup() 
{
  createCanvas(DIM, DIM);
  colorMode(RGB, 1, 1, 1);
  noStroke();
  colormap = new ColorMap(); 
  
  initGrids();
  initCoords();
  initPeers();
}
​
function mouseClicked()
{
  initGrids();
}
​
function initGrids()
{
  //read and write grids
  grid[0] = []; 
  grid[1] = [];
  
  for(let i = 0; i < SIZE; i++)
  {
    grid[0][i] = [];
    grid[1][i] = [];
    
    for(let j = 0; j < SIZE; j++)
    {
      let d = dist(i, j, SIZE/2, SIZE/2);
      let n = noise(i, j);
      grid[0][i][j] = (d > SIZE/5) ? 0 : (n < 0.3 || n > 0.7) ? random(1) : n;
      grid[1][i][j] = 0;
    }
  }
}
​
function initCoords()
{
  for(let i = 0; i < SIZE; i++)
  {
    for(let j = 0; j < SIZE; j++)
    {
      coords.push([i,j]);
    }
  }
}
​
function initPeers()
{
  for(let x = -1; x <= 1; x++)
  {
    for(let y = -1; y <= 1; y++)
    {
      if(x == 0 && y == 0) continue;
      peers.push([x, y]);
    }
  }
}
​
function draw() 
{
  
  for(let i = 0; i < SIZE; i++)
  {
    for(let j = 0; j < SIZE; j++)
    {
      //if(grid[indexer[0]][i][j] > 0.5) fill(green);
      //else fill(grey);
      //fill(lerpColor(grey, green, grid[indexer[0]][i][j]));
      
      let colour = colormap.getColor(grid[indexer[0]][i][j]);
      fill(colour);
      square(i * STEP, j * STEP, STEP);
      
      if(dist(mouseX / width * SIZE, mouseY / width * SIZE, i, j) < SIZE / 10)
      {
        grid[indexer[0]][i][j] = random(1);
      }
    }
  }
  updateGridsNeural();
  
}
​
function updateGrids()
{
  let self = 0;
  let count = 0;
  for(let coord of coords) //for each cell
  {
    self = grid[indexer[0]][coord[0]][coord[1]];
    count = 0;
    for(let peer of peers)
    {
      let i = (coord[0] + peer[0] + SIZE) % SIZE;
      let j = (coord[1] + peer[1] + SIZE) % SIZE;
      count += grid[indexer[0]][i][j]; 
    }
    
    let life = (self === 1 && count > 1 && count < 4) || (self === 0 && count === 3);
    
    grid[indexer[1]][coord[0]][coord[1]] = life ? 1 : 0;
  }
  
  indexer[0] = 1 - indexer[0];
  indexer[1] = 1 - indexer[1];
}
​
function updateGridsNeural()
{
  let self = 0;
  let count = 0;
  for(let coord of coords) //for each cell
  {
    self = grid[indexer[0]][coord[0]][coord[1]];
    count = 0;
    for(let peer of peers)
    {
      let i = (coord[0] + peer[0] + SIZE) % SIZE;
      let j = (coord[1] + peer[1] + SIZE) % SIZE;
      count += grid[indexer[0]][i][j]; 
    }
    
    let selfIsOne = 1 /  (1 + exp(-10 * ( self - 0.5))); 
    let peersOver1 = 1 / (1 + exp(-10 * ( count - 1.5 ))); 
    let peersOver2 = 1 / (1 + exp(-10 * ( count - 2.5 ))); 
    let peersOver3 = 1 / (1 + exp(-10 * ( count - 3.5 ))); 
    
    let self0peers3 =    1 / (1 + exp(-10 * (-selfIsOne + peersOver2 - peersOver3 - 0.5)));
    let self1peers2or3 = 1 / (1 + exp(-10 * ( selfIsOne + peersOver1 - peersOver3 - 1.5)));
    
    let output = 1 / (1 + exp(-10 * ( self0peers3 + self1peers2or3 - 0.5 ))); 
    let life = round(output);
    
    grid[indexer[1]][coord[0]][coord[1]] = life;
  }
  
  indexer[0] = 1 - indexer[0];
  indexer[1] = 1 - indexer[1];
}