import java.util.Random;
import java.awt.*;

public class Spielfeld
{
   Feld[][] f;
   int neuX, neuY;
   int runde;
   int breite, hoehe;

   Random wuerfel;
   int zahlL,    zahlK;
   int zahlLAlt, zahlKAlt;
   int faktL,    faktK;

   public Spielfeld(int b, int h)
   {
      wuerfel = new Random();
      runde  = 0;
      breite = b; 
      hoehe  = h;
      if (breite * hoehe <= 40)
      {
          faktL = 10; faktK = 10;
      }
      else if (breite * hoehe <= 80)
      {
          faktL =  5; faktK = 5;
      }
      else if (breite * hoehe <= 120)
      {
          faktL =  3; faktK = 4;
      }
      else 
      {
          faktL =  2; faktK = 2;
      }


      f = new Feld[breite][hoehe];

      for (int y = 0; y < hoehe; y++)
         for (int x = 0; x < breite; x++)
         {
             int z = wuerfel.nextInt(6);
             if (z <= 2)             
                f[x][y] = new Feld(x,y,z);
             else
                f[x][y] = new Feld(x,y,0);
         }

   }

   public void zeigen(Graphics g, int zeitindex)
   {
      zahlLAlt = zahlL;
      zahlKAlt = zahlK;
      zahlL    = 0; 
      zahlK    = 0;

      if (runde == 0)
         zeichnePapier(g);

      for (int y = 0; y < hoehe; y++)
         for (int x = 0; x < breite; x++)
         {
             f[x][y].zeigen(g);

             int t = f[x][y].gibTyp();
             if(t == 1) zahlL++; else
             if(t == 2) zahlK++; 
         }

   // Blattlaeuse zeichnen und Punkte verbinden
      g.setColor(Color.GREEN);
      g.fillOval(20+zeitindex,780-zahlL*faktL,3,3);
      g.drawLine(20+zeitindex-1,780-zahlLAlt*faktL,20+zeitindex,780-zahlL*faktL);

      g.setColor(Color.BLACK);
      g.drawOval(20+zeitindex,780-zahlL*faktL,3,3);

   // Marienkaefer zeichnen und Punkte verbinden
      g.setColor(Color.RED);
      g.fillOval(20+zeitindex,780-zahlK*faktK,3,3);
      g.drawLine(20+zeitindex-1,780-zahlKAlt*faktK,20+zeitindex,780-zahlK*faktK);

      g.setColor(Color.BLACK);
      g.drawOval(20+zeitindex,780-zahlK*faktK,3,3);

      runde++;
   }

   public void zeichnePapier(Graphics g)
   {
      g.setColor(Color.WHITE);
      g.fillRect(20,380,760,405);

      g.setColor(new Color(220,220,191));
      for (int x = 20; x < 780; x+=10)
          g.drawLine(x,780,x,380);
      for (int y = 380; y < 780; y+=10)
          g.drawLine(20,y,780,y);
      g.drawRect(20,380,760,400);
   }

   public void lausWeiter()
   {
      wuerfeln();

   // Regel 1: 
   // Trifft die Blattlaus auf ein leeres Feld, so wird ein Blattlaus-Kaertchen 
   // auf dieses Feld gelegt.
      if (f[neuX][neuY].gibTyp() == 0)
          f[neuX][neuY].setzeTyp(1);

   // Regel 2
   // Trifft die Blattlaus auf ein bereits von Blattlaeusen besetztes Feld, 
   // so wird ein Blattlaus-Kaertchen auf ein freies angrenzendes Feld gelegt.
      else if (f[neuX][neuY].gibTyp() == 1)
      {
      // oben frei ?
         if ((neuY > 0) && (f[neuX][neuY-1].gibTyp() == 0))
            f[neuX][neuY-1].setzeTyp(1);
         else
      // unten frei ?
         if ((neuY < hoehe-1) && (f[neuX][neuY+1].gibTyp() == 0))
            f[neuX][neuY+1].setzeTyp(1);
         else
      // links frei ?
         if ((neuX > 0) && (f[neuX-1][neuY].gibTyp() == 0))
            f[neuX-1][neuY].setzeTyp(1);
         else
      // rechts frei ?
         if ((neuX < breite-1) && (f[neuX+1][neuY].gibTyp() == 0))
            f[neuX+1][neuY].setzeTyp(1);
      }

   // Regel 3
   // Trifft die Blattlaus auf ein von Marienkaefern besetztes Feld, so passiert nichts.
      else if (f[neuX][neuY].gibTyp() == 2)
      {
      // nothing...
      }
   }

 public void kaeferWeiter()
   {
      wuerfeln();

   // Regel 1
   // Trifft der Marienkaefer auf ein leeres oder ein eigenes Feld, 
   // so muss er eine seiner Kaertchen vom Spielfeld nehmen.
      if (f[neuX][neuY].gibTyp() == 0)  // leeres Feld
      {
         for (int y = 0; y < hoehe; y++)
            for (int x = 0; x < breite; x++)
               if (f[x][y].gibTyp() == 2)
               {
                  f[x][y].setzeTyp(0);
                  return;
               }
      }
      else if (f[neuX][neuY].gibTyp() == 2)  // mit Marienkaefer besetzt
          f[neuX][neuY].setzeTyp(0);

   // Regel 2
   // Trifft der Marienkaefer auf ein von Blattlaeusen besetztes Feld, 
   // so wird das Blattlaus-Kaertchen vom Spielfeld genommen und durch ein 
   // Marienkaefer-Kaertchen ersetzt.
      else if (f[neuX][neuY].gibTyp() == 1)  // mit Blattlaeusen besetzt
         f[neuX][neuY].setzeTyp(2);
   }

   private void wuerfeln()
   {
      neuX = wuerfel.nextInt(breite);
      neuY = wuerfel.nextInt(hoehe);
   }

   private int zahlLaeuse()
   {
      return zahlL;
   }

   private int zahlKaefer()
   {
      return zahlK;
   }


}