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



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[] d2_n_x = n1_x;
int[] d2_n_y = n1_y;




int[][] durrett2_grid = new int[grid_width][grid_height];
int[][] durrett2_grid_new = new int[grid_width][grid_height];

float d2_alph = 2.0/3.0;
float d2_beta = 2; // why the hell is this 2? it is only ever used as (d2_beta - 1), 
                   // which makes sense since it's a probability, from 0-1.


void d2_occupy_vacancies(){
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      
      if(durrett2_grid[i][j] == 0){
        float[] f_n = new float[4];
        float f_w = 1f/(float)(d2_n_x.length);
        for(int n = 0; n < d2_n_x.length; n++){
          int n_i = (i + d2_n_x[n] + grid_width) % grid_width;
          int n_j = (j + d2_n_y[n] + grid_height) % grid_height;
          
          
          f_n[durrett2_grid[n_i][n_j]] += f_w;
        
        }
        
        float dice_roll = random(1f);
        float p_sum = 0;
        int contender = 0;
        int winner = 0;
        while(dice_roll > p_sum && contender < f_n.length){
          p_sum += f_n[contender];
          if( dice_roll > p_sum) {
            contender++;
          } else {
            winner = contender;
          }
        }
        
        durrett2_grid_new[i][j] = winner;
      }
    }
  }
}

void d2_spread(){
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      
      if(durrett2_grid[i][j] != 0){
        int s = durrett2_grid[i][j];
        // choose a neighbor
        float n_dice_roll = random(1f);
        int n = (int)(floor(n_dice_roll * (float)(d2_n_x.length)));
        // decide whether or not to colonize (or attack)
        float c_dice_roll = random(1f);
        if(c_dice_roll < (d2_beta-1)){
          int n_i = (i + d2_n_x[n] + grid_width) % grid_width;
          int n_j = (j + d2_n_y[n] + grid_height) % grid_height;
          int n_s = durrett2_grid[n_i][n_j];
          //is it occupied by a type this one dominates?
          if(n_s != 0 && s == n_s+1 || (s == 1 && n_s == 3)){
            // then kill it or replace it
            float k_dice_roll = random(1f);
            if(k_dice_roll > (1 - d2_alph)/(d2_beta - 1)){
              durrett2_grid_new[n_i][n_j] = 0;
            } else {
              durrett2_grid_new[n_i][n_j] = s;
            }
          }
        }
        
        
      }
      
    }
  }
}

void initD2Single(int s){
  
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      durrett2_grid[i][j] = 0;
      durrett2_grid_new[i][j] = 0;
    }
  }
  
  durrett2_grid[grid_width/2][grid_height/2] = s;
  durrett2_grid_new[grid_width/2][grid_height/2] = s;

}

void initD2Collide(int s1, int s2){
  
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      durrett2_grid[i][j] = 0;
      durrett2_grid_new[i][j] = 0;
    }
  }
  
  for(int i = 0; i < grid_width; i++){
    durrett2_grid[i][0] = s1;
    durrett2_grid_new[i][0] = s1;
    durrett2_grid[i][grid_height/2] = s2;
    durrett2_grid_new[i][grid_height/2] = s2;
  }
}

void initD2AllThree(){
  
  for(int j = 0; j < grid_height; j++){
    for(int i = 0; i < grid_width; i++){
      durrett2_grid[i][j] = 0;
      durrett2_grid_new[i][j] = 0;
    }
  }
  
  for(int i = 0; i < grid_width; i++){
    durrett2_grid[i][0] = 1;
    durrett2_grid_new[i][0] = 1;
    durrett2_grid[i][grid_height/3] = 2;
    durrett2_grid_new[i][grid_height/3] = 2;
    durrett2_grid[i][2*grid_height/3] = 3;
    durrett2_grid_new[i][2*grid_height/3] = 3;
  }
}