Topics: Cellular Automata

Do the exercises in order. Note: following the steps outlined below is required for credit — achieving the end result by some other means will not count.

Read through all of each exercise before you start on it. In particular, note that the "to do this" steps are what you should actually do to complete the exercise — don't just read the first sentence of the problem, look at the example, and try to write the sketch from there. Follow the steps!

Put your name and a description of the sketch in comments at the beginning of each sketch. Also don't forget to Auto Format your code before handing it in.

Be sure to save your sketch frequently (ctrl-S). (Every time you run your sketch is good.) The editor does not auto-save!

Create a new sketch, add a comment with your name and a description of the sketch, and save it with the name elementaryCA.

Add code to open a drawing window and clear the background to white.

Set up the array of cells as described in the slides:

• Declare an animation variable named cells which is a boolean array.
• Initialize cells to have width/10 cells. (This is done once — put it in setup().)
• Initialize each slot of cells to be false, then set the middle slot (cells[cells.length/2] to be true. (This will be done in each frame — put it in draw().)

Define the rule set: declare and initialize an animation variable

  boolean[] ruleset = { false, true, false, true, true, false, true, false };

draw() will generate and draw all of the generations of the CA. Start with just drawing the current generation: as described in the slides, write the loop for drawing one row. Use the standard going-through-an-array loop as the starting point — add the x coordinate to that as an additional loop variable. Make the rectangles 10x10, outline each rectangle in black, and hardcode the y position so that the row of rectangles is at the top of the window. When this step is complete, you should be able to run your sketch and see the initial generation (all cells white except for the middle one) displayed at the top of the drawing window.

Wrap the "draw one row" loop with a loop to repeat drawing rows as described in the slides, but with only the loop variable for the y coordinate of the row — the result of this step should be a sketch which fills the drawing window with copies of the initial generation.

Add the "compute the next generation" step:

• Put the (buggy) code from the "computing the next generation" slide at the end of the body of the "draw one row" loop, after the part that draws the current generation.
• Fix the edge case wrinkle using either the "edges remain constant" or the "edges wrap around" option as described in the slides. At this point you should be able to run the sketch without it crashing, but the pattern displayed may not be correct.
• Fix the inconsistent update wrinkle by using a separate array for the next generation as described in the slides.

When this step is complete, you should have a working sketch which displays the Sierpinski triangle pattern.

Modify the sketch to start with a random initial configuration so you can see this behavior: comment out the lines where you set the middle cell to true and the others to false (this means to put // at the beginning of each of those lines to keep them in the program but remove them from execution) and instead initialize each cell to true or false randomly. The slides on initialization options for elementary CAs show how to make a choice with equal probability — set the current cell to true in the if part and false in the else part.

Note: because the cells are initialized in draw() instead of setup(), to keep the picture stable, it is necessary to ensure that the same random initial configuration is used in each frame: add the statement

  randomSeed(0);

just before you initialize all the cells of the array. You can replace 0 with another value — the particular value given to randomSeed doesn't matter, just that the same value is given to it each time.

Create a new sketch, add a comment with your name and a description of the sketch, and save it with the name gameoflife.

Add code to open a drawing window and clear the background to white.

Set up the 2D array of cells as described in the slides:

• Declare an animation variable named cells which is a 2D boolean array.
• Initialize cells to have height/10 rows and width/10 columns. (This is done once — put it in setup().)
• Initialize each slot of cells to true or false randomly. (This will be done once — put it in setup().)

In draw(), draw the current generation of the CA as described in the slides. Start with the nested go-through-every-slot-of-a-2D-array loop pattern, then add the x and y coordinate loop variables to that framework. When this step is complete, you should be able to see the randomly-initialized initial generation of the CA.

Add the "compute the next generation" step at the end of draw(), after the current generation is drawn:

• Start with the nested go-through-every-slot-of-a-2D-array loop pattern.
• In the body of the loop, add the code to count the number of living neighbors as described in the slides, then compute the new state based on the Game of Life rules given in the slides and update cells[i][j] accordingly. Don't worry about the two wrinkles (edge cases and inconsistent updates) yet.
• Fix the edge case wrinkle using either the "edges remain constant" or the "edges wrap around" option similar to what you did for the elementary 1D CA. At this point you should be able to run the sketch without it crashing, but the pattern displayed may not be correct.
• Fix the inconsistent update wrinkle by using a separate array for the next generation similar to what you did for the elementary 1D CA.

When this step is complete, you should have a working Game of Life sketch, though it probably runs very quickly.

To slow the evolution of the CA down, put the statement

  frameRate(10);

in setup(). This adjusts the speed of the animation so that draw() is only called 10 times per second instead of the usual 60.

Finally, add code so that clicking the mouse resets the CA to a new random initial configuration.

Since the fire simulation is also a 2D cellular automaton, you can use your Game of Life sketch as a starting point: save that sketch with the name firesim, then update the comment (in firesim!) to accurately describing this sketch.

Each cell in the fire simulation has three possible states instead of just two: change the cells variable to be an array of ints instead of booleans. (This means changing types from boolean to int.) A value of 0 will represent an empty cell, a value of 1 will represent a tree, and a value of 2 will represent a burning tree.

Update the initialization and click-to-reset code to set the starting value of each cell as follows:

  if ( random(1.0) < 0.8 ) {  // probability of a tree
    if ( random(1.0) < 0.01 ) { // probability of burning
      cells[i][j] = 2;  // burning
    } else {
      cells[i][j] = 1;  // tree
    }
  } else {
    cells[i][j] = 0;  // empty
  }

This sets up a scenario where each cell has a 80% chance of starting off as a tree, and each tree cell has a 1% chance of starting off as a burning tree.

Update the drawing code to correctly set the color: empty cells should be yellow, tree cells should be green, and burning cells should be reddish brown. You can use the color selector (Tools → Color Selector...) to pick appropriate colors.

Update the "compute the next generation" code to use the rules described in class (and in the slides). Use a p_catch of 0.8 (a tree has an 80% chance of catching fire if it has at least one burning neighbor).

Experiment with some other probabilities to see how this affects the spread of the fire: try various combinations of 0.2, 0.5, and 0.8 for the probability of a cell being initialized to a tree and 0.2, 0.5, and 0.8 for the probability of a tree catching fire if it has a burning neighbor. What do you observe?