IEnumerator NextGeneration()
    {
        DeleteZells();
        List<Vector3> NextGeneration = new List<Vector3>();

        List<Vector3> DeadCells = new List<Vector3>();

        foreach (var pk in AktiveZellen)
        {
            int living = 0;
            int death = 0;

            for (int x = (int)pk.x - 1; x <= pk.x + 1; x++)
            {
                for (int z = (int)pk.z - 1; z <= pk.z + 1; z++)
                {
                    Vector3 zelle_O = new Vector3(x, pk.y + 1, z);
                    Vector3 zelle_U = new Vector3(x, pk.y - 1, z);
                    Vector3 zelle_m = new Vector3(x, transform.position.y, z);

                    if (AktiveZellen.Contains(zelle_O)) living++;
                    if (!AktiveZellen.Contains(zelle_O))
                    {
                        death++;
                        if(!DeadCells.Contains(zelle_O))DeadCells.Add(zelle_O);
                    }

                    if (AktiveZellen.Contains(zelle_U)) living++;
                    if (!AktiveZellen.Contains(zelle_U))
                    {
                        death++;
                        if(!DeadCells.Contains(zelle_U))DeadCells.Add(zelle_U);
                    }
                    if (!(zelle_m == pk))
                    {
                        if (AktiveZellen.Contains(zelle_m)) living++;
                        if (!AktiveZellen.Contains(zelle_m))
                        {
                            death++;
                           if(!DeadCells.Contains(zelle_m)) DeadCells.Add(zelle_m);
                        }
                    }
                }
            }


            //Jetzt haben wir die Lebenden und Toten Zellen um die Nachbarn rum.
            //Sollte der Nachbar tot sein, wird er später durchgegangen.

            //Die Aktuelle Zelle ist definitiv am Leben. Es geht also darum, ob sie stirbt, oder am Leben bleibt.
            // Wir gehen einmal das Stay Alive array durch, sollte die Zahl der Lebenden, darin vorkommen, adden wir die Zelle zur NextGeneration.
            //Anderfalls verfällt sie


            if (RegelSet[living] == RuleSeed.Live)
            {
                NextGeneration.Add(pk);
                GameObject tmp = Instantiate(ZellPrefab, Zellen.transform.transform, true);
                tmp.transform.position = pk;
                yield return null;
            }
            //Hier das überarbeiten wir nochmal !


            //Nun sind wir am der Überprüfung der Lebendige Zelle, sollte der Count der Nachbarn größer sein, wird sie sterben. Da sie nicht
            //in der Liste der Next Generation ist.
        }


        //Nun gehen wir die Toten Zellen durch, die nahe bei den Lebenden Standen, und wiederholen die Funktion fast gleich wie oben.
        //Nur verwenden wir diemsal die BornRule

        foreach (Vector3 DeadZelle in DeadCells)
        {
            int living = 0;
            int death = 0;


            for (int x = (int)DeadZelle.x - 1; x <= DeadZelle.x + 1; x++)
            {
                for (int z = (int)DeadZelle.z - 1; z <= DeadZelle.z + 1; z++)
                {
                    Vector3 zelle_O = new Vector3(x, DeadZelle.y + 1, z);
                    Vector3 zelle_U = new Vector3(x, DeadZelle.y - 1, z);
                    Vector3 zelle_m = new Vector3(x, transform.position.y, z);

                    if (AktiveZellen.Contains(zelle_O)) living++;
                    if (!AktiveZellen.Contains(zelle_O))
                    {
                        death++;
                    }

                    if (AktiveZellen.Contains(zelle_U)) living++;
                    if (!AktiveZellen.Contains(zelle_U))
                    {
                        death++;
                    }
                    if (!(zelle_m == DeadZelle))
                    {
                        if (AktiveZellen.Contains(zelle_m)) living++;
                        if (!AktiveZellen.Contains(zelle_m))
                        {
                            death++;

                        }
                    }
                }
            }

            //Nun haben wir die Nachbarn der Toten Zelle
            //Und schauen wieviele Lebenden und Toten Nachbarn die Zelle hat



            if (RegelSet[living] == RuleSeed.Birth)
            {
                NextGeneration.Add(DeadZelle);
                GameObject tmp = Instantiate(ZellPrefab, Zellen.transform.transform, true);
                tmp.transform.position = DeadZelle;
                yield return null;
            }
        }

        //Nun haben wir die komplette Nächste Generation in der Liste.
        //Wir löschen alle Aktuellen Zellen



        //Und fügen alle neuen Zellen zur Scene


        AktiveZellen = NextGeneration;
        yield return null;
    }