4. Game of Life

Game of Life

  • ?

    Hallo,
    Ich muss (leider) game of life programmieren, und es ist mir nicht ganz gelungen.
    Ich erkläre erstmal meine Idee:
    erst erzeug ich ein leeres Feld.

    Dann schreibe ich eine Funktion die mir was "malen" sollte.
    Dann der Algorithmus, der nach den Spielregeln die Nachbarn der Zelle abcheckt und danach entweder die Zelle tötet oder diese leben lässt.

    Jetzt schreib ich eine funktion die mir die Daten aus dem Feld 1 im Feld 2 sichert.

    Jetzt kommt die Main in der die Regeln erklärt werden und die vorherigen Funktionen aufgerufen werden

    #include <stdio.h>
#define Hoehe = 22
#define Breite = 22

void reset(int *feld){
     int x,y;
     for( y=0 ; y <= Hoehe-1 ; y++){
         for(x=0;x<=Breite-1;x++){
                                  feld[x + y*(Breite - 1)]  = 0;
                                  }
         }
}

void malen(int *feld) {
     int x,y;
     for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  if (feld[x + y*Breite] == 0){ 
                                  printf("-");                                                              
                                  else 
                                  printf("*");
                                  }
                                  } 
         printf("\n");
         }
}

int game(int *feld1, int *feld2) {
    int Nachbar,x,y;
    Nachbar = 0;
    for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  if (feld1[(x-1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (Nachbar >= 1 && Nachbar <= 3){
                                              feld2[x + y*Breite] = 1;
                                                                    }
                                  else {
                                       feld2[x + y*Breite] = 0;
                                       }
                                       Nachbar = 0;
                                       }
                                       }
                                  }

void abgleich(int *feld1, int *feld2) {
     int x,y;
     for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  feld1[x +y*Breite] = feld2[x + y*Breite];
                                  }
                                  }
                                  }

main () {
int x,y;
char a;
printf("Regeln\n");
printf("Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation\n");
printf("Der Zustand einer Zelle, lebendig oder tot, in der Folgegeneration hängt nur vom\n");
printf("Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.");
printf("Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.\n");
printf("Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.\n");
printf("Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.\n");
printf("Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.\n");
printf("Geben Sie die x und die y Koordinaten der Ursprungsindividuen in der Form x y ein.\n Um das Spiel zu starten, geben Sie 0 0 ein");

feld1 = malloc(sizeof(int)*(Breite,Hoehe));
feld2 = malloc(sizeof(int)*(Breite,Hoehe));
reset(&feld1);
reset(&feld2);
malen(&feld1);
while(y!=0;x!=0) {
                 scanf("%i /%i",&x,&y));
                 if(0<x<Breite-1 && 0<y<Hoehe-1){
                                 feld1[x + y*Breite] = 1;
                                 }
                 else {
                      if(y!=0 && x!=0) {
                              printf("Ungueltig");
                              }
                      }
                 do {
                     game(&feld1,&feld2);
                     abgleich(&feld1,&feld2);
                     malen(&feld1,&feld2);
                     printf("Noch mal? J\N");
                     scanf(("%c", &a);
                     }
                     while(a == J)
                 }
system ("pause");
}

    zum Verständnis:
    das Spielfeld selbst ist 20 auf 20, hat jedoch noch eine Zeile und Spalte am Rand als Sicherheitsabstand, damit mir die Indizes nicht abhauen.

    Das Problem ist schon in den ganzen for schleifen, der Compiler sagt, dass da
    syntax error before '=' token vorliegt
    und weitere sachen, die ich nicht verstehe, was ihm fehlt.

    Kann mir einer bitte helfen?
    Danke im Voraus

    0
  • M

    Da haben sich Gleichheitszeichen in die define's geschlichen. Nimm die mal raus und versuch's nochmal.

    0
  • L

    Wow, ich würd dich gleich heiraten.
    Damit haben sich alle Probleme bis auf Main gelöst.
    Ich hab jetzt ausgebessert

    main () {
int x,y;
char a;
printf("Regeln\n");
printf("Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation\n");
printf("Der Zustand einer Zelle, lebendig oder tot, in der Folgegeneration hängt nur vom\n");
printf("Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.");
printf("Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.\n");
printf("Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.\n");
printf("Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.\n");
printf("Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.\n");
printf("Geben Sie die x und die y Koordinaten der Ursprungsindividuen in der Form x y ein.\n Um das Spiel zu starten, geben Sie 0 0 ein");
feld1 = (int*)malloc(sizeof(int)*(Breite,Hoehe));
feld2 = (int*)malloc(sizeof(int)*(Breite,Hoehe));
reset(&feld1);
reset(&feld2);
malen(&feld1);
while(y!=0;x!=0) {
                 scanf("%i /%i",&x,&y));
                 if(0<x<Breite-1 && 0<y<Hoehe-1){
                                 feld1[x + y*Breite] = 1;
                                 }
                 else {
                      if(y!=0 && x!=0) {
                              printf("Ungueltig");
                              }
                      }
                 do {
                     game(&feld1,&feld2);
                     abgleich(&feld1,&feld2);
                     malen(&feld1,&feld2);
                     printf("Noch mal? J\N");
                     scanf(("%c", &a);
                     }
                     while(a == J)
                 }
system ("pause");
}

    dennoch bitcht der Kompiler rum, dass feld1 nicht definiert ist, genau so wie feld2.

    0
  • F

    Der Compiler sagt dir wohl eher, dass die nicht deklariert sind, womit er recht hat. Wo ist denn "int *feld1";

    (int*)malloc(sizeof(int)*(Breite,Hoehe));

    (Breite,Hoehe) macht bestimmt auch nicht das, was du willst.

    "while(a == J) " macht auch keinen Sinn.

    0
  • L

    Ich will ja feld1 initialisieren und zwas mit malloc, der versteht ja (int*)malloc(sizeof(int)* und jetzt muss eine Zahl folgen
    mir ist klar, dass (Hoehe,Breite) keine Zahl ist, aber Hoehe * Breite geht auch nicht.
    while (a == J) soll heißen, dass nach der Abfrage "Nochmal?" nur nach einem J weitergemacht wird. Warum geht es dann nicht?

    0
  • L
     

    #include <stdio.h>
#define Hoehe 22
#define Breite 22

void reset(int *feld){
     int x,y;
     for( y=0 ; y <= Hoehe-1 ; y++){
         for(x=0;x<=Breite-1;x++){
                                  feld[x + y*(Breite - 1)]  = 0;
                                  }
         }
}

void malen(int *feld) {
     int x,y;
     for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  if (feld[x + y*Breite] == 0){ 
                                  printf("-");  
                                  }                                                            
                                  else {
                                  printf("*");
                                  }
                                  } 
         printf("\n");
         }
}

int game(int *feld1, int *feld2) {
    int Nachbar,x,y;
    Nachbar = 0;
    for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  if (feld1[(x-1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (Nachbar >= 1 && Nachbar <= 3){
                                              feld2[x + y*Breite] = 1;
                                                                    }
                                  else {
                                       feld2[x + y*Breite] = 0;
                                       }
                                       Nachbar = 0;
                                       }
                                       }
                                  }

void abgleich(int *feld1, int *feld2) {
     int x,y;
     for(y=1;y<=Hoehe-2;y++){
         for(x=1;x<=Breite-2;x++){
                                  feld1[x +y*Breite] = feld2[x + y*Breite];
                                  }
                                  }
                                  }

main () {
int k,x,y;
char a;
printf("Regeln\n");
printf("Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation\n");
printf("Der Zustand einer Zelle, lebendig oder tot, in der Folgegeneration hängt nur vom\n");
printf("Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.");
printf("Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.\n");
printf("Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.\n");
printf("Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.\n");
printf("Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.\n");
printf("Geben Sie die x und die y Koordinaten der Ursprungsindividuen in der Form x y ein.\n Um das Spiel zu starten, geben Sie 0 0 ein");

feld1 = (int*)malloc(sizeof(int)*Hoehe); 
for (k=0; k<(Hoehe-1); k++) feld1[k] = malloc(sizeof(int)*Breite);

feld2 = malloc(sizeof(int)*Hoehe); 
for (k=0; k<(Hoehe-1); k++) feld1[k] = malloc(sizeof(int)*Breite);

reset(&feld1);
reset(&feld2);
malen(&feld1);
while(y!=0,x!=0) {
                 scanf("%i %i",&x,&y);
                 if(0<x<Breite-1 && 0<y<Hoehe-1){
                                 feld1[x + y*Breite] = 1;
                                 }
                 else {
                      if(y!=0 && x!=0) {
                              printf("Ungueltig");
                              }
                      }
                 do {
                     game(&feld1,&feld2);
                     abgleich(&feld1,&feld2);
                     malen(&feld1);
                     printf("Noch mal? J? N?");
                     scanf("%c", &a);
                     }
                     while(a == 'J');
                 }
system ("pause");
}

    Jetzt habe ich nur noch Probleme mit feld1 und feld2 initialisieren.

    0
  • F

    Du musst aber irgendwo die beiden Variablen deklarieren, tust du aber nicht. Wie du das machst, habe ich dir bereits oben gezeigt.

    "aber Hoehe * Breite geht auch nicht" weil?

    "Warum geht es dann nicht?"

    Weil es while(a == 'J') ist.

    0
  • ?

    Leziras schrieb:

    Ich will ja feld1 initialisieren und zwas mit malloc, der versteht ja (int*)malloc(sizeof(int)* und jetzt muss eine Zahl folgen
    mir ist klar, dass (Hoehe,Breite) keine Zahl ist, aber Hoehe * Breite geht auch nicht.

    int k,x,y;  // k,x,y sind vom Typ int
char a;     // a ist vom Typ char 
...
feld1 = (int*)malloc(sizeof(int)*Hoehe); // a [b]ist[/b] vom Typ ?? steht nirgends.
                                         // Es zählt nicht was du meinst was es ist. Der Compiler muss es wissen.

    Hast du Hoehe * Breite nochmal ohne die '=' un den defines probiert?

    Leziras schrieb:

    while (a == J) soll heißen, dass nach der Abfrage "Nochmal?" nur nach einem J weitergemacht wird. Warum geht es dann nicht?

    Weil J ein Variablenname ist, den der Compiler nicht kennt. Das Zeichen J sieht so aus : 'J' . Die ' sind wichtig.

    0
  • L

    Danke, jetzt hab ich allerdings das Problem, dass er mir in den Funktionen
    reset, malen, abgleich
    folgenden Fehler ausgibt
    87 [Warning] passing arg 1 of `reset' from incompatible pointer type
    und den Fehler zugehörig zu jeder Zeile, in der eine der oben genannten Funktionen auftaucht.

    0
  • L
     

    main () {
int x,y,*feld1,*feld2;
char a;
printf("Regeln\n");
printf("Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation\n");
printf("Der Zustand einer Zelle, lebendig oder tot, in der Folgegeneration hängt nur vom\n");
printf("Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.");
printf("Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.\n");
printf("Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.\n");
printf("Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.\n");
printf("Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Überbevölkerung.\n");
printf("Geben Sie die x und die y Koordinaten der Ursprungsindividuen in der Form x y ein.\n Um das Spiel zu starten, geben Sie 0 0 ein");

feld1 = (int*)malloc(sizeof(int)*(Hoehe*Breite));

feld2 = (int*)malloc(sizeof(int)*(Hoehe*Breite));

reset(&feld1);
reset(&feld2);
malen(&feld1);
while(y!=0,x!=0) {
                 scanf("%i %i",&x,&y);
                 if(0<x<Breite-1 && 0<y<Hoehe-1){
                                 feld1[x + y*Breite] = 1;
                                 }
                 else {
                      if(y!=0 && x!=0) {
                              printf("Ungueltig");
                              }
                      }
                 do {
                     game(&feld1,&feld2);
                     abgleich(&feld1,&feld2);
                     malen(&feld1);
                     printf("Noch mal? J? N?");
                     scanf("%c", &a);
                     }
                     while(a == 'J');
                 }
system ("pause");
}

    so sieht jetzt die main aus.

    0
  • F

    Alle Funktionsaufrufe ohne &.

    0
  • L

    Jetzt geht zumindest das Fenster auf.
    Problem er berechnet iwas falsch,ich glaub er überschreibt und fügt zu viel ein.
    außerdem er fragt mich die ganze Zeit Nochmal?
    Die Abfrage ist also in der Schleife gefangen, aber ich schaffe es nicht, diese aus der Schleife zu entfernen um dann erst nach den Berechnungen den Spieler zu fragen.

    Ich hab im abgleich feld1 mit feld 2 vertauscht, außerdem die schleifen erst über x dann über y laufen lassen, damit die koordinaten wirklich als x y verstanden werden. jetzt zeichnet mir das programm die eingegebenen koordinaten ein.

    #include <stdio.h>
#define Hoehe 22
#define Breite 22

void reset(int *feld){
     int x,y;
     for( x=0 ; x <= Hoehe-1 ; x++){
         for(y=0;y<=Breite-1;y++){
                                  feld[x + y*(Breite - 1)]  = 0;
                                  }
         }
}

void malen(int *feld) {
     int x,y;
     for(x=1;x<=Hoehe-2;x++){
         for(y=1;y<=Breite-2;y++){
                                  if (feld[x + y*Breite] == 0){ 
                                  printf("-");  
                                  }                                                            
                                  else {
                                  printf("*");
                                  }
                                  } 
         printf("\n");
         }
}

int game(int *feld1, int *feld2) {
    int Nachbar,x,y;
    Nachbar = 0;
    for(x=1;x<=Hoehe-2;x++){
         for(y=1;y<=Breite-2;y++){
                                  if (feld1[(x-1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y-1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + y*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x-1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[x + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (feld1[(x+1) + (y+1)*Breite] == 1){
                                  Nachbar++;                       }
                                  if (Nachbar >= 1 && Nachbar <= 3){
                                              feld2[x + y*Breite] = 1;
                                                                    }
                                  else {
                                       feld2[x + y*Breite] = 0;
                                       }
                                       Nachbar = 0;
                                       }
                                       }
                                  }

void abgleich(int *feld1, int *feld2) {
     int x,y;
     for(x=1;x<=Hoehe-2;x++){
         for(y=1;y<=Breite-2;y++){
                                  feld2[x +y*Breite] = feld1[x + y*Breite];
                                  }
                                  }
                                  }

main () {
int x,y,*feld1,*feld2;
char a;
printf("Regeln\n");
printf("Die Folgegeneration wird für alle Zellen gleichzeitig berechnet und ersetzt die aktuelle Generation\n");
printf("Der Zustand einer Zelle, lebendig oder tot, in der Folgegeneration haengt nur vom\n");
printf("Zustand der acht Nachbarzellen dieser Zelle in der aktuellen Generation ab.");
printf("Eine tote Zelle mit genau drei lebenden Nachbarn wird in der Folgegeneration neu geboren.\n");
printf("Lebende Zellen mit weniger als zwei lebenden Nachbarn sterben in der Folgegeneration an Einsamkeit.\n");
printf("Eine lebende Zelle mit zwei oder drei lebenden Nachbarn bleibt in der Folgegeneration lebend.\n");
printf("Lebende Zellen mit mehr als drei lebenden Nachbarn sterben in der Folgegeneration an Ueberbevoelkerung.\n");
printf("Geben Sie die x und die y Koordinaten der Ursprungsindividuen in der Form x y ein.\n ");

feld1 = (int*)malloc(sizeof(int)*(Hoehe*Breite));

feld2 = (int*)malloc(sizeof(int)*(Hoehe*Breite));

reset(feld1);
reset(feld2);
malen(feld1);
while(y!=0,x!=0) {
                 scanf("%i %i",&x,&y);
                 if(0<x<Breite-1 && 0<y<Hoehe-1){
                                 feld1[x + y*Breite] = 1;
                                 }
                 else {
                      if(y!=0 && x!=0) {
                              printf("Ungueltig");
                              }
                      }
                 do {
                     game(feld1,feld2);
                     abgleich(feld1,feld2);
                     malen(feld1);                      
                     printf("\n Noch mal? J? N? \n");
                     scanf("%c", &a);
                     }
                     while(a == 'J');
                     }
system ("pause");
}
    0
  • ?

    Du musst mal schauen ob x zu Hoehe oder Breite gehört.

    Und mach doch ein Funktion zur Eingabe so wie reset oder malen.

    0
  • V

    if(0<x<Breite-1 && 0<y<Hoehe-1) geht so nicht (jedenfalls nicht so, wie du es möchtest).

    if(x>=0 && x<Breite-1 && y>=0 && y<Hoehe-1)

    In der Funktion Reset kannst du auch memset nutzen, warum du beim Malen die erste und letzte Spalte sowie die erste und letzte Zeile ignorierst, ist mir auch nicht ganz klar.

    Etwas kurios ist auch deine Verwendung von x und y.

    0
  • L

    Hab jetzt x der Breite und y der Hoehe zugeordnet.
    Ich lasse die Ränder unberücksichtigt, damit ich keine indexprobleme habe, falls ich die zelle 1 1 betrachte und dabei nach schräg oben gehe.

    Es wundert mich, dass das Programm nicht das Richtige berechnet, ich wunder mich nur warum.

    Ich hab die Idee die ungenutze obere Zeile und linke Spalte als beschriftung zu verwenden.
    also sowas in der art wie

    int y;
       for(y = 1; y<=10; y++){
       y++;
       printf("%i", &y);}

    nur klappt bei mir nicht einmal das.

    0
  • ?

    Du kannst mit (x%Breite) und (y%Hoehe) den Überlauf verhindern. % ist der Modulo-Operator. Dadurch wird nur auf Indizes zwischen 0 und Breite/Hoehe zugegriffen. Netter Effekt ist auch noch dass das Feld "Kugelförmig" wird. Was links raus wandert kommt rechts wieder rein. Ebenso für oben/unten/rechts.

    Abgesehen davon:
    - Was macht das Programm?
    - Was erwartest du?
    - Was erscheint auf dem Schirm?

    0
  • ?

    soll ich dir meinen GoL code schicken? hatten wir vor 2 jahren im unterricht.

    0
  • ?

    isssnichwahr schrieb:

    soll ich dir meinen GoL code schicken? hatten wir vor 2 jahren im unterricht.

    Gibt es genug im Netz.
    Auch hier im Forum.

    Aber Leziras soll es selber machen und was lernen. Wenn es dann läuft, kann man sich vergleichen und sehen was gut und schlecht gelöst wurde.

    0
Anmelden zum Antworten