Rekursive Funktion bei Minesweeper, C++



  • Hallo 🙂

    Unsere aktuelle Aufgabe (10. Klasse, Informatikkurs) ist das Programmieren eines kleinen Minesweepers als C++ Konsolenanwendung.

    Theoretisch habe ich noch eine Woche Zeit für die Abgabe, praktisch habe ich heute nix zu tun, die restliche Woche aber kaum Zeit.

    Aktuell hänge ich an der "Rekursiven Funktion".
    Wir sollen das Aufdecken der "0" damit schreiben..
    Nur wie? 😕
    Also grob weiß ich was gemacht werden soll:
    Koordinate wird eingegeben, trifft sie in dem 10x10 Feld (10 Bomben) auf eine 0, sollen alle weiteren Nullen im Umkreis aufgedeckt werden.

    Die Rekursive Funktion ist übrigens Pflicht..

    Kann mir jemand "vereinfacht" erklären was ich dafür machen soll?
    Mein Spiel ist sonst soweit fertig, auch die Feldüberprüfung der Zahlen stimmt.
    Nur das Mehrfache Aufdecken bekomme ich nicht hin..

    Meine aktuelle Spielfeldoberfläche wird mit '#' angezeigt, das Spielfeld darunter sind Zahlen und '*' für die Bomben..

    Ich bedanke mich schonmal für jede Hilfe!



  • Lolli schrieb:

    Kann mir jemand "vereinfacht" erklären was ich dafür machen soll?
    Mein Spiel ist sonst soweit fertig, auch die Feldüberprüfung der Zahlen stimmt.
    Nur das Mehrfache Aufdecken bekomme ich nicht hin..

    Ich hab mich vielleicht etwas falsch ausgedrückt.
    Grob was eine Rekursive Funktion ist, weiß ich.
    Ich habe auch schon versucht eine zusammen zu basteln, aber die funktioniert einfach nicht.
    Hier mal mein komplettes bisheriges Programm.
    DIe Rekursive Funktion soll " func_aufdecken" werden. 🙂

    //Minesweeper.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <cstdlib>
    #include <stdlib.h>
    #include <time.h>
    
    using namespace std;
    char Spielfeld[10][10];
    char GUI_Spielfeld[10][10];
    int m, n;
    
    //Aufbau des Grundspielfeldes
    void func_leeren()
    {
    	//10 x 10 Spielfeld wird erzeugt
    	for (int i = 0; i < 10; i++)
    	{
    		for (int j = 0; j < 10; j++)
    		{
    			Spielfeld[i][j] = 'x';
    		}
    	}
    }
    
    //Aufbau des angezeigten Spielfeldes
    void func_GUI_leeren()
    {
    
    	for (int i = 0; i < 10; i++)
    	{
    		for (int j = 0; j < 10; j++)
    		{
    			GUI_Spielfeld[i][j] = '#';
    			//Erzeugt ein Spielfeld mit Rauten, 10 x 10
    		}
    	}
    }
    
    void func_bomben()
    {
    	//Zeit wird auf 0 gesetzt, damit die Erzeugung der Bomben _wirklich_ Random ist
    	srand(time(NULL));
    
    	int x = 10;
    	int y = 10;
    
    	//10 Bomben werden ins Spielfeld gelegt
    	for (int i = 0; i < 10; i++)
    	{
    		x = rand() % 10;
    		y = rand() % 10;
    
    		if (Spielfeld[x][y] != '*')
    		{
    			Spielfeld[x][y] = '*';
    		}
    		else
    		{
    			i--;
    			//Wenn das Feld schon eine '*' Bombe hat, berechnet er für die neue Bombe i--
    		}
    
    	}
    }
    
    void func_zahlen()
    //Zahlen werden um die Bomben herum berechnet (Zahl gibt Anzahl der umliegenden Bomben an)
    // Es müssen 8 Felder abgeprüft werden, bei Bombenfund wird die Zahl i++ berechnet.
    {
    	int count;
    
    	for (int i = 0; i < 10; i++)
    	{
    		for (int j = 0; j < 10; j++)
    		{
    			count = 0;
    
    			// Es gibt 8 Fälle zum Berechnen einer Zahl, bzw. 8 "Richtungen" in die "geschaut" wird.
    			// Ist die eingegebene Koordinate selbst eine Bombe, ist das Spiel vorbei
    
    			//i ist die Horizontale, j die Vertikale
    
    			//Nach oben gucken
    			if ((Spielfeld[i][j - 1] == '*') && (j>0))
    			{
    				count++;
    			}
    
    			//Nach unten gucken
    			if ((Spielfeld[i][j + 1] == '*') && (j < 9))
    			{
    				count++;
    			}
    
    			//Nach rechts gucken
    			if ((Spielfeld[i + 1][j] == '*') && (i <9))
    			{
    				count++;
    			}
    
    			//Nach links gucken
    			if ((Spielfeld[i - 1][j] == '*') && (i >0))
    			{
    				count++;
    			}
    
    			//Nach schräg oben links gucken
    			if ((Spielfeld[i - 1][j - 1] == '*') && (i > 0) && (j > 0))
    			{
    				count++;
    			}
    
    			//Nach schräg unten rechts gucken
    			if ((Spielfeld[i + 1][j + 1] == '*') && (i <9) && (j < 9))
    			{
    				count++;
    			}
    
    			//Nach schräg oben rechts gucken
    			if ((Spielfeld[i + 1][j - 1] == '*') && (i<9) && (j>0))
    			{
    				count++;
    			}
    
    			//Nach schräg unten links gucken
    			if ((Spielfeld[i - 1][j + 1] == '*') && (i>0) && (j<9))
    			{
    				count++;
    			}
    
    			if (Spielfeld[i][j] != '*')
    			{
    				Spielfeld[i][j] = 48 + count;
    			}
    		}
    		cout << endl;
    	}
    }
    
    void func_aufdecken(int i, int j)
    {
    	//Prüfen ob keine Bombe in dem Feld ist und aufdecken
    	if (Spielfeld[i][j] != '*')
    	{
    		Spielfeld[i][j] = GUI_Spielfeld[i][j];
    	}
    	//Prüfen ob eine 0 in dem Feld ist und die Rekursive starten muss
    	if (Spielfeld[i][j] == 48)
    	{	//Spielfeld grenze angeben und die Rundumprüfung							
    		if (i > 0 && Spielfeld[i - 1][j] == '#')
    		{
    			func_aufdecken(i - 1, j);
    		}
    		if (i < 10 && Spielfeld[i + 1][j] == '#')
    		{
    			func_aufdecken(i + 1, j);
    		}
    		if (j > 0 && Spielfeld[i][j - 1] == '#')
    		{
    			func_aufdecken(i, j - 1);
    		}
    		if (j < 10 && Spielfeld[i][j + 1] == '#')
    		{
    			func_aufdecken(i, j + 1);
    		}
    		if (i > 0 && j > 0 && Spielfeld[i - 1][j - 1] == '#')
    		{
    			func_aufdecken(i - 1, j - 1);
    		}
    		if (i > 0 && j < 10 && Spielfeld[i - 1][j + 1] == '#')
    		{
    			func_aufdecken(i - 1, j + 1);
    		}
    		if (i < 10 && j > 0 && Spielfeld[i + 1][j - 1] == '#')
    		{
    			func_aufdecken(i + 1, j - 1);
    		}
    	}
    }
    
    //Einstellung und Design des Spielfeldes
    void func_design()
    {
    	for (int i = 0; i < 10; i++)
    	{
    		for (int j = 0; j < 10; j++)
    		{
    			cout << GUI_Spielfeld[i][j] << ' ';
    
    		}
    		cout << endl;
    	}
    }
    
    //Zeigt das blanke Spielfeld (Zahlen und Bomben) an, wurde zur Überprüfung der Bombenbelegung eingepflegt
    void func_Hilfsanzeige()
    {
    	for (int i = 0; i < 10; i++)
    	{
    		for (int j = 0; j < 10; j++)
    		{
    			cout << Spielfeld[i][j] << ' ';
    
    		}
    		cout << endl;
    	}
    }
    
    //Eingabeaufforderung an den Spieler
    void func_feldauswahl()
    {
    	int ikoordinate;
    	int jkoordinate;
    	cout << "Bitte i-Koordinate (Horizontale) eingeben(zwischen 0 und 9)";
    	cin >> ikoordinate;
    	cout << "Bitte j-Koordinate (Vertikale) eingeben (zwischen 0 und 9)";
    	cin >> jkoordinate;
    
    	//Gleichsetzung der Spielfelder
    	GUI_Spielfeld[ikoordinate][jkoordinate] = Spielfeld[ikoordinate][jkoordinate];
    	if (GUI_Spielfeld[ikoordinate][jkoordinate] == '*')
    	{
    		cout << "Autsch! Du hast leider verloren" << endl;
    		//Ausgabe bei einem verlorenen Spiel 
    	}
    }
    
    int main()
    
    {
    
    	//Aufruf der Funktionen zum Erstellen des Spielfeldes
    	int x;
    	//func_leeren();
    	func_GUI_leeren();
    	func_bomben();
    
    	//Funktionen zur Ausgabe des sichtbaren Spielfeldes
    	func_zahlen();
    	func_design();
    	while (true)
    	{
    		//func_Hilfsanzeige zum Einblenden des blanken Feldes, Überprüfung der Bomben. i.d.R. Ausgeblendet
    		func_Hilfsanzeige();
    		func_feldauswahl();
    		func_aufdecken(m,n);
    		func_design();
    
    	}
    	cin >> x;
    	return 0;
    }
    


  • Falsches Unterforum, hier ist C++/CLI, eine .NET Sprache und NICHT ISO C++.


Log in to reply