Cellular Automata - OpenProcessing

sketch181139
xxxxxxxxxx
 
int caWidth = 150;
int caHeight = 150;
​
// der zellulaere Automat
boolean[][] ca = new boolean[caHeight] [caWidth];
​
// Das Regelwerk
boolean[] ruleset = new boolean[8];
​
boolean randomEdge = true;
​
void setup() {
  size(1920, 1920);
  noSmooth();
​
  // Regelwerk erstellen
  createRuleset();
​
  // alle Zellen des Automaten mit Zufallswerten befÃ¼llen
  createCA();
  frameRate(20);
}
​
void draw() {
​
  // alle Zeilen um eins nach oben schieben
  moveRowsUp();
​
  // neue, letzte Zeile erstellen
  setLastRow();
​
  // alles zeichen
  drawCA();
}
​
void drawCA() {
​
  // Breite und Hoehe der Rechtecke berechnen
  float rectWidth = (float) width / caWidth;
  float rectHeight = (float) height / caHeight;
​
  // ca[][] vertikal ablaufen
  int y = 0;
  while (y < caHeight) {
​
    // ca[][] horizontal ablaufen
    int x = 0;
    while (x < caWidth) {
      noStroke();
​
      // wenn ca[i][j] true ist dann wird das Rechteck mit #ffedbc eingefarbt, 
      // sonst mit der anderen Farbe
      if (ca[y][x]) {
        fill(random(256));
      } else {
        fill(random(100));
      }
​
      // Rechteck zeichnen
      rect(x * rectWidth, y * rectHeight, rectWidth, rectHeight);
​
      x = x + 1;
    }
    y = y + 1;
  }
}
​
/**
 * Die Funktion gibt zufaellig true oder false zurueck
 */
boolean getRandomBoolean() {
  // Am Anfang hat die Variable immer den Wert true
  boolean value = true;
​
  // Wenn die Zufallszahl kleiner als 50 ist, dann wir der 
  // Wert der Variable auf true gesetzt
  // Dieser Fall wird in ungefaehr 50% der Faelle eintreten
  if (random(0, 100) < 50) {
    value = false;
  }
​
  // Der Wert wird zurueckgegeben
  return value;
}
​
/**
 * Die Funktion schiebt alle Zeilen um eine Zeile nach oben.
 * Dadurch wird die nullte Zeile geloescht.
 */
void moveRowsUp() {
​
  // ueber alle Zeilen von ca[][] iterieren
  int y = 0;
  while (y < caHeight - 1) {
​
    // aktuelle Zeile mit der naechsten Zeile ueberschreiben
    ca[y] = ca[y + 1];
    y = y + 1;
  }
}
​
​
/**
 * Die Funktion fuellt alle Arrayeintraege des 
 * ruleset[] Arrays mit zufaelligen Werten.
 */
void createRuleset() {
​
  // ueber alle Arrayeintraege iterieren
  int i = 0;
  while (i < ruleset.length) {
​
    // Arrayeintrag mit Zufallswert befuellen
    ruleset[i] = getRandomBoolean();
    i = i + 1;
  }
}
​
void setLastRow() {
  // Zeilennummer im ca[][]-Array, welche ueberschrieben werden soll
  int y = caHeight - 1;
​
  // neues boolean-Array erstellen
  boolean[] newRow = new boolean[caWidth];
​
  /* 
   * In weiter unten folgenden Schleife werden alle Arrayeintraege von newRow[] befuellt.
   * Ausgenommen sind dabei der erste und letzte Arrayeintrag (diese bleiben in der Schleife
   * leer). Daher werden diese beiden Array-Eintraege hier mit zufaelligen Werten bzw Werte 
   * aus dem ca[][]-Array befuellt
   */
  if (randomEdge) {
    newRow[0] = getRandomBoolean();
    newRow[caWidth - 1] = getRandomBoolean();
  } else {
    newRow[0] = ca[y][0];
    newRow[caWidth - 1] = ca[y][caWidth - 1];
  } 
​
  /*
   * Ueber das neu erstellte boolean-Array iterieren.
   * Dabei werden jeweils die Werte in der letzten ca[][]-Array Zeile an der
   * aktuellen x-Position betrachtet sowie der rechte und der linke Nachbar davon.
   * Basierend auf dem rulset[] und den aktuellen Werten aus dem ca[][]-Array in der letzen
   * Zeile werden die Arrayeintraege des neu erstellen newRow[]-Arrays befuellt.
   * 
   * Da der linke Nachbar des 0. Elementes -1 wÃ¤re und es kein -1. Element gibt, beginnt die
   * Schleife an Stelle 1.
   */
  int x = 1; // Zaehlvariable
  while (x < caWidth - 1) {
​
    boolean c1 = ca[y][x - 1];      // linke Nachbarzelle
    boolean c2 = ca[y][x];          // aktuelle Zelle
    boolean c3 = ca[y][x + 1];      // rechte Nachbarzelle
​
    /* 
     * je nachdem, welche Kombination das aktuelle Element mit seinen Nachbarn hat,
     * wird entschieden, welche Regel angewandt wird. Die Regel ist dabei nichts anderes
     * als ein boolean Wert, der den aktuellen boolean der aktuellen Zelle ueberschreibt. 
     * Beispiel:
     * c1 und c2 und c3 sind alle true, daher wird ruleset[0] (Regel 0) angewandt
     * Regel 0 beinhaltet zum Beispiel false
     * Daher wird der Wert der aktuellen Zelle mit false ueberschrieben
     */
    if (c1 && c2 && c3) {
      newRow[x] = ruleset[0];
    } else if (c1 && c2 && !c3) {
      newRow[x] = ruleset[1];
    } else if (c1 && !c2 && c3) {
      newRow[x] = ruleset[2];
    } else if (!c1 && c2 && c3) {
      newRow[x] = ruleset[3];
    } else if (!c1 && !c2 && c3) {
      newRow[x] = ruleset[4];
    } else if (!c1 && c2 && !c3) {
      newRow[x] = ruleset[5];
    } else if (c1 && !c2 && !c3) {
      newRow[x] = ruleset[6];
    } else if (!c1 && !c2 && !c3) {
      newRow[x] = ruleset[7];
    }
​
    // Zaehlvariable erhoehen
    x = x + 1;
  }
​
  // letzte Zeile in ca-Array mit der neu erstellen Zeile (newRow) ueberschreiben
  ca[y] = newRow;
}
​
​
​
void createCA() {
​
  // ca[][] vertikal ablaufen
  int y = 0;
  while (y < caHeight) {
​
    // Neues Array erstellen. Dieses Array wird eine Zeile des ca[][] Arrays ueberschreiben.
    boolean[] newRow = new boolean[caWidth];
​
    // ca[][] hotizontal ablaufen
    int x = 0;
    while (x < caWidth) {
​
      // Arrayeintrag mit Zufallswert befuellen
      newRow[x] = getRandomBoolean();
​
      x = x + 1;
    }
​
    // Zeile des ca[][] Arrays mit newRow[] Array ueberschreiben
    ca[y] = newRow;
    y = y + 1;
  }
}
​
void mousePressed() {
​
  // Regelwerk erstellen
  createRuleset();
​
  // alle Zellen des Automaten mit Zufallswerten befÃ¼llen
  createCA();
}
​
void keyPressed() {
  randomEdge = !randomEdge;
  println("random Edge: " + randomEdge);
}
​