Startseite > .NET, C# > Game of Life mit C#

Game of Life mit C#


Ich hatte heute mal wirklich Lust darauf gehabt das “Game of Life” in verschiedenen Sprachen zu programmieren.
Angedacht hatte ich Assembler, C bzw. C++, C#, VB.NET, VB6, Turbo Pascal, Java… Vielleicht fallen mir noch andere Sprachen ein, dass ich auf die Schnelle erlernen kann…

Hier der Code für C# … Nicht optimiert…

C#
1
23
45
67
89
1011
1213
1415
1617
1819
2021
2223
2425
2627
2829
3031
3233
3435
3637
3839
4041
4243
4445
4647
4849
5051
5253
5455
5657
5859
6061
6263
6465
6667
6869
7071
7273
7475
7677
7879
8081
8283
8485
8687
8889
9091
9293
9495
9697
9899
100101
102103
104105
106107
108109
110111
112113
114115
116117
using System;
using System.Threading;  namespace GameOfLifeCSharp{
    class Program    {
         private const int FELD_GRÖSSE = 16;
        private const char ZEICHEN_WESEN = '#';        private const int STABILE_GENERATIONEN = 10;
         static void Main(string[] args)
        {            bool[,] felder = new bool [FELD_GRÖSSE, FELD_GRÖSSE];
             // Felder mit leben füllen
            Random randomNumber = new Random(DateTime.Now.Second);                        for (int x = 1; x < FELD_GRÖSSE - 1; x++)            {
                for (int y = 1; y < FELD_GRÖSSE - 1; y++)                    felder[x, y] = 
                        randomNumber.Next(0, 1000) > 500 ?                         true : false;
            }              int nachbarzähler = 0;            int alteanzahl = 0;
            int neueanzahl = 0;            int generationStabilität = 0;
            int generationen=0;              while (generationStabilität < STABILE_GENERATIONEN)            {
                for (int x = 1; x < FELD_GRÖSSE - 1; x++)                {
                    for (int y = 1; y < FELD_GRÖSSE - 1; y++)                    {
                        // Regeln                        // Nachbarn zählen
                        nachbarzähler += felder[x - 1, y] ? 1 : 0;                        nachbarzähler += felder[x + 1, y] ? 1 : 0;
                         nachbarzähler += felder[x, y + 1] ? 1 : 0;
                        nachbarzähler += felder[x, y - 1] ? 1 : 0;                          nachbarzähler += felder[x - 1, y + 1] ? 1 : 0;                        nachbarzähler += felder[x - 1, y - 1] ? 1 : 0;
                         nachbarzähler += felder[x + 1, y + 1] ? 1 : 0;
                        nachbarzähler += felder[x + 1, y - 1] ? 1 : 0;                          // Regel 1                        if (!felder[x, y] && nachbarzähler == 3) 
                            felder[x, y] = true;                        // Regel 2
                        else if (nachbarzähler < 2)                             felder[x, y] = false;
                        // Regel 3                        else if (nachbarzähler > 1 && 
                            nachbarzähler < 4) { }                        // Regel 4
                        else if (nachbarzähler > 3)                             felder[x, y] = false;
                         // anzahl zählen
                        if (felder[x, y]) neueanzahl++;                          nachbarzähler = 0;                    }
                }                  ShowUs(ref felder);                Console.WriteLine("Generation: {0}, Anzahl: {1}", 
                    generationen, neueanzahl);                  if (neueanzahl >= alteanzahl -2 &&                     neueanzahl <= alteanzahl +2)
                    generationStabilität++;                else
                    generationStabilität = 0;                  alteanzahl = neueanzahl;                neueanzahl = 0;
                 generationen++;
                 Thread.Sleep(100);
            }              Console.WriteLine(                "Seit {0} Generationen stabil\nEnter drücken um zu beenden", 
                generationStabilität);            Console.Read();
         }
         private static void ShowUs(ref bool[,] felder)
        {            Console.Clear();
             for (int x = 0; x < FELD_GRÖSSE; x++)
            {                for (int y = 0; y < FELD_GRÖSSE; y++)
                {                    if (felder[x, y])
                        Console.Write(ZEICHEN_WESEN);                    else
                        Console.Write(" ");                }
                Console.Write("\n");            }
        }    }
} 
GeSHi 1.0.8.8
Advertisements
Kategorien:.NET, C# Schlagwörter:
  1. Es gibt noch keine Kommentare.
  1. No trackbacks yet.

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s

%d Bloggern gefällt das: