Java 如何生成新网格-生命的游戏

大家好，我正在尝试模拟一个简单的康威生活游戏，游戏规则如下：

任何少于两个活邻居的活细胞都会死亡，就好像是由于人口不足造成的一样。 任何有两个或三个活邻居的活细胞都会延续到下一代。 任何一个有三个以上邻居的活细胞都会死亡，就好像过度拥挤一样。 任何有三个活邻居的死细胞都会变成活细胞，就像通过繁殖一样

现在的问题是，我需要修改我的实际网格以打印它，然后在应用任何规则之前将其重新更改为以前的值，但是我找不到任何系统来完成此任务，我希望有人能帮助我。 这是我的代码：

import java.util.Scanner;
import java.io.*;

class LifeGrid
{
private int[][] grid, newGrid;
private int generation = 0;

public LifeGrid(int x, int y, String filename) throws FileNotFoundException 
{ 
    grid = new int[x][y];
    newGrid = new int[x][y];

    int j = 0;

    Scanner scanner = new Scanner(new File(filename));

    while(scanner.hasNextLine() && j < x)
    {
        String line = scanner.nextLine();

        for(int i=0; i<line.length() && i<y; i++)
        {
            if(line.charAt(i) == '*')
                grid[j][i] = 1;
            else
                grid[j][i] = 0;
        }
        j++;
    }
    scanner.close();
}

public void show()
{

    for(int i=0; i<grid.length; i++)
    {
        for(int j=0; j<grid[i].length; j++)
        {
            if(grid[i][j] == 1)
                System.out.print("*");
            else
                System.out.print(" "); 
        }
        System.out.println();
    }
    System.out.println("Generation:" + generation);
}

//Getter methods

public int getWidth()             { return grid[0].length;  }
public int getHeight()            { return grid.length;     }
public int getGeneration()        { return this.generation; }
public int getCell(int x, int y)  { return grid[x][y];      }


public static void main(String[] args)throws FileNotFoundException 
{
    LifeGrid life = new LifeGrid(6, 10, args[0]);
    life.run(); 
    }

//Check neighbours

    public int neighbours(int x, int y)
    {
        int neighbours = 0;

        if(x == 0 && y == 0)
        {
        if(grid[x][y+1] == 1)       {neighbours++;} 
        if(grid[x+1][y] == 1)       {neighbours++;}
        if(grid[x+1][y+1] == 1)     {neighbours++;}
        }
        else if(x == 0 && y >= 1 && y < getWidth() -1)
        {
        if(grid[x][y+1] == 1)       {neighbours++;} 
        if(grid[x][y-1] == 1)       {neighbours++;}
        if(grid[x+1][y] == 1)       {neighbours++;}
        if(grid[x+1][y+1] == 1)     {neighbours++;} 
        if(grid[x+1][y-1] == 1)     {neighbours++;}
        }
        else if(x >= 1 && x < getHeight() -1 && y == 0)
        {
        if(grid[x][y+1] == 1)       {neighbours++;} 
        if(grid[x+1][y] == 1)       {neighbours++;}
        if(grid[x+1][y+1] == 1)     {neighbours++;} 
        if(grid[x-1][y+1] == 1)     {neighbours++;}
        }
        else if(x == getHeight()-1 && y >= 1 && y < getWidth() - 1)
        {
        if(grid[x][y+1] == 1)       {neighbours++;} 
        if(grid[x][y-1] == 1)       {neighbours++;}
        if(grid[x-1][y-1] == 1)     {neighbours++;}
        if(grid[x-1][y+1] == 1)     {neighbours++;}
        }
        else if(x >=1 && x < getHeight() - 1 && y == getWidth()-1 )
        {
        if(grid[x][y-1] == 1)       {neighbours++;}
        if(grid[x+1][y] == 1)       {neighbours++;}
        if(grid[x+1][y-1] == 1)     {neighbours++;}
        if(grid[x-1][y-1] == 1)     {neighbours++;}
        }
        else if(x == 0 && y == getWidth()-1 )
        {   
        if(grid[x][y-1] == 1)       {neighbours++;}
        if(grid[x+1][y] == 1)       {neighbours++;}
        if(grid[x+1][y-1] == 1)     {neighbours++;}
        }
        else if(x == getHeight()-1  && y == 0)
        {
        if(grid[x-1][y] == 1)       {neighbours++;}
        if(grid[x][y+1] == 1)       {neighbours++;}
        if(grid[x-1][y+1] == 1)     {neighbours++;}
        }   
        else if(x == getHeight()-1  && y == getWidth()-1)
        {
        if(grid[x][y-1] == 1)       {neighbours++;}
        if(grid[x-1][y] == 1)       {neighbours++;}
        if(grid[x-1][y-1] == 1)     {neighbours++;}
        }
        else
        {
                    if(grid[x][y+1] == 1)           {neighbours++;}
                    if(grid[x][y-1] == 1)           {neighbours++;}
                    if(grid[x+1][y] == 1)           {neighbours++;}
                    if(grid[x+1][y+1] == 1)         {neighbours++;}
                    if(grid[x+1][y-1] == 1)         {neighbours++;}
                    if(grid[x-1][y-1] == 1)         {neighbours++;}
                    if(grid[x-1][y+1] == 1)         {neighbours++;}
                }
        return neighbours;
    }
    public void run()
    {
        int n;
        int[][] old;

        for(int i=0; i<grid.length; i++)
        {
            for(int j=0; j<grid[i].length; j++)
            {
                n = neighbours(i,j);

                if(grid[i][j] == 1)
                {
                    if(n < 2 || n > 3)      {generation = 0;}
                    if(n == 2 || n == 3)    {generation = 1;}
                }
                else 
                {
                    if(n == 3)          {generation = 1;}
                    else            {generation = 0;}
                }

                if(generation == 1)
                {
                    old = grid;
                    newGrid[i][j] = 1;
                    grid = newGrid;
                    show();
                    grid = old;
                }
                else 
                {   
                    old = grid;
                    newGrid[i][j] = 0;
                    grid = newGrid;
                    show();
                    grid = old;
                                }

            }
        }
        }
}       

预期产出：

*
*
*

新的run（）方法是：

public void run()
{
    int n;

    for(int i=0; i<grid.length; i++)
    {
        for(int j=0; j<grid[i].length; j++)
        {
            n = neighbours(i,j);

            if(grid[i][j] == 1)
            {
                if(n < 2 || n > 3)  {generation = 0;}
                if(n == 2 || n == 3)    {generation = 1;}
            }
            else 
            {
                if(n == 3)      {generation = 1;}
                else            {generation = 0;}
            }

            newGrid[i][j] = generation;
        }
    }
    grid = newGrid.clone();
    show();
}

我得到：

*
*

有人能帮我找出原因吗？

欢迎

也许我误解了你的意思，但是你的问题是网格很早就被更新了（阅读：新游戏状态用于计算剩余的旧单元？）

我认为您在使用

old=grid

时遇到了麻烦，因为这只会生成数组的一部分。很可能您正在寻找一个深层拷贝，它可以使用which数组继承来实现

此外，当我阅读代码时，我感觉你已经更新了网格，同时还在计算新的游戏状态。仅将新游戏状态分配给工作网格，如“gridTemp”，当退出外部for循环时，您应该执行以下操作：

grid = gridTemp.clone()
gridTemp.clear() //purge, trash whatever, just make it empty

请记住，这只是伪代码！不管怎样，我希望这会有帮助。：）

编辑： 好的，我不能在这里运行您的代码，因此我不能100%确定这是否是您问题的解决方案，但此代码块似乎是错误的：

if(generation == 1)
                {
                    old = grid;
                    newGrid[i][j] = 1;
                    grid = newGrid;
                    show();
                    grid = old;
                }
                else 
                {   
                    old = grid;
                    newGrid[i][j] = 0;
                    grid = newGrid;
                    show();
                    grid = old;
                                }

相反，我建议进行微小的重组。将上述代码替换为：

newGrid[i][j] = generation

并且在迭代之后添加以下内容

grid = newGrid.clone();
show();

因此，与其在计算新游戏时一直更新和显示网格，不如给自己一个吻，（保持甜蜜和简单！）。首先确定新游戏状态并将其保存在一个临时网格中，如

newGrid

。 最后，您可以将游戏状态复制到旧网格并更新显示。

---

可能根本不需要在那里调用clone（）方法，但让我们有点疯狂：）

这是一个家庭作业吗？你需要更清楚一点。给出一个一次迭代的预期输出与实际输出的对比示例。找出如何打印网格。只需使用键盘输入即可生成下一个生命周期。您正在更新

grid=newGrid

，但稍后您将调用

grid=old

。我认为后一句话不应该出现。除了已经提出的建议之外。为了更快地获得更好的帮助，请发布一个。要对代码进行SSCE，需要对读取的文件进行分解，而不是将随机值分配给初始网格。我不确定您是否完全理解您的意思。我对程序做了如下更改：if（generation==1）{newGrid[I][j]=1；gridTemp=newGrid；grid=gridTemp.clone（）；show（）；gridTemp.clear（）；但是我不知道如何初始化gridTemp..对不起，请不要介意“gridTemp”可能只是让人困惑。我更新了我的答案，并试图更清楚。非常感谢你的答案，但仍然不起作用。因为现在我在一列中只放了两个“星号”，但缺少了第三个。

newGrid[i][j] = generation

grid = newGrid.clone();
show();