edv:prg:c:c_lernen:conways_spiel_des_lebens

Anonymous (anonymous@undisclosed.example.com) — 2020-01-11T01:23:11+00:00

	aktuell
Zeile 1:	Zeile 1:
	+	====== Conways Spiel des Lebens ======

	+	Hier werden wir Schritt für Schritt eine einfache Variante des Spiels in C entwickeln.
	+
	+	Als Compiler verwenden wir die GCC (aktuell die v4.8.5 auf einem RHEL7 in der x86_64 Ausprägung).
	+
	+	===== Schritt 1: Grundgerüst =====
	+
	+	File: sdl_main.c
	+	<code c>
	+	// CharSet: ISO 8859-15
	+
	+	// Beschreibung - URL: https://de.wikipedia.org/wiki/Conways_Spiel_des_Lebens
	+
	+
	+	// Kompilieren (mit GCC):
	+	// gcc -o sdl.elf sdl_main.c
	+
	+
	+	// Aufruf:
	+	// ./sdl.elf
	+
	+
	+	#include <stdio.h>
	+
	+
	+	#define SPIELFELD_HOEHE_ZEILEN 10
	+	#define SPIELFELD_BREITE_SPALTEN 10
	+
	+
	+	int spielfeld[SPIELFELD_HOEHE_ZEILEN][SPIELFELD_BREITE_SPALTEN] = {0};
	+
	+
	+	int anfangsgeneration_platzieren()
	+	{
	+	int anzahl_zellen = 0;
	+
	+	// TODO: Lebendige Zellen auf dem Spielfeld (zunaechst statisch) verteilen.
	+
	+	return anzahl_zellen;
	+	} // anfangsgeneration_platzieren()
	+
	+
	+	int main(int argc, char *argv[])
	+	{
	+	int zellen_vorhanden_lebendig = 0;
	+
	+	zellen_vorhanden_lebendig = anfangsgeneration_platzieren();
	+	printf("Spielfeld: %i x %i (Zeilen x Spalten).\n", SPIELFELD_HOEHE_ZEILEN, SPIELFELD_BREITE_SPALTEN);
	+	printf("Anfangsgeneration platziert: %i Zellen.\n", zellen_vorhanden_lebendig);
	+
	+	// TODO: Das Spielfeld auf dem Bildschirm anzeigen.
	+
	+	// TODO: Alle Regeln in der Schleife anwenden.
	+
	+	return 0;
	+	} // main()
	+
	+	// EOF
	+	</code>
	+
	+
	+	===== Schritt 2: erste Ergebnisse =====
	+
	+	In diesem Schritt haben wir einige Zellen als lebendig definiert (die Funktion "anfangsgeneration_platzieren()") und die Ausgabe des Spielfeldes am Bildschirm implementiert (die Funktion "spielfeld_anzeigen()").
	+	Außerdem haben wir eine Funktion implementiert, die Tastatureingaben liest (die "auf_tastatureingabe_warten()").
	+
	+	Der Quelltext kann jetzt so aussehen:
	+
	+	File: sdl_main.c
	+	<code c>
	+	// CharSet: ISO 8859-15
	+
	+	// Beschreibung - URL: https://de.wikipedia.org/wiki/Conways_Spiel_des_Lebens
	+
	+
	+	// Kompilieren (mit GCC):
	+	// gcc -o sdl.elf sdl_main.c
	+
	+
	+	// Aufruf:
	+	// ./sdl.elf
	+
	+
	+	#include <stdio.h>
	+	#include <stdlib.h>
	+	#include <string.h>
	+
	+
	+	#define SPIELFELD_HOEHE_ZEILEN 10
	+	#define SPIELFELD_BREITE_SPALTEN 10
	+
	+
	+	int spielfeld[SPIELFELD_HOEHE_ZEILEN][SPIELFELD_BREITE_SPALTEN] = {0};
	+
	+
	+	int anfangsgeneration_platzieren()
	+	{
	+	int anzahl_zellen = 0;
	+	int zeile, spalte;
	+
	+	// TODO: Lebendige Zellen auf dem Spielfeld (zunaechst statisch) verteilen.
	+	spielfeld[1][1] = 1;
	+	spielfeld[1][2] = 1;
	+	spielfeld[1][3] = 1;
	+	spielfeld[2][3] = 1;
	+
	+	for (zeile = 0; zeile < SPIELFELD_HOEHE_ZEILEN; zeile++) // UEber alle Zeilen von oben nach unten.
	+	{
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++) // UEber alle Spalten von links nach rechts.
	+	{
	+	if (spielfeld[zeile][spalte] == 1) // Lebendige Zellen zaehlen.
	+	anzahl_zellen++;
	+	}
	+	}
	+
	+	return anzahl_zellen;
	+	} // anfangsgeneration_platzieren()
	+
	+
	+	int auf_tastatureingabe_warten(char prompt, char zeilenbuffer, int buffer_groesse)
	+	{
	+	int zeichen_gelesen_anzahl = 0;
	+	char fake_buffer[4] = {0};
	+
	+	if (prompt) printf("\n%s", prompt);
	+	else printf("\n");
	+
	+	if (zeilenbuffer && (buffer_groesse > 1)) // Input lesen nur, wenn Buffer Platz hat.
	+	{
	+	fgets(zeilenbuffer, buffer_groesse, stdin); // Hinweis: evtl. vorhandenes '\n' wird mitgelesen.
	+
	+	if (strlen(zeilenbuffer) > 0) // Ist der gelesene String nicht leer?
	+	{
	+	if (zeilenbuffer[strlen(zeilenbuffer)] == '\n') // Evtl. vorhandenes '\n'...
	+	zeilenbuffer[strlen(zeilenbuffer)] = '\0'; // ...beseitigen.
	+	}
	+
	+	zeichen_gelesen_anzahl = strlen(zeilenbuffer); // Die "netto"-Laenge des gelesenen Strings "messen".
	+	}
	+	else
	+	{
	+	fgets(fake_buffer, sizeof(fake_buffer), stdin);
	+	}
	+
	+	fflush(stdin); // Evtl. im stdin noch vorhandene Zeichen bereinigen.
	+	return zeichen_gelesen_anzahl;
	+	} // auf_tastatureingabe_warten()
	+
	+
	+	void spielfeld_anzeigen()
	+	{
	+	// TODO: Das Spielfeld auf dem Bildschirm anzeigen.
	+	int zeile, spalte;
	+
	+	printf("\n");
	+
	+	// Oberer Rand vom Spielfeld:
	+	printf("+");
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++)
	+	{
	+	printf("-");
	+	}
	+	printf("+\n");
	+
	+	// Inhalt vom Spielfeld:
	+	for (zeile = 0; zeile < SPIELFELD_HOEHE_ZEILEN; zeile++) // UEber alle Zeilen von oben nach unten.
	+	{
	+	printf("\|");
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++) // UEber alle Spalten von links nach rechts.
	+	{
	+	if (spielfeld[zeile][spalte] == 1) printf("o");
	+	else printf(" ");
	+	}
	+	printf("\|\n");
	+	}
	+
	+	// Unterer Rand vom Spielfeld:
	+	printf("+");
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++)
	+	{
	+	printf("-");
	+	}
	+	printf("+\n");
	+	} // spielfeld_anzeigen()
	+
	+
	+	int main(int argc, char *argv[])
	+	{
	+	int zellen_vorhanden_lebendig = 0;
	+
	+	zellen_vorhanden_lebendig = anfangsgeneration_platzieren();
	+	printf("Spielfeld: %i x %i (Zeilen x Spalten).\n", SPIELFELD_HOEHE_ZEILEN, SPIELFELD_BREITE_SPALTEN);
	+	printf("Anfangsgeneration platziert: %i Zellen.\n", zellen_vorhanden_lebendig);
	+
	+	auf_tastatureingabe_warten("Enter druecken: ", NULL, 0);
	+
	+	printf("Die Anfangsbelegung:\n");
	+	spielfeld_anzeigen();
	+
	+	// TODO: Alle Regeln in der Schleife anwenden.
	+
	+	return EXIT_SUCCESS;
	+	} // main()
	+
	+	// EOF
	+	</code>
	+
	+	Die Ausgabe am Bildschirm sollte ungefähr so aussehen:
	+
	+	<code>
	+	user@rhel:/home/user/sdl> ./sdl.elf
	+	Spielfeld: 10 x 10 (Zeilen x Spalten).
	+	Anfangsgeneration platziert: 4 Zellen.
	+
	+	Enter druecken:
	+	Die Anfangsbelegung:
	+
	+	+----------+
	+	\| \|
	+	\| ooo \|
	+	\| o \|
	+	\| \|
	+	\| \|
	+	\| \|
	+	\| \|
	+	\| \|
	+	\| \|
	+	\| \|
	+	+----------+
	+	user@rhel:/home/user/sdl>
	+	</code>
	+
	+	===== Schritt 3: Spielregeln (zunächst als Dummies) einführen =====
	+
	+	Wir erstellen zunächst eine leere Funktion spielregeln_anwenden() um sie später mit der Funktionalität zu füllen:
	+
	+	<code c>
	+	int spielregeln_anwenden(int anzahl_zellen_vorher)
	+	{
	+	int anzahl_zellen_nachher = 0;
	+
	+	printf("Anzahl lebendiger Zellen VOR der Anwendung von Spielregeln: %i Zellen.\n", anzahl_zellen_vorher);
	+
	+	// TODO: Alle Spielregeln nacheinander anwenden.
	+
	+	// TODO: Anzahl lebenden Zellen neu ermitteln
	+
	+	printf("Anzahl lebendiger Zellen NACH der Anwendung von Spielregeln: %i Zellen.\n", anzahl_zellen_nachher);
	+
	+	printf("Ergebnis: ");
	+	if (anzahl_zellen_nachher > anzahl_zellen_vorher) printf("Zuwachs von %i Zellen\n", anzahl_zellen_nachher - anzahl_zellen_vorher);
	+	else if (anzahl_zellen_nachher < anzahl_zellen_vorher) printf("Verlust von %i Zellen\n", anzahl_zellen_vorher - anzahl_zellen_nachher);
	+	else printf("keine Veraenderung\n");
	+
	+	return anzahl_zellen_nachher;
	+	} // spielregeln_anwenden()
	+	</code>
	+
	+	Die main() erweitern wir wie folgt um den Aufruf von Spielregeln:
	+
	+	<code c>
	+	int main(int argc, char *argv[])
	+	{
	+	int zellen_vorhanden_lebendig = 0;
	+	char buffer_tastatureingabe[16] = {0};
	+
	+	zellen_vorhanden_lebendig = anfangsgeneration_platzieren();
	+	printf("Spielfeld: %i x %i (Zeilen x Spalten).\n", SPIELFELD_HOEHE_ZEILEN, SPIELFELD_BREITE_SPALTEN);
	+	printf("Anfangsgeneration platziert: %i Zellen.\n", zellen_vorhanden_lebendig);
	+
	+	auf_tastatureingabe_warten("Enter druecken: ", NULL, 0);
	+
	+	printf("Die Anfangsbelegung:\n");
	+	spielfeld_anzeigen();
	+
	+	// Alle Regeln in der Schleife anwenden.
	+	while (zellen_vorhanden_lebendig > 0) // Solange noch jemand lebt.
	+	{
	+	zellen_vorhanden_lebendig = spielregeln_anwenden(zellen_vorhanden_lebendig);
	+	spielfeld_anzeigen();
	+
	+	auf_tastatureingabe_warten("Fuer die naechste Runde Enter druecken oder STOP um zu beenden: ", buffer_tastatureingabe, sizeof(buffer_tastatureingabe));
	+	if (strcmp(buffer_tastatureingabe, "stop") == 0)
	+	break;
	+	}
	+
	+	if (zellen_vorhanden_lebendig > 0) printf("Endergebnis: %i Zellen sind am Leben.\n", zellen_vorhanden_lebendig);
	+	else printf("Alle sind tot.\n");
	+
	+	return EXIT_SUCCESS;
	+	} // main()
	+	</code>
	+
	+	Um den Code etwas zu übersichtlicher zu gestalten, ersetzen wir die Werte 0 und 1 für die toten und die lebendigen Zellen durch entsprechnde Makros:
	+
	+	<code c>
	+	#define ZELLE_TOT 0
	+	#define ZELLE_LEBENDIG 1
	+	</code>
	+
	+	Die anfangsgeneration_platzieren() sieht nachher wie folgt aus:
	+
	+	<code c>
	+	int anfangsgeneration_platzieren()
	+	{
	+	int anzahl_zellen = 0;
	+	int zeile, spalte;
	+
	+	// TODO: Lebendige Zellen auf dem Spielfeld (zunaechst statisch) verteilen.
	+	spielfeld[1][1] = ZELLE_LEBENDIG;
	+	spielfeld[1][2] = ZELLE_LEBENDIG;
	+	spielfeld[1][3] = ZELLE_LEBENDIG;
	+	spielfeld[2][3] = ZELLE_LEBENDIG;
	+
	+	for (zeile = 0; zeile < SPIELFELD_HOEHE_ZEILEN; zeile++) // UEber alle Zeilen von oben nach unten.
	+	{
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++) // UEber alle Spalten von links nach rechts.
	+	{
	+	if (spielfeld[zeile][spalte] == ZELLE_LEBENDIG) // Lebendige Zellen zaehlen.
	+	anzahl_zellen++;
	+	}
	+	}
	+
	+	return anzahl_zellen;
	+	} // anfangsgeneration_platzieren()
	+	</code>
	+
	+	Auch in der Funktion spielfeld_anzeigen() ersetzen wir:
	+
	+	<code c>
	+	if (spielfeld[zeile][spalte] == 1) printf("o");
	+	</code>
	+
	+	...durch:
	+
	+	<code c>
	+	if (spielfeld[zeile][spalte] == ZELLE_LEBENDIG) printf("o");
	+	</code>
	+
	+
	+	===== Schritt 4: Redundanz beseitigen =====
	+
	+	In der spielregeln_anwenden() haben wir ein TODO - die Anzahl lebenden Zellen neu zu ermitteln. Dafür erstellen wir eine Funktion lebende_zellen_zaehlen():
	+
	+	<code c>
	+	int lebende_zellen_zaehlen()
	+	{
	+	int anzahl_zellen = 0;
	+	int zeile, spalte;
	+
	+	for (zeile = 0; zeile < SPIELFELD_HOEHE_ZEILEN; zeile++) // UEber alle Zeilen von oben nach unten.
	+	{
	+	for (spalte = 0; spalte < SPIELFELD_BREITE_SPALTEN; spalte++) // UEber alle Spalten von links nach rechts.
	+	{
	+	if (spielfeld[zeile][spalte] == ZELLE_LEBENDIG) // Lebendige Zellen zaehlen.
	+	anzahl_zellen++;
	+	}
	+	}
	+
	+	return anzahl_zellen;
	+	} // lebende_zellen_zaehlen()
	+	</code>
	+
	+	Diese Funktion rufen wir dann in der spielregeln_anwenden(), die jetzt wie folgt aussieht:
	+
	+	<code c>
	+	int spielregeln_anwenden(int anzahl_zellen_vorher)
	+	{
	+	int anzahl_zellen_nachher = 0;
	+
	+	printf("Anzahl lebendiger Zellen VOR der Anwendung von Spielregeln: %i Zellen.\n", anzahl_zellen_vorher);
	+
	+	// TODO: Alle Spielregeln nacheinander anwenden.
	+
	+	anzahl_zellen_nachher = lebende_zellen_zaehlen(); // Anzahl lebenden Zellen neu ermitteln.
	+
	+	printf("Anzahl lebendiger Zellen NACH der Anwendung von Spielregeln: %i Zellen.\n", anzahl_zellen_nachher);
	+
	+	printf("Ergebnis: ");
	+	if (anzahl_zellen_nachher > anzahl_zellen_vorher) printf("Zuwachs von %i Zellen\n", anzahl_zellen_nachher - anzahl_zellen_vorher);
	+	else if (anzahl_zellen_nachher < anzahl_zellen_vorher) printf("Verlust von %i Zellen\n", anzahl_zellen_vorher - anzahl_zellen_nachher);
	+	else printf("keine Veraenderung\n");
	+
	+	return anzahl_zellen_nachher;
	+	} // spielregeln_anwenden()
	+	</code>
	+
	+	An dieser Stelle stellen wir fest, dass diese Zählung wir bereits in der anfangsgeneration_platzieren() gemacht haben. Diese Redundanz müssen wir jetzt beseitigen. Statt die lebenden Zellen direkt in der anfangsgeneration_platzieren() zu zählen, rufen wir dort einfach die lebende_zellen_zaehlen() auf:
	+
	+	<code c>
	+	int anfangsgeneration_platzieren()
	+	{
	+	int anzahl_zellen = 0;
	+
	+	// TODO: Lebendige Zellen auf dem Spielfeld (zunaechst statisch) verteilen.
	+	spielfeld[1][1] = ZELLE_LEBENDIG;
	+	spielfeld[1][2] = ZELLE_LEBENDIG;
	+	spielfeld[1][3] = ZELLE_LEBENDIG;
	+	spielfeld[2][3] = ZELLE_LEBENDIG;
	+
	+	anzahl_zellen = lebende_zellen_zaehlen();
	+
	+	return anzahl_zellen;
	+	} // anfangsgeneration_platzieren()
	+	</code>
	+
	+
	+	===== Schritt 5: Fehler beseitigen =====
	+
	+	Wenn wir das Programm ausführen, es fällt auf, dass das Programm sich durch die Eingabe des Worts "stop" nicht beenden läßt.
	+	Da die Prüfung, was über die Tastatur eingegeben wirde, in der Funktion main() stattfindet:
	+
	+	<code c>
	+	if (strcmp(buffer_tastatureingabe, "stop") == 0)
	+	break;
	+	</code>
	+
	+	...wollen wir wissen, welchen Inhalt die Variable "buffer_tastatureingabe" hat.
	+	Um den Fehler zu finden, ergänzen wir die main() um die Ausgabe des o.g. Wertes:
	+
	+	<code c>
	+	printf("DEBUG: VAR [%s] = [%s]\n", "buffer_tastatureingabe", buffer_tastatureingabe);
	+	if (strcmp(buffer_tastatureingabe, "stop") == 0)
	+	break;
	+	</code>
	+
	+	Ein kurzer Test zeigt, dass der Zeilenumbruch am eingegebenen Wort "klebt":
	+
	+	<code>
	+	Fuer die naechste Runde Enter druecken oder STOP um zu beenden: stop
	+	DEBUG: VAR [buffer_tastatureingabe] = [stop
	+	]
	+	</code>
	+
	+	Der Fehler liegt offensichtlich darin, dass das Abschneiden von %%'\n'%%, das wir in der auf_tastatureingabe_warten() vornehmen, nicht funktioniert:
	+
	+	<code c>
	+	if (strlen(zeilenbuffer) > 0) // Ist der gelesene String nicht leer?
	+	{
	+	if (zeilenbuffer[strlen(zeilenbuffer)] == '\n') // Evtl. vorhandenes '\n'...
	+	zeilenbuffer[strlen(zeilenbuffer)] = '\0'; // ...beseitigen.
	+	}
	+	</code>
	+
	+	Ja, klar - das kann nicht funktionieren! Die Zeichen-Positionen innerhalb eines C-Strings fangen nicht bei 1, sondern bei 0 an. Das heißt, das Zeichen %%zeilenbuffer[strlen(zeilenbuffer)]%% liegt hinter dem letzten Zeichen im String - wir brauchen eine Position davor.
	+	Hier ist die Korrektur:
	+
	+	<code c>
	+	if (strlen(zeilenbuffer) > 0) // Ist der gelesene String nicht leer?
	+	{
	+	if (zeilenbuffer[strlen(zeilenbuffer) - 1] == '\n') // Evtl. vorhandenes '\n'...
	+	zeilenbuffer[strlen(zeilenbuffer) - 1] = '\0'; // ...beseitigen.
	+	}
	+	</code>
	+
	+	Problem gelöst!
	+
	+	===== Schritt 6 =====
	+
	+	FIXME
	+
	+	----
	+	Stand: 26.09.2018
	+
	+	EOF

JK-Wiki edv:prg:c:c_lernen

edv:prg:c:c_lernen:conways_spiel_des_lebens