L8onWallace.pde

   1 class L8onLife extends SCPattern {
   2   // Controls the rate of life algorithm ticks, in milliseconds
   3   private BasicParameter rateParameter = new BasicParameter("DELAY", 112.5, 0.0, 1000.0);
   4   // Controls the probability of a mutation in the cycleOfLife
   5   private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1);
   6   // Controls the saturation.
   7   private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0);
   8
   9   public final double MIN_ALIVE_PROBABILITY = 0.2;
  10   public final double MAX_ALIVE_PROBABILITY = 0.9;
  11
  12   public final float MAX_ALIVE_BRIGHTNESS = 90.0;
  13
  14   private final SawLFO cubePos = new SawLFO(0, model.cubes.size(), 4000);
  15
  16   class CubeState {
  17      // Index of cube in glucose.model.cubes
  18      public Integer index;
  19      // Boolean which describes if cube is alive.
  20      public boolean alive;
  21      // Boolean which describes if strip was just changed;
  22      public boolean just_changed;
  23      // Current brightness
  24      public float current_brightness;
  25      // List of this cubes neighbors
  26      public List<Integer> neighbors;
  27
  28      public CubeState(Integer index, boolean alive, float current_brightness, List<Integer> neighbors) {
  29        this.index = index;
  30        this.alive = alive;
  31        this.current_brightness = current_brightness;
  32        this.neighbors = neighbors;
  33      }
  34   }
  35
  36   // Contains the state of all cubes by index.
  37   private List<CubeState> cube_states;
  38   // Contains the amount of time since the last cycle of life.
  39   private int time_since_last_run;
  40   // Boolean describing if life changes were made during the current run.
  41   private boolean any_changes_this_run;
  42   // Hold the new lives
  43   private List<Boolean> new_lives;
  44
  45   public L8onLife(LX lx) {
  46      super(lx);
  47
  48      //Print debug info about the cubes.
  49      //outputCubeInfo();
  50
  51      initCubeStates();
  52      time_since_last_run = 0;
  53      any_changes_this_run = false;
  54      new_lives = new ArrayList<Boolean>();
  55
  56      addParameter(rateParameter);
  57      addParameter(mutationParameter);
  58      addParameter(saturationParameter);
  59      addModulator(cubePos).trigger();
  60   }
  61
  62   public void run(double deltaMs) {
  63     Integer i = 0;
  64     CubeState cube_state;
  65
  66     any_changes_this_run = false;
  67     new_lives.clear();
  68     time_since_last_run += deltaMs;
  69
  70     for (Cube cube : model.cubes) {
  71       cube_state = this.cube_states.get(i);
  72
  73       if(shouldLightCube(cube_state)) {
  74         lightLiveCube(cube, cube_state, deltaMs);
  75       } else {
  76         lightDeadCube(cube, cube_state, deltaMs);
  77       }
  78
  79       i++;
  80     }
  81
  82     if(!any_changes_this_run) {
  83       randomizeCubeStates();
  84     } else {
  85       applyNewLives();
  86     }
  87
  88     if(time_since_last_run >= rateParameter.getValuef()) {
  89       time_since_last_run = 0;
  90     }
  91   }
  92
  93   public void lightLiveCube(Cube cube, CubeState cube_state, double deltaMs) {
  94     float cube_dist = LXUtils.wrapdistf((float) cube_state.index, cubePos.getValuef(), model.cubes.size());
  95     float hv = (cube_dist / model.cubes.size()) * 360;
  96     float bv = cube_state.current_brightness;
  97
  98     if(!cube_state.just_changed || deltaMs >= rateParameter.getValuef()) {
  99       float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 100       bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS);
 101
 102       if(cube_state.current_brightness < bv) {
 103         cube_state.current_brightness = bv;
 104       } else {
 105         bv = cube_state.current_brightness;
 106       }
 107     }
 108
 109     for (LXPoint p : cube.points) {
 110       colors[p.index] = lx.hsb(
 111         hv,
 112         saturationParameter.getValuef(),
 113         bv
 114       );
 115     }
 116   }
 117
 118   public void lightDeadCube(Cube cube, CubeState cube_state, double deltaMs) {
 119     float cube_dist = LXUtils.wrapdistf((float) cube_state.index, cubePos.getValuef(), model.cubes.size());
 120     float hv = (cube_dist / (float) model.cubes.size()) * 360;
 121     float bv =  cube_state.current_brightness;
 122
 123     if(!cube_state.just_changed || deltaMs >= rateParameter.getValuef()) {
 124       float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 125       bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS);
 126
 127       if(cube_state.current_brightness > bv) {
 128         cube_state.current_brightness = bv;
 129       } else {
 130         bv = cube_state.current_brightness;
 131       }
 132     }
 133
 134     for (LXPoint p : cube.points) {
 135       colors[p.index] = lx.hsb(
 136         hv,
 137         saturationParameter.getValuef(),
 138         bv
 139       );
 140     }
 141   }
 142
 143   public void outputCubeInfo() {
 144     int i = 0;
 145     for (Cube c : model.cubes) {
 146       print("Cube " + i + ": " + c.x + "," + c.y + "," + c.z + "\n");
 147       ++i;
 148     }
 149     print("Edgeheight: " + Cube.EDGE_HEIGHT + "\n");
 150     print("Edgewidth: " + Cube.EDGE_WIDTH + "\n");
 151     print("Channelwidth: " + Cube.CHANNEL_WIDTH + "\n");
 152   }
 153
 154   private void initCubeStates() {
 155     List<Integer> neighbors;
 156     boolean alive = false;
 157     CubeState cube_state;
 158     this.cube_states = new ArrayList<CubeState>();
 159     float current_brightness = 0.0;
 160     Integer i = 0;
 161
 162     for (Cube c : model.cubes) {
 163       neighbors = findCubeNeighbors(c, i);
 164       alive = true;
 165       cube_state = new CubeState(i, alive, current_brightness, neighbors);
 166       this.cube_states.add(cube_state);
 167       ++i;
 168     }
 169   }
 170
 171   private void randomizeCubeStates() {
 172     double prob_range = (1.0 - MIN_ALIVE_PROBABILITY) - (1.0 - MAX_ALIVE_PROBABILITY);
 173     double prob = MIN_ALIVE_PROBABILITY + (prob_range * Math.random());
 174
 175     //print("Randomizing cubes! p = " + prob + "\n");
 176
 177     for (CubeState cube_state: this.cube_states) {
 178       cube_state.alive = (Math.random() <= prob);
 179     }
 180   }
 181
 182   public List<Integer> findCubeNeighbors(Cube cube, Integer index) {
 183     List<Integer> neighbors = new LinkedList<Integer>();
 184     Integer i = 0;
 185
 186     for (Cube c : model.cubes) {
 187       if(index != i)  {
 188         if(abs(c.x - cube.x) < (Cube.EDGE_WIDTH * 2) && abs(c.y - cube.y) < (Cube.EDGE_HEIGHT * 2)) {
 189           //print("Cube " + i + " is a neighbor of " + index + "\n");
 190           neighbors.add(i);
 191         }
 192       }
 193
 194       i++;
 195     }
 196
 197     return neighbors;
 198   }
 199
 200   public boolean shouldLightCube(CubeState cube_state) {
 201     // Respect rate parameter.
 202     if(time_since_last_run < rateParameter.getValuef()) {
 203       any_changes_this_run = true;
 204       cube_state.just_changed = false;
 205       return cube_state.alive;
 206     } else {
 207       boolean new_life = cycleOfLife(cube_state);
 208       new_lives.add(new_life);
 209       return new_life;
 210     }
 211   }
 212
 213   public void applyNewLives() {
 214     int index = 0;
 215     for(boolean liveliness: new_lives) {
 216       CubeState cube_state = this.cube_states.get(index);
 217       cube_state.alive = new_lives.get(index);
 218       index++;
 219     }
 220   }
 221
 222   public boolean cycleOfLife(CubeState cube_state) {
 223     Integer index = cube_state.index;
 224     Integer alive_neighbor_count = countLiveNeighbors(cube_state);
 225     boolean before_alive = cube_state.alive;
 226     boolean after_alive = before_alive;
 227     double mutation = Math.random();
 228
 229     if(cube_state.alive) {
 230       if(alive_neighbor_count < 2 || alive_neighbor_count > 3) {
 231         after_alive = false;
 232       } else {
 233         after_alive = true;
 234       }
 235
 236     } else {
 237       if(alive_neighbor_count == 2) {
 238         after_alive = true;
 239       } else {
 240         after_alive = false;
 241       }
 242     }
 243
 244     if(mutation <= mutationParameter.getValuef()) {
 245       after_alive = !after_alive;
 246     }
 247
 248     if(before_alive != after_alive) {
 249       cube_state.just_changed = true;
 250       any_changes_this_run = true;
 251     }
 252
 253     return after_alive;
 254   }
 255
 256   public Integer countLiveNeighbors(CubeState cube_state) {
 257     Integer count = 0;
 258     CubeState neighbor_cube_state;
 259
 260     for(Integer neighbor_index: cube_state.neighbors) {
 261        neighbor_cube_state = this.cube_states.get(neighbor_index);
 262        if(neighbor_cube_state.alive) {
 263          count++;
 264        }
 265     }
 266
 267     return count;
 268   }
 269 }
 270
 271 class L8onAutomata extends SCPattern {
 272   // Controls the rate of life algorithm ticks, in milliseconds
 273   private BasicParameter rateParameter = new BasicParameter("DELAY", 75.0, 0.0, 1000.0);
 274   // Controls the probability of a mutation in the cycleOfStripperLife
 275   private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1);
 276   // Controls the rate of life algorithm ticks, in milliseconds
 277   private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0);
 278
 279   private final SawLFO pointPos = new SawLFO(0, model.points.size(), 8000);
 280
 281   public final double MIN_ALIVE_PROBABILITY = 0.2;
 282   public final double MAX_ALIVE_PROBABILITY = 0.9;
 283
 284   public final float MAX_ALIVE_BRIGHTNESS = 90.0;
 285
 286   class PointState {
 287      // Index of cube in glucose.model.cubes
 288      public Integer index;
 289      // Boolean which describes if cube is alive.
 290      public boolean alive;
 291      // Boolean which describes if strip was just changed;
 292      public boolean just_changed;
 293      // Current brightness
 294      public float current_brightness;
 295
 296      public PointState(Integer index, boolean alive, float current_brightness) {
 297        this.index = index;
 298        this.alive = alive;
 299        this.current_brightness = current_brightness;
 300        this.just_changed = false;
 301      }
 302   }
 303
 304   // Contains the state of all cubes by index.
 305   private List<PointState> point_states;
 306   // Contains the amount of time since the last cycle of life.
 307   private int time_since_last_run;
 308   // Boolean describing if life changes were made during the current run.
 309   private boolean any_changes_this_run;
 310   // Hold the new lives
 311   private List<Boolean> new_states;
 312
 313   public L8onAutomata(LX lx) {
 314      super(lx);
 315
 316      //Print debug info about the cubes.
 317      //outputCubeInfo();
 318
 319      initPointStates();
 320      randomizePointStates();
 321      time_since_last_run = 0;
 322      any_changes_this_run = false;
 323      new_states = new ArrayList<Boolean>();
 324
 325      addParameter(mutationParameter);
 326      addParameter(rateParameter);
 327      addParameter(saturationParameter);
 328      addModulator(pointPos).trigger();
 329   }
 330
 331   private void initPointStates() {
 332     boolean alive = true;
 333     PointState point_state;
 334     this.point_states = new ArrayList<PointState>();
 335     Integer i = 0;
 336     float current_brightness = 0.0;
 337
 338     for (LXPoint p : model.points) {
 339       point_state = new PointState(i, alive, current_brightness);
 340       this.point_states.add(point_state);
 341       ++i;
 342     }
 343   }
 344
 345   public void run(double deltaMs) {
 346     Integer i = 0;
 347     PointState point_state;
 348
 349     any_changes_this_run = false;
 350     new_states.clear();
 351     time_since_last_run += deltaMs;
 352
 353     for (LXPoint p : model.points) {
 354       point_state = this.point_states.get(i);
 355
 356       if(shouldLightPoint(point_state)) {
 357         lightLivePoint(p, point_state, deltaMs);
 358       } else {
 359         lightDeadPoint(p, point_state, deltaMs);
 360       }
 361       i++;
 362     }
 363
 364     if(!any_changes_this_run) {
 365       randomizePointStates();
 366     } else {
 367       applyNewStates();
 368     }
 369
 370     if(time_since_last_run >= rateParameter.getValuef()) {
 371       time_since_last_run = 0;
 372     }
 373   }
 374
 375   public void lightLivePoint(LXPoint p, PointState point_state, double deltaMs) {
 376     float point_dist = LXUtils.wrapdistf((float) point_state.index, pointPos.getValuef(), model.points.size());
 377     float hv = (point_dist / model.points.size()) * 360;
 378     float bv = point_state.current_brightness;
 379
 380     if(deltaMs >= rateParameter.getValuef() || !point_state.just_changed) {
 381       float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 382       bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS);
 383
 384       if(point_state.current_brightness < bv) {
 385         point_state.current_brightness = bv;
 386       } else {
 387         bv = point_state.current_brightness;
 388       }
 389     }
 390
 391     colors[p.index] = lx.hsb(
 392       hv,
 393       saturationParameter.getValuef(),
 394       bv
 395     );
 396   }
 397
 398   public void lightDeadPoint(LXPoint p, PointState point_state, double deltaMs) {
 399     float point_dist = LXUtils.wrapdistf((float) point_state.index, pointPos.getValuef(), model.points.size());
 400     float hv = (point_dist / model.points.size()) * 360;
 401     float bv = point_state.current_brightness;
 402
 403     if(!point_state.just_changed || deltaMs >= rateParameter.getValuef()) {
 404       float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 405       bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS);
 406
 407       if(point_state.current_brightness > bv) {
 408         point_state.current_brightness = bv;
 409       } else {
 410         bv = point_state.current_brightness;
 411       }
 412     }
 413
 414     colors[p.index] = lx.hsb(
 415       hv,
 416       saturationParameter.getValuef(),
 417       bv
 418     );
 419   }
 420
 421   public boolean shouldLightPoint(PointState point_state) {
 422     // Respect rate parameter.
 423     if(time_since_last_run < rateParameter.getValuef()) {
 424       any_changes_this_run = true;
 425       point_state.just_changed = false;
 426       return point_state.alive;
 427     } else {
 428       boolean new_state = cycleOfAutomata(point_state);
 429       new_states.add(new_state);
 430       return new_state;
 431     }
 432   }
 433
 434   public boolean cycleOfAutomata(PointState point_state) {
 435     Integer index = point_state.index;
 436     Integer alive_neighbor_count = countLiveNeighbors(point_state);
 437     boolean before_alive = point_state.alive;
 438     boolean after_alive = before_alive;
 439     double mutation = Math.random();
 440
 441     if(point_state.alive) {
 442       if(alive_neighbor_count == 1) {
 443         after_alive = true;
 444       } else {
 445         after_alive = false;
 446       }
 447
 448     } else {
 449       if(alive_neighbor_count == 1) {
 450         after_alive = true;
 451       } else {
 452         after_alive = false;
 453       }
 454     }
 455
 456     if(mutation < mutationParameter.getValuef()) {
 457       after_alive = !after_alive;
 458     }
 459
 460     if(before_alive != after_alive) {
 461       any_changes_this_run = true;
 462       point_state.just_changed = true;
 463     }
 464
 465     return after_alive;
 466   }
 467
 468   public int countLiveNeighbors(PointState point_state) {
 469     int count = 0;
 470
 471     if (point_state.index > 0) {
 472       PointState before_neighbor = point_states.get(point_state.index - 1);
 473       if(before_neighbor.alive) {
 474         count++;
 475       }
 476     }
 477
 478     if (point_state.index < (point_states.size() - 1)) {
 479       PointState after_neighbor = point_states.get(point_state.index + 1);
 480       if(after_neighbor.alive) {
 481         count++;
 482       }
 483     }
 484
 485     return count;
 486   }
 487
 488   private void applyNewStates() {
 489     int index = 0;
 490     for(boolean new_state: new_states) {
 491       PointState point_state = this.point_states.get(index);
 492       point_state.alive = new_states.get(index);
 493       index++;
 494     }
 495   }
 496
 497   private void randomizePointStates() {
 498     double prob_range = (1.0 - MIN_ALIVE_PROBABILITY) - (1.0 - MAX_ALIVE_PROBABILITY);
 499     double prob = MIN_ALIVE_PROBABILITY + (prob_range * Math.random());
 500
 501     //print("Randomizing points! p = " + prob + "\n");
 502
 503     for (PointState point_state: this.point_states) {
 504       point_state.alive = (Math.random() <= prob);
 505       point_state.just_changed = true;
 506     }
 507   }
 508 }
 509
 510 class L8onStripLife extends SCPattern {
 511   // Controls the rate of life algorithm ticks, in milliseconds
 512   private BasicParameter rateParameter = new BasicParameter("DELAY", 112.5, 1.0, 1000.0);
 513   // Controls the probability of a mutation in the cycleOfStripperLife
 514   private BasicParameter mutationParameter = new BasicParameter("MUT", 0.000000011, 0.0, 0.1);
 515   // Controls the saturation.
 516   private BasicParameter saturationParameter = new BasicParameter("SAT", 90.0, 0.0, 100.0);
 517
 518   public final double MIN_ALIVE_PROBABILITY = 0.4;
 519   public final double MAX_ALIVE_PROBABILITY = 0.9;
 520
 521   public final float MAX_ALIVE_BRIGHTNESS = 90.0;
 522
 523   private final SawLFO stripPos = new SawLFO(0, model.strips.size(), 8000);
 524
 525   class StripState {
 526      // Index of strip in glucose.model.strips
 527      public Integer index;
 528      // Boolean which describes if strip is alive.
 529      public boolean alive;
 530      // Boolean which describes if strip was just changed;
 531      public boolean just_changed;
 532      // Current brightness
 533      public float current_brightness;
 534      // List of this cubes neighbors
 535      public List<Integer> neighbors;
 536
 537      public StripState(Integer index, boolean alive, float current_brightness, List<Integer> neighbors) {
 538        this.index = index;
 539        this.alive = alive;
 540        this.current_brightness = current_brightness;
 541        this.neighbors = neighbors;
 542        this.just_changed = false;
 543      }
 544   }
 545
 546   // Contains the state of all cubes by index.
 547   private List<StripState> strip_states;
 548   // Contains the amount of time since the last cycle of life.
 549   private int time_since_last_run;
 550   // Boolean describing if life changes were made during the current run.
 551   private boolean any_changes_this_run;
 552   // Hold the new lives
 553   private List<Boolean> new_lives;
 554
 555   public L8onStripLife(LX lx) {
 556      super(lx);
 557
 558      //Print debug info about the strips.
 559      //outputStripInfo();
 560
 561      initStripStates();
 562      randomizeStripStates();
 563      time_since_last_run = 0;
 564      any_changes_this_run = false;
 565      new_lives = new ArrayList<Boolean>();
 566
 567      addParameter(rateParameter);
 568      addParameter(mutationParameter);
 569      addParameter(saturationParameter);
 570
 571      addModulator(stripPos).trigger();
 572   }
 573
 574   public void run(double deltaMs) {
 575     Integer i = 0;
 576     StripState strip_state;
 577
 578     any_changes_this_run = false;
 579     new_lives.clear();
 580     time_since_last_run += deltaMs;
 581
 582     for (Strip strip : model.strips) {
 583       strip_state = this.strip_states.get(i);
 584
 585       if(shouldLightStrip(strip_state)) {
 586         lightLiveStrip(strip, strip_state, deltaMs);
 587       } else {
 588         lightDeadStrip(strip, strip_state, deltaMs);
 589       }
 590       i++;
 591     }
 592
 593     if(!any_changes_this_run) {
 594       randomizeStripStates();
 595     } else {
 596       applyNewLives();
 597     }
 598
 599     if(time_since_last_run >= rateParameter.getValuef()) {
 600       time_since_last_run = 0;
 601     }
 602   }
 603
 604   public void lightLiveStrip(Strip strip, StripState strip_state, double deltaMs) {
 605     float strip_dist = LXUtils.wrapdistf((float) strip_state.index, stripPos.getValuef(), model.strips.size());
 606     float hv = (strip_dist / model.strips.size()) * 360;
 607     float bv = strip_state.current_brightness;
 608
 609     if(deltaMs >= rateParameter.getValuef() || !strip_state.just_changed) {
 610       float bright_prop = min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 611       bv = min(MAX_ALIVE_BRIGHTNESS, bright_prop * MAX_ALIVE_BRIGHTNESS);
 612
 613       if(strip_state.current_brightness < bv) {
 614         strip_state.current_brightness = bv;
 615       } else {
 616         bv = strip_state.current_brightness;
 617       }
 618     }
 619
 620     for (LXPoint p : strip.points) {
 621       colors[p.index] = lx.hsb(
 622         hv,
 623         saturationParameter.getValuef(),
 624         bv
 625       );
 626     }
 627   }
 628
 629   public void lightDeadStrip(Strip strip, StripState strip_state, double deltaMs) {
 630     float strip_dist = LXUtils.wrapdistf((float) strip_state.index, stripPos.getValuef(), model.strips.size());
 631     float hv = (strip_dist / model.strips.size()) * 360;
 632     float bv = strip_state.current_brightness;
 633
 634     if(!strip_state.just_changed || deltaMs >= rateParameter.getValuef()) {
 635       float bright_prop = 1.0 - min(((float) time_since_last_run / rateParameter.getValuef()), 1.0);
 636       bv = max(0.0, bright_prop * MAX_ALIVE_BRIGHTNESS);
 637
 638       if(strip_state.current_brightness > bv) {
 639         strip_state.current_brightness = bv;
 640       } else {
 641         bv = strip_state.current_brightness;
 642       }
 643     }
 644
 645     for (LXPoint p : strip.points) {
 646       colors[p.index] = lx.hsb(
 647         hv,
 648         saturationParameter.getValuef(),
 649         bv
 650       );
 651     }
 652   }
 653
 654   public void outputStripInfo() {
 655     int i = 0;
 656     for (Strip strip : model.strips) {
 657       print("Strip " + i + ": " + strip.cx + "," + strip.cy + "," + strip.cz + "\n");
 658       ++i;
 659     }
 660   }
 661
 662   private void initStripStates() {
 663     List<Integer> neighbors;
 664     boolean alive = false;
 665     float current_brightness = 0.0;
 666     StripState strip_state;
 667     this.strip_states = new ArrayList<StripState>();
 668     Integer i = 0;
 669
 670     int total_neighbors = 0;
 671
 672     for (Strip strip : model.strips) {
 673       neighbors = findStripNeighbors(strip, i);
 674       alive = true;
 675       strip_state = new StripState(i, alive, current_brightness, neighbors);
 676       this.strip_states.add(strip_state);
 677
 678       total_neighbors += neighbors.size();
 679       ++i;
 680     }
 681
 682     float average_neighbor_count = (float) total_neighbors / (float) model.strips.size();
 683     //print("Average neighbor count: " + average_neighbor_count + "\n");
 684   }
 685
 686   private void randomizeStripStates() {
 687     double prob_range = (1.0 - MIN_ALIVE_PROBABILITY) - (1.0 - MAX_ALIVE_PROBABILITY);
 688     double prob = MIN_ALIVE_PROBABILITY + (prob_range * Math.random());
 689
 690     //print("Randomizing strips! p = " + prob + "\n");
 691
 692     for (StripState strip_state : this.strip_states) {
 693       strip_state.alive = (Math.random() <= prob);
 694       strip_state.just_changed = true;
 695     }
 696   }
 697
 698   public List<Integer> findStripNeighbors(Strip strip, Integer index) {
 699     List<Integer> neighbors = new LinkedList<Integer>();
 700     Integer i = 0;
 701     int neighbor_count = 0;
 702     double distance = 0.0;
 703
 704     for (Strip s : model.strips) {
 705       if( (int)index != (int)i )  {
 706         distance = Math.sqrt( Math.pow((s.cx - strip.cx), 2) + Math.pow((s.cy - strip.cy), 2) + Math.pow((s.cz - strip.cz), 2) );
 707
 708         if(distance < ( (double) Cube.EDGE_WIDTH) ) {
 709           //print("Strip " + i + " is a neighbor of " + index + "\n");
 710           neighbors.add(i);
 711         }
 712       }
 713       i++;
 714     }
 715
 716     return neighbors;
 717   }
 718
 719   public boolean shouldLightStrip(StripState strip_state) {
 720     // Respect rate parameter.
 721     if(time_since_last_run < rateParameter.getValuef()) {
 722       any_changes_this_run = true;
 723       strip_state.just_changed = false;
 724       return strip_state.alive;
 725     } else {
 726       boolean new_life = cycleOfStripperLife(strip_state);
 727       new_lives.add(new_life);
 728       return new_life;
 729     }
 730   }
 731
 732   public void applyNewLives() {
 733     int index = 0;
 734     for(boolean liveliness: new_lives) {
 735       StripState strip_state = this.strip_states.get(index);
 736       strip_state.alive = new_lives.get(index);
 737       index++;
 738     }
 739   }
 740
 741   public boolean cycleOfStripperLife(StripState strip_state) {
 742     Integer alive_neighbor_count = countLiveNeighbors(strip_state);
 743     boolean before_alive = strip_state.alive;
 744     boolean after_alive = before_alive;
 745     double mutation = Math.random();
 746
 747     if(strip_state.alive) {
 748       if(alive_neighbor_count < 2 || alive_neighbor_count > 6) {
 749         after_alive = false;
 750       } else {
 751         after_alive = true;
 752       }
 753
 754     } else {
 755       if(alive_neighbor_count == 5) {
 756         after_alive = true;
 757       } else {
 758         after_alive = false;
 759       }
 760     }
 761
 762     if(mutation < mutationParameter.getValuef()) {
 763       after_alive = !after_alive;
 764     }
 765
 766     if(before_alive != after_alive) {
 767       any_changes_this_run = true;
 768       strip_state.just_changed = true;
 769     }
 770
 771     return after_alive;
 772   }
 773
 774   public Integer countLiveNeighbors(StripState strip_state) {
 775     Integer count = 0;
 776     StripState neighbor_strip_state;
 777
 778     for(Integer neighbor_index: strip_state.neighbors) {
 779        neighbor_strip_state = this.strip_states.get(neighbor_index);
 780        if(neighbor_strip_state.alive) {
 781          count++;
 782        }
 783     }
 784
 785     return count;
 786   }
 787 }