Ziel dieser Aufgabe ist es eine einfache Version von
»Conways Spiel des Lebens«  in C zu implementieren.

Das Spielfeld wird dargestellt durch quadratische Matrizen, deren Einträge entweder belegt (bevölkert), oder nicht belegt sind. Ein Eintrag an Position (i, j) in einer Matrix wird durch seine Zeile i und sein Spalte j bezeichnet, wobei die Zählung der Zeilen und Spalten bei 0 beginnt.

Implementieren Sie die folgende C-Header Datei:

#ifndef LIFE__H
#define LIFE__H

#include <stdbool.h>

//Einfach zu benutzen um minmum und maximum eines Vergleichs zu bekommen.
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))
#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))


/** Eine Matrix besteht aus einer Kantenlänge und einem zweidimensionalen
    Array von Wahrheitswerten. 
**/
typedef struct{
  unsigned int length;
  bool** data;
} Matrix;

/**
   Erzeugt ein neues quadratisches Matrixobjekt mit Kantenlänge length.
   Auf allen Koordinaten wird der Wert false gesetzt.
*/
Matrix newMatrix(unsigned int length); 

/**
  Löscht alle Daten des Objekts komplett auf dem Heap. 
*/
void deleteMatrix(Matrix m);


/**
  Erzeugt einen String mit soviel Zeilen, wie die quadratische Matric
  hat. In jeder Zeile wird der Wert true durch das Zeichen '*' und der  
  Wert false durch das Zeichen ' ' dargestellt.

  Der erzeugte String wird in den Parameter geschrieben. Es wird davon 
  ausgegangen, dass dieser eine ausreichende Länge an Speicherplatz 
  beinhaltet.
*/
void showMatrixIn(Matrix m,char* result);

/**
  Erzeugt einen String mit soviel Zeilen, wie die quadratische Matric
  hat. In jeder Zeile wird der Wert true durch das Zeichen '*' und der  
  Wert false durch das Zeichen ' ' dargestellt.
*/
char* showMatrix(Matrix m);

/** 
  Gibt an, wieviel der maximal 8 benachbarten Felder mit true belegt sind.
*/
unsigned int anzahlBelegterNachbarn(Matrix m,unsigned int x, unsigned int y);

/** 
  Erzeugt eine neue Matrix die nach den Regeln des Spiels wie folgt belegt ist:

  Für eine Matrix-Zelle, die belegt ist:
      Jede Zelle mit einem oder keinem Nachbarn stirbt.
      Jede Zelle mit vier oder mehr Nachbarn stirbt.
      Jede Zelle mit zwei oder drei Nachbarn überlebt.

  Für eine Matrix-Zelle, die leer ist:
      Jede Zelle mit drei Nachbarn wird belegt.

Hier bedeutet ”stirbt“: nicht belegt in der Matrix (false); 
und überlebt“: belegt in der Matrix (true).


  Das Ergebnis wird in den Parameter result geschrieben. Dabei wird davon
  ausgegangen, dass m.length==result.length ist.
*/
void zugGOLIn(Matrix m, Matrix result);


/**
   Wie zugGOLIn, jedoch wird jetzt eine neue Matrix als Ergebnis erzeugt
   und zurück gegeben.
*/
Matrix zugGOL(Matrix m);

#endif

Auf einem Unix-Terminal lassen sich mit folgenden kleinen Test, nach und nach alle Generationen einer Startpopulation anzeigen:

#include "Life.h"
#include <stdio.h>
#include <unistd.h>

int main(){
  Matrix m1 ;
  Matrix m2 = newMatrix(20);

  Matrix oktagon = newMatrix(20);
  int i;
  for (i=4;i<8;i++){
    oktagon.data[3][i] = true;
    oktagon.data[8][i] = true;
    oktagon.data[i][3] = true;
    oktagon.data[i][8] = true;    
  }

  for (i=5;i<7;i++){
    oktagon.data[4][i] = true;
    oktagon.data[7][i] = true;
    oktagon.data[i][4] = true;
    oktagon.data[i][7] = true;    
  }
  
  char* ms = showMatrix(oktagon);
  printf("%s\n",ms);
  m1 = oktagon;
  printf("\033[H\033[J");
  while(true){
    printf("\033[%d;%dH",1,1);
    printf("%s\n",ms);
    zugGOLIn( m1, m2);
    showMatrixIn(m1,ms);    
    Matrix tmp = m1;
    m1=m2;
    m2=tmp;
    sleep(1);
  }
  return 0;
}