// an object-oriented implementation of GoL

// ugly global
GameBoard gb;

void setup(){
  size(500, 500);
  background(0);
  
  gb = new GameBoard(width, height, 5, 50);
  gb.randPop(1);
}

void draw(){
  for(int i = 0; i < gb.sizeX; i++){
    for(int j = 0; j < gb.sizeY; j++){
      stroke(0);
      switch(gb.board[i][j].state){
        case 0:
          fill(0);
          break;
        case 1:
          fill(0, 153, 0);
          break;
        case 2:
          fill(102, 102, 255);
          break;
        case 3:
          fill(163, 14, 36);
          break;
      }
      rect((i * gb.board[i][j].sizeX) % width, 
      (j * gb.board[i][j].sizeY) % height, 
      gb.board[i][j].sizeX, 
      gb.board[i][j].sizeY);
    }
  }
  
  gb.generation(1);  
  
  if(mousePressed){
    //gb.dropGlider(mouseX % width, mouseY % height);
    gb.randPop(1);
  }
}

class Cell{
  int state;
  int sizeX;
  int sizeY;
  
  //constructor
  Cell(int s, int x, int y){
    state = s;
    sizeX = x;
    sizeY = y;
  }
}

class GameBoard{
  int sizeX;
  int sizeY;
  int cellSize;
  int popAlive;
  Cell[][] board;
  
  GameBoard(int x, int y, int s, int pA){
    sizeX = x / s;
    sizeY = y / s;
    cellSize = s;
    popAlive = pA;
    board = new Cell[sizeX][sizeY];
  }
  
  void randPop(int s){
    for(int i = 0; i < sizeX; i++){
      for(int j = 0; j < sizeY; j++){
        if(int(random(1,101)) <= popAlive){
          board[i][j] = new Cell(s, cellSize, cellSize);
        }
        else
        {
          board[i][j] = new Cell(0, cellSize, cellSize);
        }
      }
    }
  }
  int countNeighbors(int x, int y){
    int neighbors = 0;
    
    if(board[(x + sizeX - 1) % sizeX][(y + sizeY - 1) % sizeY].state != 0){ neighbors++; } 
    if(board[x][(y + sizeY - 1) % sizeY].state != 0){ neighbors++; }
    if(board[(x + 1) % sizeX][(y + sizeY - 1) % sizeY].state != 0){ neighbors++; } 
    if(board[(x + sizeX - 1) % sizeX][y].state != 0){ neighbors++; } 
    if(board[(x + 1) % sizeX][y].state != 0){ neighbors++; } 
    if(board[(x + sizeX - 1) % sizeX][(y + 1) % sizeY].state != 0){ neighbors++; } 
    if(board[x][(y + 1) % sizeY].state != 0){ neighbors++; } 
    if(board[(x + 1) % sizeX][(y + 1) % sizeY].state != 0){ neighbors++; }
    
    return neighbors;
  }
  int countState(int state){
    return state;
  }
  void generation(int cycles){
    int neighbors = 0;
    Cell[][] next = new Cell[sizeX][sizeY];
    
    for(int c = 0; c < cycles; c++){
      for(int i = 0; i < sizeX; i++){
        for(int j = 0; j < sizeY; j++){
          neighbors = countNeighbors(i, j);
          
          next[i][j] = new Cell(0, cellSize, cellSize);
          
          if(board[i][j].state != 0){
            if(neighbors == 2)
            {
              next[i][j].state = 2;
            }
            else if(neighbors == 3){
              next[i][j].state = 3;
            }
            else{
              next[i][j].state = 0;
            }
          }
          else{
            if(neighbors == 3){
              next[i][j].state = 1;
            }
            else{
              next[i][j].state = 0;
            }
          }
        }
      }
      
      for(int i = 0; i < sizeX; i++){
        for(int j = 0; j < sizeY; j++){
          board[i][j].state = next[i][j].state;
        }
      }
    }
  }
  void dropGlider(int x, int y){
    int bX = x / cellSize;
    int bY = y / cellSize;
   
    board[bX][bY].state = 1;
    board[(bX + 1) % sizeX][bY].state = 1;
    board[(bX + 2) % sizeX][bY].state = 1;
    board[(bX + 2) % sizeX][(bY + sizeY - 1) % sizeY].state = 1;
    board[(bX + 1) % sizeX][(bY + sizeY - 2) % sizeY].state = 1;
  }
}