import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.lang.*;
import javax.swing.border.*;

/***********************************************************************************/
class Casella
  {
    boolean viva,futuro;
    Rectangle r;

//----------------------------------------------------------------------
    Casella(int i, int j, int l)
      {
        viva = false;
        futuro = false;
        r = new Rectangle(i*l,j*l,l,l);
      }
  }

/***********************************************************************************/
class Schema

{
  int n_c, n_r, l;
  Casella[][] s;

//----------------------------------------------------------------------
  Schema(int nc, int nr, int lt)
    {
      n_c = nc;
      n_r = nr;
      l = lt;
      s = new Casella[nc][nr];
      for (int i=0;i<nc;i++)
        for (int j=0;j<nr;j++)
          s[i][j]=new Casella(i,j,l);
    }

//----------------------------------------------------------------------
  void Azzera()
    {
      if (s==null) return;
      for (int i=0;i<n_c;i++)
        for (int j=0;j<n_r;j++)
          {
            s[i][j].viva = false;
            s[i][j].futuro = false;
          };
    }
}

/***********************************************************************************/
class Pannello
extends JPanel

{
  int n_c, n_r,l;
  Schema s;

  Pannello(int nc, int nr, int lato)
    {
      setPreferredSize(new Dimension(360,360));
      n_c=nc;
      n_r=nr;
      l = lato;
    }    

//----------------------------------------------------------------------
  public void paint(Graphics g)
    {
      Casella c;
      Rectangle r;
                                
      setBackground(Color.green);
      super.paintComponent(g);
      if (s==null) return;
      for (int i=0;i<n_c;i++)
        for (int j=0;j<n_r;j++)
          {
            c=s.s[i][j];
            g.setColor(Color.black);
            r = c.r;
            g.drawRoundRect(r.x,r.y,r.width,r.height,l/2,l/2);
            if (c.viva) g.setColor(Color.red);
            else g.setColor(Color.white);
            g.fillRoundRect(r.x+1,r.y+1,r.width-2,r.height-2,l/2,l/2);
          }
    }

//----------------------------------------------------------------------
  void setParametri(int nc, int nr, int lato, Schema schema)
    {
      n_c = nc;
      n_r = nr;
      l = lato;
      s = schema;
    }
}

/***********************************************************************************/
class Sfondo
extends JPanel

{
   Sfondo()
     {
       setPreferredSize(new Dimension(420,420));
       setBackground(Color.green);
     }
}

/***********************************************************************************/
class Messaggio
extends JPanel

{
  Border blackline;
  TitledBorder border;
 
  Messaggio(String intestazione)
    {
      Font font = new java.awt.Font("Verdana",Font.PLAIN,10);
      blackline = BorderFactory.createLineBorder(Color.black);
      border = BorderFactory.createTitledBorder(blackline,intestazione);
      border.setTitleJustification(TitledBorder.CENTER);
      border.setTitlePosition(TitledBorder.DEFAULT_POSITION);
      border.setTitleFont(font);
      setBorder(border);
      setBackground(Color.yellow);
      setLayout(new FlowLayout(FlowLayout.CENTER,0,0));
      setPreferredSize(new Dimension(40,36));
    }
}

/***********************************************************************************/
public class Vita
extends JApplet
implements ActionListener

{
  static final int MAX_DIM = 50;
  Container client;
  Timer timer;
  Pannello pannello;
  Sfondo sfondo;
  JPanel messaggi;
  Messaggio mess_stato, mess_vive;
  JLabel lb_stato, lb_vive;
  int lato, n_righe, n_colonne, n_vive, n_iniziali, intervallo, conta;
  static boolean distribuzione,evoluzione;
  Schema schema;
  int[][] vicina;

//----------------------------------------------------------------------
  public static void main(String args[])
    {
      JFrame f = new JFrame("VITA");

      Container fc = f.getContentPane();

      f.addWindowListener
         (
           new WindowAdapter()
             {
               public void windowClosing(WindowEvent e)
                 {
                   if (evoluzione)
                     {
                       return;
                     }
                   else
                     System.exit(0);
                 }
             }
         );
      Vita applet = new Vita();
      applet.init();
      fc.add(applet);
      f.pack();
      f.setVisible(true);
    }

//----------------------------------------------------------------------
  JMenuBar creaMenu()
    {
      JMenuBar result = new JMenuBar();
      result.setBackground(Color.cyan);
      
      JMenu m_parametri = new JMenu("Parametri");
      m_parametri.setBackground(Color.cyan);
      m_parametri.setMnemonic(KeyEvent.VK_P); 

      JMenuItem mi_n_righe = new JMenuItem("N. di Righe",KeyEvent.VK_R);
      mi_n_righe.setActionCommand("11");
      mi_n_righe.addActionListener(this);
      m_parametri.add(mi_n_righe);

      JMenuItem mi_n_colonne = new JMenuItem("N. di Colonne",KeyEvent.VK_C);
      mi_n_colonne.setActionCommand("12");
      mi_n_colonne.addActionListener(this);
      m_parametri.add(mi_n_colonne);

      JMenuItem mi_n_vive = new JMenuItem("Celle inizialmente vive",KeyEvent.VK_V);
      mi_n_vive.setActionCommand("13");
      mi_n_vive.addActionListener(this);
      m_parametri.add(mi_n_vive);

      JMenuItem mi_intervallo = new JMenuItem("Intervallo (ms) ",KeyEvent.VK_I);
      mi_intervallo.setActionCommand("14");
      mi_intervallo.addActionListener(this);
      m_parametri.add(mi_intervallo);
      
      result.add(m_parametri);
 
      JMenu m_inizio = new JMenu("Inizio");
      m_inizio.setBackground(Color.cyan);
      m_inizio.setMnemonic(KeyEvent.VK_I);

      JMenuItem mi_casuale = new JMenuItem("Casuale",KeyEvent.VK_C);
      mi_casuale.setActionCommand("21");
      mi_casuale.addActionListener(this);
      m_inizio.add(mi_casuale);

      JMenuItem mi_manuale = new JMenuItem("Manuale",KeyEvent.VK_M);
      mi_manuale.setActionCommand("22");
      mi_manuale.addActionListener(this);
      m_inizio.add(mi_manuale); 

      result.add(m_inizio);

      JMenu m_evoluzione = new JMenu("Evoluzione");
      m_evoluzione.setBackground(Color.cyan);
      m_evoluzione.setMnemonic(KeyEvent.VK_E);

      JMenuItem mi_avvio = new JMenuItem("Avvio",KeyEvent.VK_A);
      mi_avvio.setActionCommand("31");
      mi_avvio.addActionListener(this);
      m_evoluzione.add(mi_avvio);

      result.add(m_evoluzione);

      return result;
    }
//---------------------------------------------------------------
  public void init()
    {
      n_righe = 20;
      n_colonne = 20;
      lato = MisuraLato();
      n_vive = 0;
      n_iniziali = n_righe*n_colonne/2;
      distribuzione = false;
      evoluzione = false;
      intervallo = 500;
      vicina = new int[8][2];
      timer = new Timer(intervallo, this);
      timer.setCoalesce(true);
      setJMenuBar(creaMenu());

      client = getContentPane();
      Font font = new java.awt.Font("Verdana",Font.PLAIN,10);
      messaggi = new JPanel(null);
      messaggi.setLayout(new BoxLayout(messaggi,BoxLayout.X_AXIS));
      mess_stato = new Messaggio("Stato");
      lb_stato = new JLabel("stato",JLabel.CENTER);
      lb_stato.setFont(font);
      mess_stato.add(lb_stato);
      
      mess_vive = new Messaggio("Celle vive");
      lb_vive = new JLabel("vive",JLabel.CENTER);
      lb_vive.setFont(font);
      mess_vive.add(lb_vive);

      messaggi.add(mess_stato);
      messaggi.add(mess_vive);

      pannello = new Pannello(n_righe,n_colonne,lato);
      pannello.addMouseListener
        (
          new MouseAdapter()
            {
              public void mousePressed(MouseEvent e)
                {
                  if (evoluzione)
                    {
                      evoluzione = false;
                      stopAnimation();
                      return;
                    };
                  if (distribuzione)
                    {
                      StatoCella(e.getX(),e.getY());
                    };
                }
            }
        );

      Border vuoto = BorderFactory.createEmptyBorder(8,8,8,8);
      sfondo = new Sfondo();
      sfondo.setBorder(vuoto);
      sfondo.setLayout(new BoxLayout(sfondo,BoxLayout.Y_AXIS));
      sfondo.add(messaggi);
      sfondo.add(Box.createRigidArea(new Dimension(0,4)));
      sfondo.add(pannello);

      client.add(sfondo);
    }
//---------------------------------------------------------------
  public void stop()
    {
      stopAnimation();
    }
//-----------------------------------------------------------------------
  public void StatoCella(int X, int Y)
    {
      Insets insets = pannello.getInsets();

      int x=X-insets.left;
      int y=Y-insets.top;
      int i=x/lato, j=y/lato;
      if ((i>n_colonne-1)||(j>n_righe-1)) return;
      schema.s[i][j].viva = !schema.s[i][j].viva;
      if (schema.s[i][j].viva) n_vive++;
      else n_vive--;
      distribuzione = (n_vive<n_iniziali);
      lb_vive.setText(" "+n_vive);
      lb_stato.setText(" "+conta);
      sfondo.repaint();
    }

//-----------------------------------------------------------------------
  public void startAnimation()
    {
      if (evoluzione)
        if (!timer.isRunning())
          {
            timer.start();
          }
    }
//-------------------------------------------------------------------------
  public void stopAnimation()
    {
      evoluzione = false;
      if (timer.isRunning())
        {
          timer.stop();
        }
    }

//---------------------------------------------------------------
  int leggeIntero(String s)
    {
      int result=0;
      if (s==null) return 0;
      try
        {
          Integer r = new Integer(s);
          result = r.intValue();
        }
      catch(ArithmeticException e)
        {
          result = 0;
        };
      return result;
    }
//---------------------------------------------------------------
  public void actionPerformed(ActionEvent e)
    {
      if (evoluzione)
        {
          Scenario();
          return;
        };
      sfondo.setVisible(false);
      String aux$;
      int aux;
      String azione$= e.getActionCommand();
      int azione = Integer.parseInt(azione$);
      switch (azione)
        {
          case 11:
            aux$ = String.valueOf(n_righe);
            aux$ = JOptionPane.showInputDialog(this,"Numero di righe?",aux$);
            aux  = leggeIntero(aux$);
            if (aux>0) n_righe=aux;
            if (n_righe>MAX_DIM) n_righe=MAX_DIM;
            pannello.setParametri(n_colonne, n_righe, lato, schema);
            break;
          case 12:
            aux$ = String.valueOf(n_colonne);
            aux$ = JOptionPane.showInputDialog(this,"Numero di colonne?",aux$);
            aux  = leggeIntero(aux$);
            if (aux>0) n_colonne=aux;
            if (n_colonne>MAX_DIM) n_colonne=MAX_DIM;
            pannello.setParametri(n_colonne, n_righe, lato, schema);
            break;
          case 13:
            aux$ = String.valueOf(n_iniziali);
            aux$ = JOptionPane.showInputDialog(this,"Celle inizialmente vive",aux$);
            aux  = leggeIntero(aux$);
            if (aux>0) n_iniziali=aux;
            pannello.setParametri(n_colonne, n_righe, lato, schema);            
            break;
          case 14:
            aux$ = String.valueOf(intervallo);
            aux$ = JOptionPane.showInputDialog(this,"Intervallo? (ms)",aux$);
            aux  = leggeIntero(aux$);
            if (aux>0) intervallo=aux;
            timer.setDelay(intervallo);
            pannello.setParametri(n_colonne, n_righe, lato, schema);            
            break;
          case 21:
            InizioCasuale();
            break;
          case 22:
            InizioManuale();
            break;
          case 31:
            Evoluzione();
            break;
          default:
            JOptionPane.showMessageDialog(this,"Caso non previsto.");
        };
    }   
//-------------------------------------------------------------------
  int NCasuale(int max)
    {
      return((int)Math.round(Math.floor(max*Math.random())));
    }

//-------------------------------------------------------------------
  int MisuraLato()
    {
      int lc = 360/n_colonne;
      int lr = 360/n_righe;
      int ris=lc;
      if (lr<lc) ris=lr;
      return ris;
    }

//---------------------------------------------------------------------------
  void NuovoSchema()
    {                              
      n_vive=0;
      conta = 0;
      lato = MisuraLato();
      schema = new Schema(n_colonne, n_righe, lato);
    }
//---------------------------------------------------------------
  void InizioCasuale()
    {
      int i,j;
      if (n_iniziali>n_righe*n_colonne)
        {
          JOptionPane.showMessageDialog(this,"Numero di cellule eccessivo. Diminuire.");
          return;
        };
      distribuzione=false;
      
      NuovoSchema();
      do
        {
          i = NCasuale(n_colonne);
          j = NCasuale(n_righe);
          if ( !schema.s[i][j].viva)
            {
              schema.s[i][j].viva=true;
              n_vive++;
            }
        } while(n_vive<n_iniziali);
      pannello.setParametri(n_colonne, n_righe, lato, schema);
      lb_vive.setText(" "+n_vive);
      lb_stato.setText(" "+conta);
      sfondo.setVisible(true);
      sfondo.repaint();
    }

//---------------------------------------------------------------
  void InizioManuale()
    {
      NuovoSchema();
      pannello.setParametri(n_colonne, n_righe, lato, schema);
      sfondo.setVisible(true);
      sfondo.repaint();
      distribuzione = true;
    }

//---------------------------------------------------------------------------
  public void Evoluzione()
    {
      evoluzione = false;
      if (n_vive<1)
        {
          JOptionPane.showMessageDialog(this,"Inizializzare la simulazione.");
          return;
        };
      if (n_vive>n_righe*n_colonne)
        {
          JOptionPane.showMessageDialog(this,"Numero di cellule eccessivo. Diminuire.");
          return;
        };
      evoluzione = true;
      distribuzione=false;
      for (int i=0; i<n_colonne; i++)
        for (int j=0; j<n_righe; j++) schema.s[i][j].futuro = schema.s[i][j].viva;
      sfondo.setVisible(true);
      sfondo.repaint();
      conta = -1;
      timer.setInitialDelay(0);
      timer.start();
    }
//-------------------------------------------------------------------------------
  public void Scenario()
    {     
      Casella c;
      int i,j, v;
      
      pannello.repaint();
      conta++;
      n_vive = 0;
      for (i=0; i<n_colonne; i++)
        for (j=0; j<n_righe; j++)
          {
            schema.s[i][j].viva = schema.s[i][j].futuro;
            if (schema.s[i][j].viva) n_vive++;
          };
      for (i=0; i<n_colonne; i++)
        for (j=0; j<n_righe; j++ )
          {
            v = SommaVicine(i,j);
            c = schema.s[i][j];
            if (c.viva)
              {
                if ((v!=2)&&(v!=3))
                  schema.s[i][j].futuro = false;
              }
            else
              {
                if (v==3)
                  schema.s[i][j].futuro = true;
              };
          };
      lb_vive.setText(" "+n_vive);
      lb_stato.setText(" "+conta);
    }

//---------------------------------------------------------------
  int SommaVicine(int i, int j)
    {

/*
Data la cella (i,j), si girano le celle circostanti a partire da quella
in alto a sinistra
  012
  7 3
  654
*/

      int cs,cd,ri,rs,k, result = 0;
      cs = (i == 0)? n_colonne-1: i-1;
      cd = (i == n_colonne-1)? 0: i+1;
      ri = (j == 0)? n_righe-1  : j-1;
      rs = (j == n_righe-1)?   0: j+1;
      vicina[0][0] = ri;   vicina[0][1] = cs;  //riga inf. col. sin.
      vicina[1][0] = ri;   vicina[1][1] = i;   //riga inf. col. stessa
      vicina[2][0] = ri;   vicina[2][1] = cd;  //riga inf. col. destra
      vicina[3][0] = j;    vicina[3][1] = cd;  //stessa riga, col. destra
      vicina[4][0] = rs;   vicina[4][1] = cd;  //riga sup. col. destra
      vicina[5][0] = rs;   vicina[5][1] = i;
      vicina[6][0] = rs;   vicina[6][1] = cs;
      vicina[7][0] = j;    vicina[7][1] = cs;
      for (k=0; k<8; k++)
        if (schema.s[vicina[k][1]][vicina[k][0]].viva) result++;
      return(result);
    }
}