float durrett_delta = .09;  // yellow wins
//float durrett_delta = .085;  // red wins
//float durrett_delta = .08;  // red wins

int[][] durrett_grid = new int[grid_width][grid_height];;
int[][] durrett_grid_new = new int[grid_width][grid_height];;

color[] durrett_colors = {color(200,   0, 0), 
                          color(200, 200, 0), 
                          color(  0, 200, 0), 
                          color(  0, 200, 200)};


/*
float[][] nrs = {{ 1.0,  1.0,  1.0},
                 { 1.0,  1.0,  1.0},
                 { 1.0,  1.0,  2.0},
                 { 1.0,  1.0,  3.0},
                 { 1.0,  2.0,  3.0}};
*/

float[][] nrs = {{ 1.0,  1.0,  1.0},
                 { 1.0,  1.5,  5.0},
                 { 1.0,  2.0,  5.0},
                 { 1.0,  2.5,  5.0},
                 { 1.0,  3.0,  5.0},
                 { 1.0,  3.5,  5.0},
                 { 1.0,  4.0,  5.0},
                 { 1.0,  4.5,  5.0}};


float[][] pops= new float[nrs.length][3];
                 
float nr_1 = 5.0;
float nr_2 = 5.0;
float nr_3 = 1.0;

int[] n0_x = {      0, 
                -1,    1, 
                    0      };
int[] n0_y = {     -1, 
                 0,    0, 
                    1      };
                    
int[] n1_x = {         -1,  0,  1,
                   -2, -1,  0,  1,  2,
               -3, -2, -1,  0,  1,  2,  3,
               -3, -2, -1,      1,  2,  3,
               -3, -2, -1,  0,  1,  2,  3,
                   -2, -1,  0,  1,  2,
                       -1,  0,  1};

int[] n1_y = {         -3, -3, -3,    
                   -2, -2, -2, -2, -2, 
               -1, -1, -1, -1, -1, -1, -1,
                0,  0,  0,      0,  0,  0,
                1,  1,  1,  1,  1,  1,  1,
                    2,  2,  2,  2,  2, 
                        3,  3,  3  };
                    
               
                    
int[] n2_x = {                 -1,  0,  1,
                       -3, -2, -1,  0,  1,  2,  3,
                   -4, -3, -2, -1,  0,  1,  2,  3,  4,
                   -4, -3, -2, -1,  0,  1,  2,  3,  4,
               -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,
               -5, -4, -3, -2, -1,      1,  2,  3,  4,  5,
               -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,
                   -4, -3, -2, -1,  0,  1,  2,  3,  4,
                   -4, -3, -2, -1,  0,  1,  2,  3,  4,
                       -3, -2, -1,  0,  1,  2,  3
                               -1,  0,  1};


int[] n2_y = {                 -5, -5, -5, 
                       -4, -4, -4, -4, -4, -4, -4,
                   -3, -3, -3, -3, -3, -3, -3, -3, -3,
                   -2, -2, -2, -2, -2, -2, -2, -2, -2,
               -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                0,  0,  0,  0,  0,      0,  0,  0,  0,  0,
                1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
                    2,  2,  2,  2,  2,  2,  2,  2,  2,
                    3,  3,  3,  3,  3,  3,  3,  3,  3,
                        4,  4,  4,  4,  4,  4,  4,
                                5,  5,  5};

void makeNeighborhood(float r, int n){
  ArrayList n_x2 = new ArrayList();
  ArrayList n_y2 = new ArrayList();
  for(float j = -floor(r) - 1.0; j < floor(r) + 1.0; j++){
    for(float i = -floor(r) - 1.0; i < floor(r) + 1.0; i++){
      if (!(i == 0 && j == 0) && sqrt(sq(i) + sq(j)) <= r){
        n_x2.add(new Integer((int)(i)));
        n_y2.add(new Integer((int)(j)));
      }
    }
  }
  
  if(n == 0){
    n0_x = new int[n_x2.size()];
    n0_y = new int[n_y2.size()];
  } else if(n == 1){
    n1_x = new int[n_x2.size()];
    n1_y = new int[n_y2.size()];
  } else if(n == 2){
    n2_x = new int[n_x2.size()];
    n2_y = new int[n_y2.size()];
  }
  
  Iterator it_x = n_x2.iterator();
  Iterator it_y = n_y2.iterator();
  int i = 0;
  while(it_x.hasNext()){
    if(n == 0){
      n0_x[i] = ((Integer)(it_x.next())).intValue();
      n0_y[i] = ((Integer)(it_y.next())).intValue();
    } else if(n == 1){
      n1_x[i] = ((Integer)(it_x.next())).intValue();
      n1_y[i] = ((Integer)(it_y.next())).intValue();
    } else if(n == 2){
      n2_x[i] = ((Integer)(it_x.next())).intValue();
      n2_y[i] = ((Integer)(it_y.next())).intValue();
    }
    i++;
  }
  
}

int[] d2_n_x = n1_x;
int[] d2_n_y = n1_y;

boolean d3_big_neighborhoods_dominate = true;
int[][] d3_n_x = {n0_x, n0_x, n1_x, n2_x}; // zero argument doesn't matter
int[][] d3_n_y = {n0_y, n0_y, n1_y, n2_y}; // zero argument doesn't matter

void durrett_0_spread(){
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      
      boolean spread_into = false;
      float n_count = 0;
      int n =0;
      while(n < n0_x.length && !spread_into){
        int n_i = (i + n0_x[n] + grid_width) % grid_width;
        int n_j = (j + n0_y[n] + grid_height) % grid_height;
        if(durrett_grid[n_i][n_j] == 0) {
          n_count++;
          spread_into = true;
        }
        
        n++;
      }  
      
      if(spread_into) durrett_grid_new[i][j] = 0;
    }
  }
}

void durrett_1_spread(){
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      
      if(durrett_grid[i][j] == 1){
        
        for(int n = 0; n < n1_x.length; n++){
          float p_disperse = random(1f);
          if(p_disperse < durrett_delta){
            int n_i = (i + n1_x[n] + grid_width) % grid_width;
            int n_j = (j + n1_y[n] + grid_height) % grid_height;
            durrett_grid_new[n_i][n_j] = 1;
          }
          
        }
        
      }
      
    }
  }
}

void initDurrettBands(int s0, int s1){
  int band_width = grid_height / 2;
  int[] ds = {s0, s1};
  for (int n = 0; n < ds.length; n++){
    for(int j = n*band_width; j < (n+1)*band_width; j++){
      for(int i = 0; i < grid_width; i++){
        durrett_grid[i][j] = ds[n];
        durrett_grid_new[i][j] = ds[n];
      }
    }
  }
}