# Wolfram Cellular Automata

### byDaniel Shiffman

Simple demonstration of a Wolfram's 1-dimensional cellular automata. When the system reaches bottom of the window, it restarts with a new ruleset. Mouse click restarts as well.

``````/**
* Wolfram Cellular Automata
* by Daniel Shiffman.
*
* Simple demonstration of a Wolfram's 1-dimensional
* cellular automata. When the system reaches bottom
* of the window, it restarts with a new ruleset.
* Mouse click restarts as well.
*/

CA ca; // An instance object to the cellular automata

void setup() {
size(640, 360);
int[] ruleset = {0,1,0,1,1,0,1,0};  // An initial rule system
ca = new CA(ruleset);  // Initialize CA
background(0);
}

void draw() {
ca.render();  // Draw the CA
ca.generate();  // Generate the next level

// If we're done, clear the screen,
// pick a new ruleset and restart
if (ca.finished()) {
background(0);
ca.randomize();
ca.restart();
}
}

void mousePressed() {
background(0);
ca.randomize();
ca.restart();
}
``````
``````class CA {

int[] cells;  // An array of 0s and 1s
int generation;  // How many generations?
int scl;  // How many pixels wide/high is each cell?

int[] rules;  // Array to store the rules, for example {0,1,1,0,1,1,0,1}

CA(int[] r) {
rules = r;
scl = 1;
cells = new int[width/scl];
restart();
}

// Set the rules of the CA
void setRules(int[] r) {
rules = r;
}

// Make a random ruleset
void randomize() {
for (int i = 0; i < 8; i++) {
rules[i] = int(random(2));
}
}

// Reset to generation 0
void restart() {
for (int i = 0; i < cells.length; i++) {
cells[i] = 0;
}
// cell having a state of "1"
cells[cells.length/2] = 1;
generation = 0;
}

// The process of creating the new generation
void generate() {
// First we create an empty array for the new values
int[] nextgen = new int[cells.length];
// For every spot, determine new state by examing current
// state, and neighbor states
// Ignore edges that only have one neighor
for (int i = 1; i < cells.length-1; i++) {
int left = cells[i-1];   // Left neighbor state
int me = cells[i];       // Current state
int right = cells[i+1];  // Right neighbor state
// Compute next generation state based on ruleset
nextgen[i] = executeRules(left,me,right);
}
// Copy the array into current value
for (int i = 1; i < cells.length-1; i++) {
cells[i] = nextgen[i];
}
//cells = (int[]) nextgen.clone();
generation++;
}

// This is the easy part, just draw the cells,
// fill 255 for '1', fill 0 for '0'
void render() {
for (int i = 0; i < cells.length; i++) {
if (cells[i] == 1) {
fill(255);
} else {
fill(0);
}
noStroke();
rect(i*scl,generation*scl, scl,scl);
}
}

// Implementing the Wolfram rules
// Could be improved and made more concise,
// but here we can explicitly see what is going on for each case
int executeRules (int a, int b, int c) {
if (a == 1 && b == 1 && c == 1) { return rules; }
if (a == 1 && b == 1 && c == 0) { return rules; }
if (a == 1 && b == 0 && c == 1) { return rules; }
if (a == 1 && b == 0 && c == 0) { return rules; }
if (a == 0 && b == 1 && c == 1) { return rules; }
if (a == 0 && b == 1 && c == 0) { return rules; }
if (a == 0 && b == 0 && c == 1) { return rules; }
if (a == 0 && b == 0 && c == 0) { return rules; }
return 0;
}

// The CA is done if it reaches the bottom of the screen
boolean finished() {
if (generation > height/scl) {
return true;
} else {
return false;
}
}
}
``````

This example is for Processing 4+. If you have a previous version, use the examples included with your software. If you see any errors or have suggestions, please let us know.