0

我正在研究康威的生命克隆游戏，因为这是一种很好的做法，但我遇到了问题。我看到有像素删除和重生，但所有像素只是散布在屏幕的最末端，然后其他像素正在重生，但那时它只是空闲。

以下是一些截图： 在此处输入图像描述

我将向您展示我的一些代码以了解此逻辑。这一切都在change方法中处理：

package main;

import java.awt.Color;
import java.awt.Graphics;

public class Functions {

  public static int pixelsize=6,gridwidth=800/6,gridheight=600/6;
  static int[][] pixels = new int[gridwidth][gridheight];
  static boolean first = true;

  public static void change(){

    for(int i = 0; i < gridwidth; i++){
      for(int j = 0; j < gridheight; j++){
        int neighbors = 0;
        //check each cell

        try{

          if(pixels[i+1][j] == 1){neighbors++;}
          if(pixels[i-1][j] == 1){neighbors++;}
          if(pixels[i+1][j-1] == 1){neighbors++;}
          if(pixels[i][j+1] == 1){neighbors++;}
          if(pixels[i][j-1] == 1){neighbors++;}
          if(pixels[i+1][j+1] == 1){neighbors++;}
          if(pixels[i-1][j-1] == 1){neighbors++;}
          if(pixels[i-1][j+1] == 1){neighbors++;}

        }catch(ArrayIndexOutOfBoundsException e){

        }

        if(neighbors == 3 || neighbors == 2 ){
          pixels[i][j] = 1;
        }else if(neighbors < 2 || neighbors >= 4){
          pixels[i][j] = 0;
        }
      }
    }
  }

  public static void render(Graphics g){

    for(int i = 0; i < gridwidth;i++){
      for(int j = 0; j < gridheight; j++){
        if(pixels[i][j] == 1){

          g.setColor(Color.red);
          g.fillRect(i*6, j*6, 6, 6);
        }
      }
    }
  }
}


感谢所有的帮助。可悲的是，它仍然无法正常工作。
现在它正在做同样的事情，但是像这样形成菱形：
在此处输入图像描述

4

2 回答 2

6

我在这里看到的主要问题是您在发现值的同时更新它们。

您应该在更新之前缓存整个网格（或至少是邻居计数），否则，当您更新 处的元素时，您正在通过计算当前迭代的结果(x, y)来更改连续为 的元素的邻居计数(x+1,y)。(x+1,y+1)(x,y+1)

例如，您可以像这样更新一个名为 cachedPixels 的单独数组：

for(int i = 0; i < gridwidth; i++){
    for(int j = 0; j < gridheight; j++){
        int neighbors = 0;
        // find the proper boundaries
        int minI = Math.max(0, i - 1);
        int maxI = Math.min(gridwidth, i + 2)
        int minJ = Math.max(0, j - 1);
        int maxJ = Math.min(gridheight, j + 2)

        for (int i2 = minI; i2 < maxI; i2++) {
           for (int j2 = minJ; j2 < maxJ; j2++) {
              if (i2 != i || j2 != j) {
                 if (pixels[i2][j2] == 1) {
                    neighbors++;
                 }
              }
           }
        }

        if (neighbors == 2 || neighbors == 3) {
           cachedPixels[i][j] = 1;
        } else {
           cachedPixels[i][j] = 0; // probably not even necessary as 0 is default value
        }
    }   
}

然后在使用 arraycopy 函数对整个数组集完成此过程后：

for (int i = 0; i < length; i++) {
    System.arraycopy(cachedPixels[i], 0, pixels[i], 0, cachedPixels[i].length);
}

简单地设置pixels = cachedPixels 会将“pixels”指向“cachedPixels”数组，因此改变一个会改变另一个，系统就会崩溃。

PS 您用于 GoL 的规则与 John H. Conway 的不同。如果细胞有 3 个邻居，则细胞总是在下一个时间步存活，并且只有在这个时间步还活着的情况下，它们才能与 2 个邻居一起在下一个时间步存活，否则它们会死亡：

cachedPixels[i][j] = 0; // Default value - death.
if (neighbors == 3) {
   cachedPixels[i][j] = 1;
} else if (thisCell == 1 && neighbors == 2) {
   cachedPixels[i][j] = 1;
}
于 2013-02-08T17:39:45.823 回答
2

您的新生像素不应被视为此移动的邻居，而您的死亡像素应被计算在内。它可以通过为新生像素和垂死像素设置另一个值来实现，例如2和。3处理完该字段后，您通过用 替换新生儿的值和死亡的值来提交它的状态。10

于 2013-02-08T17:41:49.533 回答