ArrayList leuchtenListe = new ArrayList();                             // Initialisiert die Liste der Leuchten
ArrayList oblichterListe = new ArrayList();                            // Initialisiert die Liste der Oblichter
ArrayList fixLeuchtenListe = new ArrayList();                          // Initialisiert die Liste der FixLeuchten
ArrayList punkteListe = new ArrayList();                               // Initialisiert die Liste der Punkte
ArrayList elektrikerListe = new ArrayList();                           // Initialiserit die Liste der Elektriker

void setup()
{
  size(SIZE_WIDTH, SIZE_HEIGHT);                                        // Bestimmt die Fenstergrösse
  frameRate(RATE);                                                      // Bestimmt die Abspielgeschwindigkeit
  fillArray();                                                          // Füllt den Array mit 0 und 9 Werten [Hintergrundinformation]
  
  for (int i=0; i<anzahlLeuchten; i++)                                  // Erstellt i Leuchten ..
  {
    MovingLight newLeuchte = new MovingLight(10*(int)random(1,(int)(SIZE_WIDTH-10)/10),10*(int)random(1,(int)(SIZE_HEIGHT-10)/10), 10, 10,20,20);
    leuchtenListe.add(newLeuchte);                                      // .. und fügt alle der Liste hinzu
  }
  
  for (int i=0; i<anzahlOblichter; i++)                                 // Erstellt i Oblichter ..
  {
    Oblicht newOblicht = new Oblicht(10*(int)random(1,((int)(SIZE_WIDTH-BIG_LIGHT_SIDELENGHT)/10)-1), 10*(int)random(1,((int)(SIZE_HEIGHT-BIG_LIGHT_SIDELENGHT)/10)-1), BIG_LIGHT_SIDELENGHT, BIG_LIGHT_SIDELENGHT,20,20);
    oblichterListe.add(newOblicht);                                     // .. und füht alle der Liste hinzu
  }
  
  for (int i=0; i<anzahlFixLeuchten; i++)                               // Erstell i FixLeuchten; eigendtlich keine, da in Variablen i=0 stehen sollte
  {
    FixLight newFixLeuchte = new FixLight(0,0,10,10,punkteListe);
    fixLeuchtenListe.add(newFixLeuchte);
  }
  
  for (int i=0; i<anzahlElektriker; i++)
  {
    Elektriker newElektriker = new Elektriker(10*(int)random(1,(int)(SIZE_WIDTH-10)/10), 10*(int)random(1,(int)(SIZE_HEIGHT-10)/10), 10 ,10, 20, 20);
    elektrikerListe.add(newElektriker);
  }
}

void draw()
{
  background(0);
  deckenPlatten();                                                      // Zeichnet die Deckenplatten    
  //unterKonstruktion();
  println(rasterPosition[(int)(mouseX/ARRAY_SIZE_X)][(int)(mouseY/ARRAY_SIZE_Y)]);  // Gibt im Outputfenster die Wertigkeit des Arrays an, für jedes Feld das "unter der Maus" liegt
      
  for (int i=0; i<oblichterListe.size(); i++)
  {
    Oblicht currOblicht = (Oblicht) oblichterListe.get(i);              // Zeichnet die Oblichter
    currOblicht.move();
  }
  
  for (int i=0; i<leuchtenListe.size(); i++)
  {
    MovingLight currLeuchte = (MovingLight) leuchtenListe.get(i);       // Zeichnet die Leuchte
    currLeuchte.move();
  }
  
  for (int i=0; i<fixLeuchtenListe.size(); i++)
  {
    FixLight currFixLeuchte = (FixLight) fixLeuchtenListe.get(i);       // Zeichnet die FixLeuchten
    currFixLeuchte.paintMe();
  }
  
  for (int i=0; i<elektrikerListe.size(); i++)
  {
    Elektriker currElektriker = (Elektriker) elektrikerListe.get(i);    // Zeichnet die Elektriker
    currElektriker.move();
  }
  
  for (int i=0; i<punkteListe.size(); i++)
  {
    Punkt currPunkt = (Punkt) punkteListe.get(i);
    currPunkt.move();
  }
  
  MovingLight ausgewaehlteLeuchte = findClosestLeuchte(mouseX, mouseY); // Findet die Ausgewählte Leuchte
  if (ausgewaehlteLeuchte != null)                                      // Wenn sie ausgwählt ist..
  {                                                                     // Erhält sie eine Markierung
    ausgewaehlteLeuchte.markierung();
  }
}


//********************************************************************************

void fillArray()                                                        // Funktion Array füllen >> Liefert die Hintergrundinformation
{                                                                       // Die Kanten des Fensters werden jeweils mit einer Wertigkeit von 9 gefüllt..
  for(int i=0; i<(int)SIZE_WIDTH/ARRAY_SIZE_X; i++)                     // ..alle Elemente wissen, dass sie 9 nicht besetzen dürfen. 9 ist eine Grenze
  {                                                                     // i >> Alle Werte in X-Richtung
    for(int j=0; j<(int)SIZE_HEIGHT/ARRAY_SIZE_Y; j++)                  // j >> Alle Werte in Y-Richtung
    {
      rasterPosition[i][j] = N_FREE;                                    // Alle Arrays werden grundsätzlich auf "leer" gestellt
      rasterPosition[0][j] = N_MASSIVE;                                 // Der Rand oben wird auf 9 gesetzt
      rasterPosition[i][0] = N_MASSIVE;                                 // Der Rand links wird auf 9 gesetzt
      rasterPosition[((int)SIZE_WIDTH/ARRAY_SIZE_X)-1][j] = N_MASSIVE;  // Der Rand rechts wird auf 9 gesetzt
      //rasterPosition[i][20] = N_MASSIVE;                                // Der Unterzug_1 wird auf 9 gesetzt
      //rasterPosition[i][40] = N_MASSIVE;                                // Der Unterzug_2 wird auf 9 gewetzt
      rasterPosition[i][((int)SIZE_HEIGHT/ARRAY_SIZE_Y)-1] = N_MASSIVE; // Der Rand unten wird auf 9 gesetzt
    }
  } 
}


//********************************************************************************

void createLeuchteAtMousePos()                                          // Zeichne einen Ball an der Mausposition
{
  int mX = 10*((int)(mouseX/10));                                       // xPosition Maus
  int mY = 10*((int)(mouseY/10));                                       // yPosition Maus
  MovingLight newLeuchte = new MovingLight(mX, mY,10, 10,20,20);        // zeichne einen neuen Ball
  leuchtenListe.add(newLeuchte);                                        // füge ihn in der Liste hinzu
  //println("ein neuer ball wurde gebaut.");                            // bestätigt in der Ausgabe, dass ein neuer Ball gezeichnet wurde
}


//********************************************************************************

void deleteLeuchteAtMousePos()                                          // lösche den Ball
{
  MovingLight leuchteToDelete = findClosestLeuchte(mouseX, mouseY);     // löschen den nächsten Ball, um das ganze nicht ein zweites Mal zu schreiben wird die Funktion von oben aufgerufen
  
  leuchtenListe.remove(leuchteToDelete);                                // ersetze den Ball in der Liste
}


//********************************************************************************

void deleteLeuchtenAtPosition (float x, float y, ArrayList liste)
{
  ArrayList loeschListe = new ArrayList();
  loeschListe = findLeuchte(x, y, liste);
  for (int i=0; i<loeschListe.size(); i++)
  {
    liste.remove(loeschListe.get(i));
  }
}


//********************************************************************************

ArrayList findLeuchte(float x, float y, ArrayList liste)                 // Finde den nächsten Ball(x und y werden von oben (mouseX und mouseY) genommen
{
  ArrayList loeschListe = new ArrayList();
  for (int i=0; i<liste.size(); i++)                                     // Aufruf, dass jeder Ball überprüft wird
  {
    Light currLeuchte = (Light) liste.get(i);                            // Jede "Leuchte" wird überprüft
    if (currLeuchte.getX() == x && currLeuchte.getY() == y)              // Wenn die xPosition und die yPosition übereinstimmen
    {
      loeschListe.add(currLeuchte);                                      // ..wird diese Leuchte der loeschListe hinzugefü
    }
  }
  return loeschListe;                                                    // Diese neu gefüllte Liste muss zurückgegeben werden
}


//********************************************************************************

MovingLight findClosestLeuchte(float x, float y)                         // Finde den nächsten Ball(x und y werden von oben (mouseX und mouseY) genommen
{
  float minDistance=0;                                                   // Erste Distanz wird mit 0 gefüllt
  int index=0;
  
  for (int i=0; i<leuchtenListe.size(); i++)                             // Aufruf, dass jeder Ball überprüft wird
  {
    MovingLight currLeuchte = (MovingLight) leuchtenListe.get(i);        // Jede "MovingLight" wird überprüft
    float dX = currLeuchte.getX() - x;                                   // dX ist der Abstand x-Richtung von der "MovingLight" zu x
    float dY = currLeuchte.getY() - y;                                   // dY ist der Abstand y-Richtung vom der "MovingLight" zu y
    float distanceSqr = dX*dX + dY*dY;                                   // ist das Quadrat von der Distanz zwischen x,y "MovingLight" und x,y Maus
    if (distanceSqr < minDistance || i==0)                               // Wenn die Distanz kleiner ist, als der vorherige Wert, Dann:
    {
      minDistance = distanceSqr;                                         // ..ersetze den Wert
      index = i;                                                         // damit merkt er sich die Position der "MovingLight" in der Liste
    }
  }
  if (leuchtenListe.size()==0) return null;
  else return (MovingLight) leuchtenListe.get(index);                    // Diese neu gefüllte Liste muss zurückgegeben werden
}


//********************************************************************************

void mouseReleased()                                                     // Mausfunktionen
{
  if (mouseButton == LEFT)                                               // Wenn die Linke Maustaste gedrückt wird, dann wird die Funktion neue Leuchte ausgeführt
  {
    createLeuchteAtMousePos();
  }
  else if (mouseButton == RIGHT)                                         // Wenn die Rechte Maustaste gedrückt wird, dann wird die Funktion lösche Leuchte ausgeführt
  {
    deleteLeuchteAtMousePos();
  }
}


//********************************************************************************

void deckenPlatten()                                                     // Zeichnet die Plattenstruktur im Hintergrund
{                                                                        // 2 for-Schleifen zeichnen jeweils 3 Rechtecke in X und Y Richtung verschoben
  // Zeichnet das Wesentliche: Das Plattenraster
  noFill();                                                              // Die Funktion wird im void draw() aufgerufen
  strokeWeight(0);
  stroke(50);
  for(int i=0; i<SIZE_WIDTH/10; i++)
  {
    for(int j=0; j<SIZE_HEIGHT/30+1; j++)
    {
      rect(30*i,-20+j*30,10,30);
      rect(30*i+10,-10+j*30,10,30);
      rect(30*i+20,0+j*30,10,30);
    }
  }
  
  // Zeichnet das Unwesentliche: Den schwarzen Trägerrahmen
  noStroke();
  fill(0);
  rect(0,0,ARRAY_SIZE_X, SIZE_HEIGHT);
  rect(0,0,SIZE_WIDTH, ARRAY_SIZE_Y);
  rect(0,SIZE_HEIGHT - 10, SIZE_WIDTH, SIZE_HEIGHT);
  rect(SIZE_WIDTH - 10, 0, SIZE_WIDTH, SIZE_HEIGHT);
  noFill();
  stroke(100);
  rect(ARRAY_SIZE_X, ARRAY_SIZE_Y, SIZE_WIDTH - 2*ARRAY_SIZE_X, SIZE_HEIGHT - 2*ARRAY_SIZE_Y);
}

//********************************************************************************

/*
void unterKonstruktion()                                                 // Zeichnet die Plattenstruktur im Hintergrund
{                                                                        // 2 for-Schleifen zeichnen jeweils 3 Rechtecke in X und Y Richtung verschoben
  noFill();                                                              // Die Funktion wird im void draw() aufgerufen
  strokeWeight(0);
  stroke(255,0,0);
  rect(ARRAY_SIZE_X, ARRAY_SIZE_Y, sizeB - 2*ARRAY_SIZE_X, sizeH - 2*ARRAY_SIZE_Y);
}
*/