C# - Conways Spiel des Lebens

    • C#

    Es gibt 4 Antworten in diesem Thema. Der letzte Beitrag () ist von VaporiZed.

      C# - Conways Spiel des Lebens

      Beschreibung:
      Diese Konsolenanwendung ist eine codierte Darstellung des Conways Spiel des Lebens, nachzulesen auf Wikipedia.

      Verwendete Programmiersprache(n) und IDE(s):
      Visual Studio 2017 Community, C#

      Systemveränderungen:
      Es wird gefordert, ein Spielfeld in Form einer Textdatei auf dem Desktop anzulegen.

      Download(s):
      Projektordner - Dekomprimiert ca. 3,5 MB
      Beispiel Spielfeld, muss sich auf Desktop befinden

      Lizenz/Weitergabe:
      Open Source, der sich im Anhang befindende Code dient als Vorlage und wurde komplett Kommentiert. Mir hat es sehr dabei geholfen, C# ein wenig besser zu lernen. Der Code stammt allein von mir, in rücksicht auf die Regeln des Wikipedia Beitrags. Für Verbesserungvorschläge bin ich sehr offen, da ich dieses Programm auch nur entwickelt habe, um mich ein bisschen mehr in C# einzufinden.

      Grundlegendes zum Code:
      Das Spiel besteht aus Zellen. Eine Leere Zelle (" ") ist eine "Tote Zelle", eine mit einem Rautezeichen gefüllte Zelle ("#") ist eine "Lebendige Zelle". Je nach dem wie viele "Nachbarn" eine Zelle hat stirbt sie, bleibt am Leben oder wird geboren, je nach Status der Zelle. Gearbeitet wird größtenteils mit einer 2-Dimensionalen String-Liste die als Spielfeld dient. Es werden Zeilenweise alle Zeichen der Textdatei in diese Liste hinzugefügt. Die Liste wird nach der überprüfung der Regeln verändert, da das sonst die Ergebnisse verfälschen würde.

      Hier der Code in Textform zum drüber schaun:
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Collections.Generic;
      3. using System.Linq;
      4. using System.Text;
      5. using System.Threading.Tasks;
      7. namespace gameOfLife {
      8. class Program {
      9. static List<List<string>> hashRows = new List<List<string>>(); // 2-Dimensionale String-Liste die das Spielfeld darstellt (das Spielfeld kann beliebig groß sein)
      10. static List<string> changePoints = new List<string>(); // Liste in der zu verändernde Punkte eingetragen werden
      11. static string fillData = Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\Spielfeld.txt"; // Pfad zur Spielfeld-Datei auf dem Desktop
      13. static void Main(string[] args) {
      14. if(System.IO.File.Exists(fillData)) {
      15. bool goOn = true;
      16. int generation = 1;
      17. fillList();
      18. doListOutput(hashRows, generation);
      19. while(goOn) {
      20. generation += 1;
      21. checkGeneration();
      22. changeGeneration();
      23. doListOutput(hashRows, generation);
      24. if(!Console.ReadKey().Key.Equals(ConsoleKey.Enter)) { goOn = false; }
      25. }
      26. } else {
      27. System.IO.File.Create(fillData);
      28. Console.WriteLine("Auf Ihrem Desktop wurde eine Text-Datei mit dem Namen 'Spielfeld.txt' erstellt. Sie können Ihre eigene Anfangs-Generation bestimmen, dabei steht ein Leerzeichen " +
      29. "für ein nicht existierendes- und ein Rautezeichen ('#') für ein lebendiges Lebewesen. Es empfiehlt sich ein 40x20 Spielfeld anzulegen aus Leerzeichen und Rautezeichen. " +
      30. "Die Regeln sind dabei nachzulesen auf: https://de.wikipedia.org/wiki/Conways_Spiel_des_Lebens");
      31. Console.ReadKey();
      32. }
      33. }
      35. /// <summary>
      36. /// Füllt die Variable hashRows mit den Eingaben aus der Textdatei Zeilenweise. Jede Zeile wird dabei eine neue Leere String-Liste die mit dem Text der Zeile gefüllt wird. Jedes Zeichen ist
      37. /// ein einzelnes Item.
      38. /// </summary>
      39. /// <see cref="hashRows"/>
      40. /// <see cref="fillData"/>
      41. static void fillList() {
      42. int lineCount = 0;
      43. foreach(var line in System.IO.File.ReadLines(fillData)) { // Es wird jede Zeile des Spielfeldes durch Iteriert.
      44. List<string> emptyFillList = new List<string>(); // Zwischenvariable
      45. hashRows.Add(emptyFillList); // Leere String-Liste wird hinzugefügt.
      46. foreach(char element in line) { hashRows[lineCount].Add(element.ToString()); } // Das zuvor Leer hinzugefügte Item wird mit Zeichen der Zeile gefüllt.
      47. lineCount += 1;
      48. }
      49. }
      51. /// <summary>
      52. /// Diese Funktion überprüft das Spielfeld nach den Regeln. Hierbei ist es wichtig, dass man das Spielfeld erst NACH dem Überprüfen verändern darf, da das sonst das ergebnis verfälschen würde.
      53. /// </summary>
      54. static void checkGeneration() {
      55. for(int lstIndx = 0; lstIndx < hashRows.Count; lstIndx++) { // es wird jede Zeile des Spielfelds durch Iteriert
      56. for(int i = 0; i < hashRows[lstIndx].Count; i++) { // es werden alle Items (Zeichen der Zeile) der oben bestimmten Zeile durch Iteriert
      57. List<string> arround = new List<string> { // in dieser Liste werden im Folgenden alle umliegenden Items des Items hashRows[lstIndx][i] hinzugefügt, um die Regeln zu überprüfen
      58. hashRows[calcIndex(hashRows.Count, lstIndx - 1)][calcIndex(hashRows[calcIndex(hashRows.Count, lstIndx - 1)].Count, i - 1)], // oben links
      59. hashRows[calcIndex(hashRows.Count, lstIndx - 1)][i], // oben mitte
      60. hashRows[calcIndex(hashRows.Count, lstIndx - 1)][calcIndex(hashRows[calcIndex(hashRows.Count, lstIndx - 1)].Count, i + 1)], // oben rechts
      62. hashRows[lstIndx][calcIndex(hashRows[lstIndx].Count, i - 1)], // links
      63. hashRows[lstIndx][calcIndex(hashRows[lstIndx].Count, i + 1)],// rechts
      65. hashRows[calcIndex(hashRows.Count, lstIndx + 1)][calcIndex(hashRows[calcIndex(hashRows.Count, lstIndx + 1)].Count, i - 1)], // unten links
      66. hashRows[calcIndex(hashRows.Count, lstIndx + 1)][i], // unten mitte
      67. hashRows[calcIndex(hashRows.Count, lstIndx + 1)][calcIndex(hashRows[calcIndex(hashRows.Count, lstIndx + 1)].Count, i + 1)] // unten rechts
      68. };
      69. int surrounding = countElementsWith("#", arround);
      70. string cellType = hashRows[lstIndx][i];
      71. if (cellType == "#") { if (surrounding < 2 || surrounding > 3) { addAsChange(lstIndx, i, " "); } } else { if (surrounding == 3) { addAsChange(lstIndx, i, "#"); } } // Die Regeln
      72. // hierbei durch einfaches Zählen der lebenden Zellen ('#') überprüft, alle zu ändernden Zellen werden in addAsChange zur Liste changePoints mit allen Argumenten hinzugefügt.
      73. }
      74. }
      75. }
      77. /// <summary>
      78. /// Hier werden zur Liste changePoints die Punkte in einem Element gespeichert, die zu verändern sind. Sie werden so als String hinzugefügt, dass man sie später nur mit einem ',' splitten
      79. /// muss.
      80. /// </summary>
      81. /// <param name="pointY">Y-Punkt des zu Verändernden Elements</param>
      82. /// <param name="pointX">x-Punkt des zu Verändernden Elements</param>
      83. /// <param name="cellType">Typ in den es geändert werden soll</param>
      84. /// <see cref="changePoints"/>
      85. static void addAsChange(int pointY, int pointX, string cellType) {
      86. changePoints.Add(pointY.ToString() + "," + pointX.ToString() + "," + cellType);
      87. }
      89. /// <summary>
      90. /// Hier wird die Generation mit den zuvor gespeicherten Punkten verändert. Dabei wird so vorgegangen:
      91. /// [0] = Y-Punkt
      92. /// [1] = X-Punkt
      93. /// [2] = Zellen Typ
      94. /// </summary>
      95. static void changeGeneration() {
      96. foreach (string elements in changePoints) {
      97. string[] vs = elements.Split(',');
      98. hashRows[Int16.Parse(vs[0])][Int16.Parse(vs[1])] = vs[2];
      99. }
      100. }
      102. /// <summary>
      103. /// Im folgenden wird mit den angegebenen Werten ein Index berechnet bzw. überprüft. Dabei muss man immer im Kopf behalten, dass das Spielfeld Torus-förmig ist. Heißt: wenn der zu suchende
      104. /// Index über das Spielfeld hinaus geht, ist er 0. Wenn er kleiner ist als das Spielfeld, ist er das letzte Item der Liste, also der maximal mögliche Wert.
      105. /// Sollte er aber Legitim mitten auf dem Spielfeld liegen, so wird er nicht verändert und nur zurück gegeben.
      106. /// </summary>
      107. /// <param name="maxVal">Größt möglicher Wert, letztes Item einer Liste</param>
      108. /// <param name="checkVal">Zu überprüfender Index</param>
      109. /// <returns>Legitimen Punkt auf dem Spielfeld.</returns>
      110. static int calcIndex(int maxVal, int checkVal) {
      111. if (checkVal >= maxVal) { checkVal = 0; } else if (checkVal < 0) { checkVal = maxVal - 1; }
      112. return checkVal;
      113. }
      115. /// <summary>
      116. /// Zählt wie viele Elemente einer Liste angegebenen Parameter enthalten.
      117. /// </summary>
      118. /// <param name="searchParam">Zu suchender Parameter</param>
      119. /// <param name="vs">Liste in der gesucht werden soll</param>
      120. /// <returns>Anzahl der Elemente, die angegebenen Parameter gleichen.</returns>
      121. static int countElementsWith(string searchParam, List<string> vs) {
      122. int i = 0;
      123. foreach(string element in vs) {
      124. if(element.Equals(searchParam)) { i++; }
      125. }
      126. return i;
      127. }
      129. /// <summary>
      130. /// Gibt die angegebene 2-Dimensionale String-Liste (das Spielfeld) aus.
      131. /// </summary>
      132. /// <param name="list">Auszugebene Liste</param>
      133. /// <param name="gen">Generation in der man sich befindet</param>
      134. static void doListOutput(List<List<string>> list, int gen) {
      135. Console.WriteLine( gen.ToString() + ". Generation:" + Environment.NewLine);
      136. foreach(List<string> listItm in list) {
      137. for(int i = 0; i < listItm.Count; i++) {
      138. Console.Write(listItm[i]);
      139. }
      140. Console.WriteLine();
      141. }
      142. Console.WriteLine();
      143. }
      144. }
      145. }




      In den Sourcecode-Austausch verschoben, da keine Binaries zum Download vorhanden sind.
      -Artentus
      Projekte

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Quellcoder02“ ()

      @Quellcoder02 Ohne Kommentar:
      Spielfeld.txt
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      @RodFromGermany komisch, bei mir funktioniert alles ohne Probleme. Befindet sich bei dir die Spielfeld.txt Datei auf dem Desktop auch unter dem Namen Spielfeld.txt? Oder kannst du mir zirka sagen wo bei dir der Fehler kommt?
      Projekte

      @Quellcoder02 unter VS13 und VS10 dasselbe:

      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Keine Probleme bei mir. VS17CE (15.6.3), daher Fehlertracking schwierig
      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „VaporiZed“, mal wieder aus Grammatikgründen.

      Aufgrund spontaner Selbsteintrübung sind all meine Glaskugeln beim Hersteller. Lasst mich daher bitte nicht den Spekulatiusbackmodus wechseln.

    Facebook
    Telefonspende