Es schneit! - OpenProcessing

Hauptprogramm
xxxxxxxxxx
 
int[][] now; // aktueller Zustand des Spielfeldes
int[][] then; // nächster Zustand des Spielfeldes
​
int MAXV = 80; // dann gibt es pro Zeile/Spalte die Felder 0 bis MAXV-1
int FSIZE = 8; // Größe eines Feldes in Pixeln
​
int i; // oft benutzte Zähl-
int j; // variablen
​
void setup()
{
  size(MAXV * FSIZE, MAXV * FSIZE); // das Spielfeld ist quadratisch
  //noStroke();
  now = new int[MAXV][MAXV];
  then = new int[MAXV][MAXV];
  initialisiere_Spielfeld();
}
​
// ----------------------------------------------------
​
void initialisiere_Spielfeld() // hier wird das Spielfeld gefüllt,
{                              // wie auch immer -> EDITIEREN
  for (i = 0; i < MAXV; i++)
  {
    for (j = 0; j < MAXV; j++)
    {
      now[i][j] = 0; // im Grundbeispiel sind alle Felder 0
    }
  }
  now[0][0] = 1;
}
​
// ----------------------------------------------------
​
void draw() // Zeichenroutine, normalerweise nicht editieren
{
  for (i = 0; i < MAXV; i++)
  {
    for (j = 0; j < MAXV; j++)
    {
      zeichne_ein_Feld(i, j);
    }
  }
  berechne_Folgezustand();
  kopiere_um();
}
​
// ----------------------------------------------------
​
void berechne_Folgezustand() // hier steckt das Regelwerk drin -> EDITIEREN
{                            // (i. d. R. aber nur innerhalb der j-Schleife)
  int above;
  int under;
  int left;
  int right;
  int moore_e;
  int moore_q;
  int moore_y;
  int moore_c;
  int me;
  int next_me;
  
  for (i = 0; i < MAXV; i++)
  {
    for (j = 0; j < MAXV; j++)
    {
      above = now[i][j-1];
      under = now[i][j+1];
      
      left = feldwert(i-1, j);
      right = feldwert(i+1, j);
      moore_e = feldwert(i+1, j-1);
      moore_q = feldwert(i-1, j-1);
      moore_y = feldwert(i-1, j+1);
      moore_c = feldwert(i+1, j+1);
      
      next_moore_e = moore_e;
      next_moore_q = moore_q;
      
      if(j == 0) {
        moore_e = 0;
        moore_q = 0;
        above = 0;
      }
      
      me = now[i][j];
      
      next_me = me;
      
      blocked = (under == 1 || j == MAXV-1);
      not_blocked = !blocked;
      
      if (me == 0) {
        if (above == 1) {
          next_me = 1;
        }
      } else if (me == 1) {
        if (not_blocked) {
          next_me = 0;
        }
      }
      
      then[i][j] = next_me;
    }
  }
  
  then[(int) random(0, MAXV)][0] = 1;
}
​
// ----------------------------------------------------
​
void zeichne_ein_Feld(int x0, int y0) // wie ein Feld sich mit
{                                              // seinem Wert darstellt -> EDITIEREN
  val = now[x0][y0];
  
  if (now[x0][y0] == 0)
  {
    fill(0);
    rect(x0*FSIZE,y0*FSIZE,FSIZE+1,FSIZE+1);
  }
  if (now[x0][y0] == 1)
  {
    fill(255);
    rect(x0*FSIZE,y0*FSIZE,FSIZE+1,FSIZE+1);
  }
}
​
// ----------------------------------------------------
​
void kopiere_um() // die Umkopier-Routine -> nicht editieren
{
  for (i = 0; i < MAXV; i++)
  {
    for (j = 0; j < MAXV; j++)
    {
      now[i][j] = then[i][j];
    }
  }
}
​
// ----------------------------------------------------
​
int feldwert(int fx, int fy) // liefert den Wert eine Feldes, korrigiert dabei 
{                            // mit der kkw-Funktion ungültige Koordinaten
  fx = kkw(fx);
  fy = kkw(fy);
  return now[fx][fy];
}
​
// ----------------------------------------------------
​
int kkw(int koordinatenwert) // korrigiert einen Koordinatenwert ("faltet die Welt um") -> nicht editieren
{
  if (koordinatenwert < 0)
  {
    return kkw(koordinatenwert + MAXV);
  }
  else if (koordinatenwert >= MAXV)
  {
    return kkw(koordinatenwert - MAXV);
  }
  else
  {
    return koordinatenwert;
  }
}
​
// ----------------------------------------------------
​
// experimentell:
int nw(int fx, int fy, char richtung) // liefert den Wert eines Nachbarfeldes
{                                     //    Q  W  E
  int nx = fx;                        //    A     S   <- Richtungen
  int ny = fy;                        //    Y  X  C 
                                      // -> normalerweise nicht editieren
  if (richtung == 'q') {
    nx = kkw(fx - 1);
    ny = kkw(fy - 1);
  }
  if (richtung == 'w') {
    ny = kkw(fy - 1);
  }
  if (richtung == 'e') {
    nx = kkw(fx + 1);
    ny = kkw(fy - 1);
  }
  if (richtung == 'a') {
    nx = kkw(fx - 1);
  }
  if (richtung == 'd') {
    nx = kkw(fx + 1);
  }
  if (richtung == 'y') {
    nx = kkw(fx - 1);
    ny = kkw(fy + 1);
  }
  if (richtung == 'x') {
    ny = kkw(fy + 1);
  }
  if (richtung == 'c') {
    nx = kkw(fx + 1);
    ny = kkw(fy + 1);
  }
​
  return now[nx][ny];
}