taralino

Algorithmische Beschreibung

Wir haben bereits sämtliche Grundlagen besprochen, um Simulationen zum Game of Life durchzuführen. Als kleine Zusammenfassung möchten wir den Ablauf einer Simulation algorithmisch beschreiben.

Definiere ein Spielfeld (in Abhängigkeit der Anzahl der Spalten und Zeilen) sowie eine initiale Startkonfiguration (d.h. eine erste Belegung einiger Zellen durch Individuen).

Führe nun wiederholt folgende Schritte aus, bis die Simulation abgebrochen wird:

Berechne zu jeder Zelle die Anzahl der Individuen in den acht angrenzenden Zellen (unter Berücksichtigung periodischer Randbedingungen).
Berechne unter Verwendung der zuvor definierten Regeln die neue Belegung des Spielfeldes.
Gehe wieder zu Schritt 1, um die Simulation fortzusetzen.

Genau dieser Ablauf wird in der folgenden Simulation umgesetzt. Die Startkonfiguration wird in Abhängigkeit eines Parameters erzeugt, der den (erwarteten) Anteil an Individuen definiert (in Prozent und bezogen auf die Gesamtanzahl der Zellen des Spielfeldes).

Quellcode

Grundlegende Simulation zum Game of Life mit einer zufälligen Startkonfiguration.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="taralino.js"></script>
</head>
<body>
<script>

/*******************************
  Kennzahlen zur Simulation
*******************************/

// Spielfeld (Anzahl der Zeilen und Spalten):
var s = 80;

// Anteil der (erwarteten) Individuen in Prozent:
var a = 50;


/*******************************
  Globale Variablen
*******************************/

// Leeres Spielfeld (zweidimensionales Datenfeld):
var M = [];
for (var i = 0; i < s; i++) M.push([]);
for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) M[i].push(0);

// Anzahl der Individuen in der Nachbarschaft (zweidimensionales Datenfeld):
var N = [];
for (var i = 0; i < s; i++) N.push([]);
for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) N[i].push(0);


/*******************************
  calculate_N()
*******************************/

// Der Befehl calculate_N() bestimmt fuer alle Zellen
// die Anzahl der Individuen in der jeweiligen Nachbarschaft.

function calculate_N() {
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    N[i][j] = -M[i][j];
    for (var r = -1; r <= 1; r++) for (var q = -1; q <= 1; q++) {
      N[i][j] = N[i][j] + M[(i+r+s)%s][(j+q+s)%s];
    };
  };
};


/*******************************
  calculate_M()
*******************************/

// Der Befehl calculate_M() bestimmt das neue Spielfeld unter
// Verwendung der aktuellen Belegung sowie der jeweiligen Nachbarschaft.

function f(m, n) {
  var h = 0;
  if ((m == 1) && (n == 2)) h = 1;
  if ((m == 1) && (n == 3)) h = 1;
  if ((m == 0) && (n == 3)) h = 1;
  return h;
};

function calculate_M() {
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    M[i][j] = f(M[i][j], N[i][j]);
  };
};


/*******************************
  grid()
*******************************/

// Der Befehl zeichnet das Spielfeld.

function grid() {
  Grid.clear();
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    if (M[i][j] == 1) Grid.pixel(j, i, "blue");
  };
  Grid.draw();
};


/*******************************
  setup()
*******************************/

// Der Befehl setup() wird jeweils beim Start einmalig ausgefuehrt.

function setup() {
  // Erzeugung einer zufaelligen Startkonfiguration
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    if (random(0,100) < a) M[i][j] = 1;
  };

  // Gitternetz zur Darstellung des Spielfeldes initialisieren
  var z = Math.max(1, Math.floor(320/s));
  Grid.init(s, s, {background:"lightgrey", style:"canvas", zoom:z});

  // Darstellung des Spielfeldes
  grid();

  // Simulationsgeschwindigket durch Anzahl der Schritte pro Sekunde (fps)
  Animation.init({fps:12});
};


/*******************************
  loop()
*******************************/

// Der Befehl loop() wird wird automatisch immer wieder aufgerufen.

function loop() {
  calculate_N();
  calculate_M();
  grid();
};



</script>
</body>
</html>

Vorschau Download Kopie speichern

Codingaufgabe

Mache dich mit dem Quellcode zuvor vertraut. Schaue dir dabei insbesondere die Funktion f(m,n) an, welche die Regeln der Simulation umsetzt.

Anschließend kannst du die Parameter zur Spielfeldgröße sowie zur Startkonfiguration verändert und die Simulation erneut durchführen.