Minesweeper in C

[Luis W. (brausedealer)]

Hey erstmal, ich bin mir nicht sicher ob ich hier im richtigen Forum 
gelandet bin. Aber ich wollte mich sowieso mal Anmelden da war das jetzt 
der richtige Zeitpunkt.

Zu meinem Problem ich muss für ein Uni Projekt Minesweeper als Konsolen 
Variante erstellen.

Unter GCC linux

Ich habe schon angefangen und bin so auf meine Probleme gestoßen:

Das aufdecken: Ich überprüfe auf anliegende Minen, das geht. Außer ich 
bin am rand des Spielfeld.

Und das "automatische" aufdecken bis eine Mine kommt. Ich verstehe schon 
nicht ganz nach welchen System das Minesweeper macht. da kann ich es 
natürlich auch schwer umsetzen :-D

Das leeren der Konsole um das aktuelle Feld auszugeben haut auch noch 
nicht so hin.



Hier mein code bist jetzt

/*
 ============================================================================
 Name        : Pool3_Minesweeper_V2.c
============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define TRUE 1
#define FALSE 0

int **board;
int n, m;
FILE *datei;


void build_board(char *argv[]);
void build_mines(int anzahl);
void write_board(char *argv[]);
int check_mines(int x, int y);
void refresh_board(char *argv[]);

int main(int argc, char *argv[]) {
  if(argc == 4){// Kontrolle ob die richtige anzahl an werten übergeben wurde
    int groese = 0, min = 0, max = 0, anzahl = 0, i, j;

    n = atoi(argv[1]); //n aus Konsolenparameter auslesen
    m = atoi(argv[2]); //m aus Konsolenparameter auslesen

    /*n = 20;
    m = 20;*/
    if(10 <= n && n <= 26 && 10 <= m && m <= 26){ // Kontrolle ob n und m im richtigen bereich liegen

        groese = n * m; // größe des Feldes

        //Minimale und Maximale anzahl der bomben
        min = (groese * 10) / 100;
        max = (groese * 25) / 100;

        srand (time (NULL)); //zufallszahl beginnen
        anzahl = (rand () % ((max + 1) - min)) + min; // Zufällige anzahl der bomben bestimmen

        //Speicherzuweißung
        board = (int **)malloc(n * sizeof(int *));
        for(i = 0; i < n; i++){
          board[i] = (int *)malloc(m * sizeof(int));
          }

        //Board mit 0 füllen, 0 ist die anzeige falls noch nicht aufgedeckt
        for(i = 0; i < n; i++){
          for(j = 0; j < m; j++){
            board[j][i] = 0;
            }
          }
          build_board(argv);
          build_mines(anzahl);
      
          refresh_board(argv);
          write_board(argv);
        }
      else{ printf("Ihre Eingabe Daten sind falsch\n");}

      }

    else{printf("Ihre Eingabe Daten sind falsch\n");}

    return EXIT_SUCCESS;
}

void build_board(char *argv[]){
  int i, j;
  datei = fopen(argv[3], "w+");
  //datei = fopen("test", "w+");
  for(j = 0; j < m; j++){
    for(i = 0; i < n; i++){
      fputc(48, datei);
      fputc(32, datei);
    }
    fputc(10, datei);
    }

  fclose(datei);
}

void build_mines(int anzahl){
  int i = anzahl;
  srand (time (NULL));
  while(i > 0){
    board[rand() % n ][rand() % m ] = 9;
    i -=1;
  }

}

int check_mines(int x, int y){
  int zahl = 0, i, j;

  for(i = x - 1; i < 4; i++){
    for(j = y - 1; j < 4; j++){
      if(board[i][j] == 1) zahl++;
      }
    }

  return zahl;
}

void write_board(char *argv[]){
  int temp;
  datei = fopen(argv[3], "r");

  //Hier sollte der bisherige Ausgabe gelöscht werden um das Aktuelle Feld auszugeben
  //system("clear");
  printf("\033[2J\033[1;1H");

  while((temp = fgetc(datei))!=EOF) {
    printf("%c", temp);
  }
  fclose(datei);

}

void refresh_board(char *argv[]){
  int i, j;
  datei = fopen(argv[3], "r+");
  for(i = 0; i < n; i++){
    for(j = 0; j < m; j++){
        if(board[j][i] == 9){
          fputc(48, datei);
          fputc(32, datei);
          }
        else{
          fputc(board[j][i] + 48, datei);
          fputc(32, datei);
        }
      }
      fputc(10, datei);
    }
  fclose(datei);
}

int uncover(int x, int y){
  int mine = FALSE;
  if(board[x][y] == 9) mine = TRUE;
  else{
    board[x][y] = check_mines(x, y);
  }

  return mine;
}

Copy paste der Aufgabe:


-ein rechteckiges Spielfeld mit n x m Feldern generieren und in einer 
Textdatei abspeichern.

Auf die Felder des Spielfelds sollen zufällig Minen verteilt werden. 
Dabei dürfen die verteilten Minen insgesamt nicht weniger als 10% und 
nicht mehr als 25% des Spielfeldes belegen.
In Feldern, auf denen keine Mine abgelegt wurde, soll die Anzahl der an 
das jeweilige Feld angrenzenden Minen angezeigt werden und zwar auch bei 
diagonaler Verbindung der Felder

Minesweeper spielen lassen, bis entweder alle minenfreien Felder 
gefunden wurden, oder bis beim Aufdecken der Felder eine Mine getroffen 
wurde.

Bei Spielbeginn sollen alle Felder verdeckt dargestellt werden (weder 
Minen noch sonstige Angaben sichtbar)
Spielzüge sollen per Tastatureingabe erfolgen. Die Auswahl eines Feldes 
erfolgt durch Angabe seiner Zeilen- und Spaltenkoordinate (z.B. G12). 
Mögliche Spielzüge sind „Feld aufdecken“ (A) oder „Feld markieren / 
Markierung entfernen“ (M). Ist ein Feld bereits markiert, dann wird die 
Markierung bei erneutem Markieren entfernt. Ein markiertes Feld darf 
nicht aufgedeckt werden.
Wird ein leeres, also ein minenfreies Feld aufgedeckt, dann sollen 
angrenzende Felder in der das aufgedeckte Feld umgebenden Fläche soweit 
aufgedeckt werden, bis entweder ein bereits markiertes Feld oder eine 
Mine gefunden werden. Das bereits markierte Feld oder die Mine werden 
nicht mehr aufgedeckt und bilden so den Rand der aufgedeckten Fläche. In 
allen Randfeldern dieser Fläche soll jeweils die Anzahl der Minen 
dargestellt werden, die auf den außen angrenzenden, also noch verdeckten 
Feldern liegen.
Die Darstellung bereits aufgedeckter Felder soll bei den weiteren 
Spielzügen nicht mehr verändert werden.
Das Spiel ist gewonnen, sobald alle minenfreien Felder aufgedeckt sind.
Das Spiel ist verloren, sobald beim Aufdecken eine Mine getroffen wurde.

am Spielende das nachfolgend definierte Spielergebnis auf dem Bildschirm 
anzeigen und an die bereits erstellte Textdatei anhängen.

Alle nicht getroffenen Minen, alle korrekt markierten Minen, sowie ggf. 
die beim Aufdecken getroffene Mine sollen zusätzlich zu den im 
bisherigen Spielverlauf dargestellten Angaben auf dem Spielfeld 
angezeigt werden.
Die Spieldauer in Minuten und die Anzahl der getätigten Spielzüge sollen 
ausgegeben werden.

[Dussel (Gast)]

Luis W. schrieb:
> Das aufdecken: Ich überprüfe auf anliegende Minen,
Warum das? Zu Spielbeginn legst die Minen und berechnest danach für 
jedes Feld die Anzahl der benachbarten Minen. Beim Aufdecken wird nur 
noch abgelesen, ob auf dem Feld eine Mine, eine Zahl oder gar nichts 
ist.

Luis W. schrieb:
> Und das "automatische" aufdecken bis eine Mine kommt.
Wenn gar nichts darauf ist, wird jedes Feld benachbarte Feld aufgedeckt, 
auf dem gar nichts oder eine Zahl ist. Das für jedes dadurch aufgedeckte 
Feld wiederholen.

[Luis W. (brausedealer)]

Das mit dem Check mines funktioniert ja. deswegen würde ich das auch 
beibehalten.
Und selbst wenn. wie soll ich dann den unterschied zwischen einem 
Aufgedeckten Feld und einem nicht aufgedeckten Feld erkennen. Dann sind 
ja alle von Anfang an mit zahlen voll.
Dann müsste ich das ganze Prinzip ändern.

[Dussel (Gast)]

Luis W. schrieb:
> wie soll ich dann den unterschied zwischen einem
> Aufgedeckten Feld und einem nicht aufgedeckten Feld erkennen.
Über ein int-Array, bool gibt es ja in C nicht.

Luis W. schrieb:
> Dann sind ja alle von Anfang an mit zahlen voll.
Die 0 darfst du halt nicht anzeigen.

Ich muss dazu sagen, dass ich dein Programm nicht nachvollzogen habe.
Mein Ansatz wäre, ein Array für das Spielfeld zu machen, in dem die 
Anzahl der angrenzenden Minen eingetragen ist. 0 wird als leeres Feld 
angezeigt und zum Beispiel 9 steht für Mine. Je nachdem, ob Laufzeit 
oder Speicher wichtiger ist, kann man in das Array auch noch ein Flag 
für 'verdeckt', 'markiert' und 'offen' speichern, ansonsten ein 
separates Array dafür anlegen.
Wie gesagt, ich würde die Zahlen direkt bei der Erzeugung des Spielfelds 
berechnen.