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;
}

theta

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