self_product.java

命的一个重要特征就是能够自我繁殖

          alloc (100,3,1,1,1,false);
          xx = yy = max/2;
          break;
    }
}
public void clearundefrules() { // Clearance of undefined rules
      for (int a = 0; a < 9; a ++)
       for (int b = 0; b < 9; b ++)
        for (int c = 0; c < 9; c ++)
         for (int d = 0; d < 9; d ++)
          for (int e = 0; e < 9; e ++) 
           if (rule[a][b][c][d][e] == -1) rule[a][b][c][d][e] = a;
}
public void readLoopAndRules(String loop[], String looprules) {
  for (int i=0,y=max/2; i < loop.length; i++,y++) 
     for (int j=0, x=max/2; j < loop[i].length(); j++,x++) {
        String s =  loop[i].substring(j,j+1);
        if (s.equals(" ")) s = "0";
        grid[cd][x][y] = Integer.parseInt (s);
     }
  int c,t,r,b,l,i;
  for (int len=0; len <looprules.length(); len +=7 )   {
     c = Integer.parseInt(looprules.substring(len  ,len+1));
     t = Integer.parseInt(looprules.substring(len+1,len+2));
     r = Integer.parseInt(looprules.substring(len+2,len+3));
     b = Integer.parseInt(looprules.substring(len+3,len+4));
     l = Integer.parseInt(looprules.substring(len+4,len+5));
     i = Integer.parseInt(looprules.substring(len+5,len+6));
     rule[c][t][r][b][l] = i;     //       T 
     rule[c][l][t][r][b] = i;     //    L  C R   >>=>> I (next state)
     rule[c][b][l][t][r] = i;     //       B
     rule[c][r][b][l][t] = i;     //   (with rotations)
  }
}
public boolean inSheath(int t, int r, int b, int l)
{ int f = 0;
  if ((t == 1) || (t == 2) || (t == 4) || (t == 6) || (t == 7)) f ++;
  if ((r == 1) || (r == 2) || (r == 4) || (r == 6) || (r == 7)) f ++;
  if ((b == 1) || (b == 2) || (b == 4) || (b == 6) || (b == 7)) f ++;
  if ((l == 1) || (l == 2) || (l == 4) || (l == 6) || (l == 7)) f ++;
  return (f > 1) ? true : false;
}
public void set_undefined_rule()  // Sayama's rules
{ int a, b, c, d, e;
  for (a = 0; a < 9; a ++)
   for (b = 0; b < 9; b ++)
    for (c = 0; c < 9; c ++)
     for (d = 0; d < 9; d ++)
      for (e = 0; e < 9; e ++)
       if (rule[a][b][c][d][e] == -1) {
         // Definition of rules which concern the state 8 
         if (a == 8) rule[a][b][c][d][e] = 0;
         else if ((b == 8) || (c == 8) || (d == 8) || (e == 8))
              switch(a) {
               case 0: case 1:
		    if (((b >= 2) && (b <= 7)) || ((c >= 2) && (c <= 7)) ||
			((d >= 2) && (d <= 7)) || ((e >= 2) && (e <= 7)))
                         rule[a][b][c][d][e] = 8;
                    else rule[a][b][c][d][e] = a;
		    break;
               case 2: case 3: case 5:
                    rule[a][b][c][d][e] = 0;
		    break;
               case 4: case 6: case 7:
                    rule[a][b][c][d][e] = 1;
		    break;
               }
         else    // Extension of rules
           switch (a) {
           case 0:
             if(((b==1)||(c==1)||(d==1)||(e==1)) && inSheath(b,c,d,e))
                    rule[a][b][c][d][e] = 1;
             else
                    rule[a][b][c][d][e] = 0;
            break;
           case 1:
            if(((b==7)||(c==7)||(d==7)||(e==7)) && inSheath(b,c,d,e))
                    rule[a][b][c][d][e] = 7;
            else if(((b==6)||(c==6)||(d==6)||(e==6)) && inSheath(b,c,d,e))
                    rule[a][b][c][d][e] = 6;
            else if(((b==4)||(c==4)||(d==4)||(e==4)) && inSheath(b,c,d,e))
                    rule[a][b][c][d][e] = 4;
            break;
           case 2:
            if ((b == 3) || (c == 3) || (d == 3) || (e == 3))
                    rule[a][b][c][d][e] = 1;
            else if ((b == 2) || (c == 2) || (d == 2) || (e == 2))
                    rule[a][b][c][d][e] = 2;
            break;
           case 4: case 6: case 7:
            if(((b==0) || (c==0) || (d==0) || (e==0)) && inSheath(b,c,d,e))
                    rule[a][b][c][d][e] = 0;
            break;
          }
       }
  rule[1][1][1][5][2] = 8;
  rule[1][1][5][2][1] = 8;
  rule[1][5][2][1][1] = 8;
  rule[1][2][1][1][5] = 8;
       // Clearance of undefined rules 
  for (a = 0; a < 9; a ++)
    for (b = 0; b < 9; b ++)
      for (c = 0; c < 9; c ++)
        for (d = 0; d < 9; d ++)
          for (e = 0; e < 9; e ++) 
            if (rule[a][b][c][d][e] == -1) rule[a][b][c][d][e] = 8;
}
public void SetNextGeneration() {
  int xp1, yp1, xm1, ym1;
  if ( ! cyclic)
   for (int X=1;X<max-1;X++) 
    for (int Y=1;Ymax-1;Y++) 
     grid[1-cd][X][Y] = rule [grid[cd][X][Y]] [grid[cd][X][Y-1]]
               [grid[cd][X+1][Y]] [grid[cd][X][Y+1]] [grid[cd][X-1][Y]];
 else
   for (int X=0;Xmax;X++) 
    for (int Y=0;Ymax;Y++) {
      xp1 =  (X == max-1) ? 0     : X+1;
      yp1 =  (Y == max-1) ? 0     : Y+1;
      xm1 =  (X == 0)     ? max-1 : X-1; 
      ym1 =  (Y == 0)     ? max-1 : Y-1;
      grid[1-cd][X][Y] = rule [grid[cd][X][Y]] [grid[cd][X][ym1]]
              [grid[cd][xp1][Y]] [grid[cd][X][yp1]] [grid[cd][xm1][Y]];
  }
  cd = 1-cd;
}
public boolean action(Event ev, Object arg){
 if ( ev.target instanceof Button) {
        String button = (String) arg;
        if      (button.equals("Stop")) {
            pausebutton.setLabel("Start");
            running = false;
        }
        else if (button.equals("Start")) {
            pausebutton.setLabel("Stop");
            running = true;
        }
        else if (button.equals("Step")) {
            stepLeft = 1;
            if (running) {
              pausebutton.setLabel("Start");
              running = false;
            }
        }
        return true;
 } else  if ( ev.target instanceof Choice) {
       looptype = choice.getSelectedIndex();
       if (pausebutton.getLabel().equals("Start")) {
             reinit();
             repaint();
       } 
       return true;
 } else return false;
}
public void start(){if(runner==null){runner=new Thread(this);runner.start();}}
public void stop() {runner = null;}
public void run()   {
  repaint();
  while (true) {
    if (running || stepLeft > 0) {
      if (looptype == ants){
        if ( grid[cd][xx][yy] == empty) {
            direction++;
            grid[cd][xx][yy]=full;    
        } else {    
            direction--;
            grid[cd][xx][yy]=empty;
        }
	repaint();
        if (direction>=4)   direction%=4;
        if (direction< 0)   direction+=4;
        if (direction == up)    { if (yy>0) yy--; }
        if (direction == left)  { if (xx>0) xx--; }
        if (direction == down)  { if (yy<max-1) yy++;}
        if (direction == right) { if (xxmax-1) xx++;}
	try{Thread.sleep(1);}catch(InterruptedException e){};
      } else {
           SetNextGeneration();
           if( (steps % refreshSteps == 0)|| (stepLeft > 0)) repaint();   
      }
      if (stepLeft > 0) stepLeft--;
      showStatus("Steps:"+(steps++));
      try{Thread.sleep(delay);}catch(InterruptedException e){};
    }
    else try{Thread.sleep(500);}catch(InterruptedException e){};
  }
}
public void update(Graphics g) {  paint(g);}
public void paint (Graphics g) {
 if (looptype == ants) {
    if (started) {
       started=false;
       g.clearRect(0,0,width,height);
       for (int X=0;X<max;X++) 
         for (int Y=0;Ymax;Y++) {
          g.setColor( (grid[cd][X][Y] == empty) ? Color.black : Color.red );
          g.fillRect(X*(square+fringe),Y*(square+fringe),square,square);
        }
    } else {
        g.setColor( (grid[cd][xx][yy] == empty) ? Color.black : Color.red );
        g.fillRect(xx*(square+fringe),yy*(square+fringe),square,square);
    }
 } else {
     if (started) {
        g.clearRect(0,0,width,height);
        started = false;
     }
     for (int X=0;Xmax;X++)
       for (int Y=0;Ymax;Y++) {
             g.setColor( loopColors [grid[cd][X][Y]]);
             g.fillRect(X*(square+fringe),Y*(square+fringe),square,square);
       }
 }
}
}