// Globale Variabeln


int Breite = 800;                                    // Breite des Fensters
int Hoehe = 600;                                     // Hšhe des Fensters
int AnzSpalten = 2 + 2;                              // Anzahl Spalten des Rasters
int AnzZeilen = 2 + 2;                               // Anzahl Spalten des Rasters
float FeldBreite = Breite / (AnzSpalten-2);          // Breite eines Feldes
float FeldHoehe = Hoehe / (AnzZeilen-2);             // Hšhe eines Feldes

color Hintergrund = color (255);                     // Hintergrundfarbe
color FensterColor = color (255);                    // Farbe Fenster
color RahmenColor = FensterColor;                    // Farbe Fenster
color FensterStroke = color (200);                   // Farbe Fensterumriss
color c1wachsen = color (255);                       // Farbe Kreis innen im Wachstum
color c2wachsen = color (200, 160, 80);              // Farbe Kreis Mitte im Wachstum
color c3wachsen = color (150, 120, 50);              // Farbe Kreis aussen im Wachstum
color c1fertig = color (255);                        // Farbe Kreis innen fertige Zelle
color c2fertig = color (180, 180, 80);               // Farbe Kreis Mitte fertige Zelle
color c3fertig = color (130, 130, 50);               // Farbe Kreis aussen fertige Zelle

int AnzahlOeffnungen = 3;                            // Anzahl …ffnungen total
int minAbstand = 50;                                 // min. Abstand zwischen zwei …ffnungen
int minB = 50;                                       // min. Fensterbreite
int maxB = 200;                                      // max. Fensterbreite
float Rahmenbreite = 5;                              // Breite Fensterrahmen

int AnzahlZellen = 1400;                              // Anzahl Zellen
float Rand = 2;                                      // Rand der Šusseren Kreise
float minR = 2;                                      // minimaler Radius einer Zelle
float minA = 3;                                      // minimaler Abstand, darunter = berŸhrt

int o = 1;                                           // Anzal neue Zellen pro Frame
int m = 5;                                           // Anzal Wachstumsrunden pro Durchgang
float f = 0.05;                                      // Wachstum pro Durchgang
float g = f*4;                                       // Verschiebung pro Durchgang

int n = 0;                                           // ZŠhler gezeichnete Zelle
int AnzahlFertigeZellen = 0;                         // ZŠhler fertige Zellen
int ZaehlerOeffnungen = 0;                           // ZŠhler gezeichnete …ffnungen

boolean schlaufen = false;                           // "draw" stoppen/starten Ÿber Mausklick

Zelle [] meineZelle = new Zelle [AnzahlZellen];
Oeffnung [] meineOeffnung = new Oeffnung [AnzahlOeffnungen];
Feld [] meinFeld = new Feld [AnzSpalten*AnzZeilen];

//----------------------------------------------------------------------------------------------------
// Initialisierung
//----------------------------------------------------------------------------------------------------

import processing.pdf.*;

void setup()
{
  size (Breite, Hoehe);
  // frameRate (5);
  background (Hintergrund);

  for (int s = 0; s < AnzSpalten; s++) {                 // Felder generieren
    for (int z = 0; z < AnzZeilen; z++){
      meinFeld [z*AnzSpalten + s] = new Feld (s, z);                         
    }
  }
  
  for (int i=0; i < AnzahlOeffnungen; i++) {             // Oeffnungen generieren und zeichnen
    meineOeffnung [i] = new Oeffnung ();
    ZaehlerOeffnungen++;
    meineOeffnung [i].zeichnen ();
  }

  meineZelle [0] = new Zelle ();                         // erste Zelle generieren und zeichnen
  meineZelle [0].zeichnen ();
  
  noLoop ();
  
}

//----------------------------------------------------------------------------------------------------
// Frame fŸr Frame wiederholt
//----------------------------------------------------------------------------------------------------

void draw ()
{
  println (n);
  
  for (int j = 1; j <= m; j++)                // m-mal wachsen, bevor eine neue Zelle generiert wird
  {
    for (int i = 0; i <= n; i++)             // alle bestehenden Zellen "durchschlaufen"
    {
      meineZelle [i].entwickeln ();    
    }
  }

  if (n < AnzahlZellen-o-1)                // schlaufen, falls Anzahl Zellen noch nicht erreicht ist
  {
    for (int i = 0; i < o; i++) {          // o neue Zellen pro Frame
      n++;
      meineZelle [n] = new Zelle ();         // neue Zelle generieren
      meineZelle [n].zeichnen ();            // generierte Zelle zeichnen
    }
  } 
}