Conways Game of Life: Ab der 3. Generation fehlerhaft

Hallo liebe C-Sharpler,

ich möchte mich herzlich für die Aufnahme bedanken.

Ich komme auch direkt zu meinem ersten Beitrag / meiner ersten Frage hier im Forum.

Ich bin C# Neuling und versuche mich gerade am Game of Life. Um meinen Fehler schneller finden zu können ist im folgenden Beispiel ein Spielfeld bereits "hardgecodet" und nicht zufällig initialisiert, wie es bei dem Spiel sonst der Fall ist.

Ich sitze wirklich schon mehrere Tage an diesem Problem: Ich spiele mit der Standard 23/3 Regel. Diese besagt, dass
*- eine tote Zelle mit genau drei lebenden Nachbarn zum Leben erwacht, *- eine lebende Zelle mit weniger als zwei lebenden Nachbarn stirbt, *- eine lebende Zelle mit zwei oder drei lebenden Nachbarn am Leben bleibt, *- eine lebende Zelle mit mehr als drei lebenden Nachbarn stirbt.

Ich spiele ausserdem mit einem "endlichen" Spielfeld, sprich mit einem unsichtbaren Rand, welcher aus toten Zellen bestehen soll.

Wo der Fehler genau liegt, weiss ich nicht. Jedoch weiss ich, dass die zweite Generation fehlerlos ausgegeben wird. Genau dasselbe passiert, wenn ich die erste Generation manuell mit meiner zweiten überschreibe (sodass diese die neue erste ist). Wenn ich jedoch 2 Generationen nach meiner Ursprungsgeneration generieren lasse, bekomme ich ein fehlerhaftes Ergebnis.

Über jede konstruktive Anmerkung bin ich überaus dankbar und freue mich auf die Zeit hier im Forum.

Danke und einen schönen Tag,

rwinde

Ziemlich kurzer Code, ich poste den mal hier, damit niucht jeder die .txt runterladen muss...nächstes mal selbst machen, bitte.

using System;

namespace ConsoleApplication1
{
    public class TestGrid
    {
        private int[,] grid;
        private int[,] newgrid;

        public int[,] InitGrid()
        {
            grid = new int[4, 4];
            newgrid = new int[4, 4];
            Console.WriteLine("Das Spielfeld hat die Größe {0} x {1}!", 4, 4);
            return grid;
        }

        public void FillGrid() //Befüllung des "ersten" Spielfelds
        {
            //grid[0, 0] = 1;
            //grid[0, 1] = 0;
            //grid[0, 2] = 0;
            //grid[0, 3] = 1;
            //grid[1, 0] = 1;
            //grid[1, 1] = 1;
            //grid[1, 2] = 0;
            //grid[1, 3] = 1;
            //grid[2, 0] = 0;
            //grid[2, 1] = 0;
            //grid[2, 2] = 1;
            //grid[2, 3] = 1;
            //grid[3, 0] = 1;
            //grid[3, 1] = 0;
            //grid[3, 2] = 1;
            //grid[3, 3] = 1;

            grid[0, 0] = 1;
            grid[0, 1] = 1;
            grid[0, 2] = 1;
            grid[0, 3] = 0;
            grid[1, 0] = 1;
            grid[1, 1] = 1;
            grid[1, 2] = 0;
            grid[1, 3] = 1;
            grid[2, 0] = 1;
            grid[2, 1] = 0;
            grid[2, 2] = 0;
            grid[2, 3] = 0;
            grid[3, 0] = 0;
            grid[3, 1] = 1;
            grid[3, 2] = 1;
            grid[3, 3] = 1;


            int test = grid[3, 3];

            for (int height = 0; height < 4; height++)
            {
                for (int length = 0; length < 4; length++)
                {
                    if (grid[height, length] == 1)
                    {
                        Console.Write("X");
                    }
                    else
                    {
                        Console.Write("O");
                    }
                }
                Console.WriteLine();
            }
            Console.ReadKey();
            
        }

        public int NeighborCheck(int height, int length, int varHeight, int varLength)
            // Checken, ob Nachbarn leben & ob Nachbarn im Feld sind
        {
            int result = 0;
            int checkHeight = height + varHeight;
            int checkLength = length + varLength;

            if (IsCheckPositionInGrid(checkHeight, checkLength))
            {
                result = grid[checkHeight, checkLength];
            }

            return result;
        }

        private bool IsCheckPositionInGrid(int checkHeight, int checkLength)
        {
            return (checkHeight >= 0 && checkHeight < 4) &&
                   (checkLength >= 0 && checkLength < 4);
        }

        public void NewGeneration() // Neue Generation des Spiels erstellen
        {
            for (int i = 2; i < 100; i++)
            {
                Console.WriteLine(i + ". Generation");
                for (int height = 0; height < 4; height++)
                {
                    for (int length = 0; length < 4; length++)
                    {
                        int neighborsAlive =
                            NeighborCheck(height, length, 0, 1)
                            + NeighborCheck(height, length, 0, -1)
                            + NeighborCheck(height, length, 1, -1)
                            + NeighborCheck(height, length, 1, 0)
                            + NeighborCheck(height, length, 1, 1)
                            + NeighborCheck(height, length, -1, -1)
                            + NeighborCheck(height, length, -1, 0)
                            + NeighborCheck(height, length, -1, 1);

                        int isAlive = grid[height, length];

                        if (isAlive == 1)
                        {
                            if (neighborsAlive == 2 || neighborsAlive == 3)
                            {
                                newgrid[height, length] = 1;
                                Console.Write("X");
                            }
                            else
                            {
                                newgrid[height, length] = 0;
                                Console.Write("O");
                            }
                        }
                        else
                        {
                            if (neighborsAlive == 3)
                            {
                                newgrid[height, length] = 1;
                                Console.Write("X");
                            }
                            else
                            {
                                newgrid[height, length] = 0;
                                Console.Write("O");
                            }
                        }
                    }
                    Console.WriteLine();
                    
                }
                Console.ReadKey();
                grid = newgrid;
            }
            
        }
    }
}

Du musst die Grid austauschen:

var temp = grid;
grid = newgrid;
newgrid = temp;

Wäre auch einfacher zu verstehen, wenn du ein paar konstanten einführen würdest:

also

const int FieldWidth = 4;
const int FieldHeight = 4;

grid = new int[FieldWidth , FieldHeight ];
newgrid = new int[FieldWidth , FieldHeight ];

[...]

for (int y= 0; y< FieldHeight ; y++)
{
       for (int x= 0; x< FieldWidth ; x++)
       {
       }
}

Hi malignate,

vielen Dank für die schnelle Hilfe!

Hat alles wunderbar geklappt.

Ich habe nicht gewusst, dass man eine Art "Zwischenvariable" braucht, um das von mir gewollte zu realisieren.

Vielen Dank dafür, und einen schönen Tag.

Grüße