Laden...

Conways Game of Life: Ab der 3. Generation fehlerhaft

Erstellt von rwinde vor 7 Jahren Letzter Beitrag vor 7 Jahren 3.265 Views
R
rwinde Themenstarter:in
2 Beiträge seit 2016
vor 7 Jahren
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

3.003 Beiträge seit 2006
vor 7 Jahren

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;
            }
            
        }
    }
}

"Furlow, is it always about money?"
"Is there anything else? I mean, how much sex can you have?"
"Don't know. I haven't maxed out yet."
(Furlow & Crichton, Farscape)

742 Beiträge seit 2005
vor 7 Jahren

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++)
       {
       }
}

R
rwinde Themenstarter:in
2 Beiträge seit 2016
vor 7 Jahren

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