4-Gewinnt Diagonal nach 4 gleichen Zeichen in einer Reihe Absuchen.

Hallo C++ Community,

Ich habe ein Problem (klar sonst würde ich keine Frage stellen ;D)

Ich arbeite momentan an einem 4-Gewinnst spiel, was auch soweit funktioniert bis auf den Punkt das ich es nicht schaffe in den Diagonalen nach 4 gleichen Zeichen in einer Reihe zu suchen. Da ich nicht weis was ihr alles von meinem Code braucht lade ich mal den gesamten hoch.

#include <conio.h>
#include <iostream.h>
#include <string.h>
#include <math.h>

/*4-Gewinnt */
//------------------------------------------------------------------------------
//Globale Variablen
//Initialisieren des Feldes   
char Feld [6][7];
int Runde = 0;

//Funktionen
void FeldAnzeigen();
void Verarbeiten(int);
int Kontrolle();
int Zug();

//Hauptprogramm
int main ()
{
//Sonstige Variablen
    int Zeile, Spalte;
    int ZugSpalte=0;
    int Kontrollwert=0;

cout<<"==============================================================================="<<endl;
cout<<"================================= 4-Gewinnt ==================================="<<endl;
cout<<"==============================================================================="<<endl<<endl<<endl;

cout<<"================================== Regeln: ===================================="<<endl;
cout<<"1. Spieler 1 ist [x] Spieler 2 ist [#]."<<endl;
cout<<"2. Ziel des Spieles ist es 4 Steine seiner Form in eine Reihe zu bekommen."<<endl;
cout<<"3. Erlaubt sind Diagonal, Senkrecht und Wagerecht."<<endl;
cout<<"==============================================================================="<<endl<<endl<<endl;

    cout<<"1 - 2 - 3 - 4 - 5 - 6 - 7";
    for (Zeile = 0; Zeile <= 5 ;Zeile++)
        {   
        cout<<endl;
        for (Spalte = 0; Spalte <= 6; Spalte++)
            {
            Feld [Zeile][Spalte]=' ';
            cout<<Feld [Zeile][Spalte]<<" | ";
            }
        }
do
{        
ZugSpalte = Zug ();
Verarbeiten(ZugSpalte); 
FeldAnzeigen();

Runde++;

Kontrollwert=Kontrolle();
}
while(Kontrollwert == 0);

if(Kontrollwert == 1)
{
                   cout<<"\nSpieler 1 [x] hat gewonnen!"<<endl;
}
else if (Kontrollwert == 2)
{
                   cout<<"\nSpieler 2 [#] hat gewonnen!"<<endl;
}

getch();
}

//--------------------------FUNKTIONEN-----------------------------------------
//Grafische Ausgabe des Aktuellen Feldes
void FeldAnzeigen ()
{
cout<<"==============================================================================="<<endl;
cout<<"================================= 4-Gewinnt ==================================="<<endl;
cout<<"==============================================================================="<<endl;

    cout<<"1 - 2 - 3 - 4 - 5 - 6 - 7";
    for (int Zeile = 0; Zeile <= 5; Zeile++)
        {   
        cout<<endl;
        for (int Spalte = 0; Spalte <= 6; Spalte++)
            {
            cout<<Feld [Zeile][Spalte]<<" | ";
            }        
        }
}

//Zug
//Eingabe des Zuges
int Zug ()
{
    int ZugSpalte=0;
    do
    {
    cout<<endl<<endl<<"In welche Spalte wollen sie setzen?"<<endl;    
    cin>>ZugSpalte;
    ZugSpalte=ZugSpalte-1;

//Kontrolle ob Spalte gültig
    if(ZugSpalte<0 || ZugSpalte>6)
      {
      cout<<"Zahl zwischen 1 und 7 eingeben."<<endl;
      }
    if(Feld[0][ZugSpalte]!=' ' && ZugSpalte<0 || ZugSpalte>6 && Feld[0][ZugSpalte]!=' ')
      {
      cout<<"Spalte ist bereits voll. Bitte andere Spalte ausw\x84hlen."<<endl;
      }
    }
    while(ZugSpalte<0 || ZugSpalte>6 || Feld[0][ZugSpalte]!=' ');

system("cls");
return ZugSpalte;
}

//Verarbeiten der Auswahl
void Verarbeiten (int ZugSpalte)   
{    
    bool Stopper=1;
    for(int i=6;i>=0;)
    {   
    if(Feld [i][ZugSpalte]==' ' && Stopper==1)
      {
            if (Runde % 2 == 0)
            {
               Feld [i][ZugSpalte]='x';
               Stopper=0;
            }
            else
            {
               Feld [i][ZugSpalte]='#';
               Stopper=0;                
            }     
      }
    else
      {
      i=i-1;
      }
    }
} 

//Kontrolle
int Kontrolle ()
{

//Kontrolle der Spalten
//------------------------------------------------------------------------------
    int Zeile = 0, Spalte = 0, Counter = 0;

    for (Spalte = 0; Spalte <= 6; Spalte++)
        {   
        for (Zeile = 0; Zeile <= 5 ;Zeile++)
            {
            if(Feld [Zeile][Spalte]=='x')
                    {
                    Counter++;        
                    }
                    else
                        {
                        Counter = 0;
                        }
            if (Counter == 4)
               {
               return 1;
               }
            }
        }            
Counter = 0;

    for (Spalte = 0; Spalte <= 6; Spalte++)
        {   
        for (Zeile = 0; Zeile <= 5 ;Zeile++)
            {
            if(Feld [Zeile][Spalte]=='#')
                    {
                    Counter++;        
                    }
                    else
                        {
                        Counter = 0;
                        }
            if (Counter == 4)
               {
               return 2;
               }
            }
        }
Counter = 0;
//------------------------------------------------------------------------------        

//Kontrolle der Zeilen
//------------------------------------------------------------------------------
    for (Zeile = 0; Zeile <= 5 ;Zeile++)
        {   
        for (Spalte = 0; Spalte <= 6; Spalte++)
            {
            if(Feld [Zeile][Spalte]=='x')
                    {
                    Counter++;        
                    }
                    else
                        {
                        Counter = 0;
                        }
            if (Counter == 4)
               {
               return 1;
               }
            }
        }            
Counter = 0;

    for (Zeile = 0; Zeile <= 5 ;Zeile++)
        {   
        for (Spalte = 0; Spalte <= 6; Spalte++)
            {
            if(Feld [Zeile][Spalte]=='#')
                    {
                    Counter++;        
                    }
                    else
                        {
                        Counter = 0;
                        }
            if (Counter == 4)
               {
               return 2;
               }
            }
        }
Counter = 0;
//------------------------------------------------------------------------------

//Kontrolle der Diagonalen
//------------------------------------------------------------------------------    
return 0;        
}

Es tut mir Leid das mein Problem so überhaupt nicht eingegrenzt ist aber ich weis halt echt nicht wie ich das machen soll. hab zwar schon folgendes Probiert:

for (Spalte = 0, Zeile = 0; Spalte <= 6 && Zeile <= 5; Spalte++, Zeile++)
        {   
        if(Feld [Zeile][Spalte]=='x')//bzw # für den anderen Spieler
                    {
                    Counter++;        
                    }
                    else
                        {
                        Counter = 0;
                        }
            if (Counter == 4)
               {
               return 1;
               }
        }

aber das kontrolliert halt nur von ganz oben rechts an....

Ich hoffe ihr könnt mir irgendwie helfen.

MfG.: Jörn G.

Ich meinte das geht halt nur von ganz oben Links an....

Ohne deinen Code angesehen zu haben ein kleiner Tipp: Du brauchst nicht das gesamte Feld zu durchsuchen sondern nur die Geraden und Diagonalen des letzten gesetzten Steins.

DarkShadow44

int KontrolleDiagonal()
{
	for(int Spalte=0; Spalte<=6; Spalte++)
	{
		for(int Zeile=0; Zeile<=5; Zeile++)
		{
			int Counter=0;

			for(int x=Spalte, y=Zeile; x<=6 && y<=5; x++, y++) //nach rechts unten
			{
				if(Feld[y][x]=='x')
				{
					Counter++;
				}
			}
			if(Counter>=4)
				return 1;

			Counter=0;
			for(int x=Spalte, y=Zeile; x>=0 && y<=5; x--, y++) //nach links unten
			{
				if(Feld[y][x]=='x')
				{
					Counter++;
				}
			}
			if(Counter>=4)
				return 1;
		}
	}

	return 0;
}

Sollte so gehen. Du gehts einfach alle Felder durch und prüfst dabei von jedem aus nach links und rechts diagonal. Mag nicht die effizienteste Lösung sein aber es ist eine

Und nur mal so als Tipp, du solltest den Kontrollcode in eine extra Methode packen und ihr beim Aufrufen sagen welcher Spieler es ist und auf welches Zeichen geprüft wird, dann hast du den ganzen Kontrollcode nicht doppelt