3. Problem bei 4 gewinnt implementierung

Problem bei 4 gewinnt implementierung

  • M

    Die Funktionsdeklarationen und -definitionen darfst du natürlich nicht so verändern. Es muss ja ein Hinweis darauf bleiben, dass du kein einzelnes int-Objekt, sondern ein zweidimensionales Feld von int-Objekten übergeben willst.

    0
  • R

    Ich habe dann jetzt die prototypen in wie folgt geänder

    #include<iostream>
using namespace std;

void gewonnen_s1(int feld[][],int s,int r);
void gewonnen_s2(int feld[][],int s,int r);
    0
  • M

    Wenn du ne Fehlermeldung bekommst, wärs nett, uns das auch mitzuteilen.

    Dein Code kompiliert, wenn du nur die zwei Zeilen änderst, in denen du deine Funktionen aufrufst.

    #include <iostream>
using namespace std;

int gewonnen_s1(int feld[7][6],int s,int r);
int gewonnen_s2(int feld[7][6],int s,int r);

int main()
{
    int reihe,spalte;
    int spielfeld[7][6]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    while(1)
    {
    cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 1: \n";
    cout<<"\nSpalte: \n";
    cin>>spalte;
    cout<<"\nReihe: \n";
    cin>>reihe;
    while(spielfeld[spalte][reihe]!=0)
    {
        cout<<"\nDieses Feld ist schon belegt\n";
        cout<<"\nSpalte: \n";
        cin>>spalte;
        cout<<"\nReihe: \n";
        cin>>reihe;
    }
    spielfeld[spalte][reihe]=1;
    gewonnen_s1(spielfeld,spalte,reihe);    // Änderung 1
    cout<<"\nGeben sie ihre Spalte und Reihe ein, Spieler 2: \n";
    cout<<"\nSpalte: \n";
    cin>>spalte;
    cout<<"\nReihe: \n";
    cin>>reihe;
    while(spielfeld[spalte][reihe]!=0)
    {
        cout<<"\nDieses Feld ist schon belegt\n";
        cout<<"\nSpalte: \n";
        cin>>spalte;
        cout<<"\nReihe: \n";
        cin>>reihe;
    }
    spielfeld[spalte][reihe]=2;
    gewonnen_s2(spielfeld,spalte,reihe);    // Änderung 2
    }
}

int gewonnen_s2(int feld[7][6],int s, int r)
{
    if(feld[s][r]==2 && feld[s+1][r]==2 && feld[s+2][r]==2 && feld[s+3][r]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s-1][r]==2 && feld[s-2][r]==2 && feld[s-3][r]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r+1]==2 && feld[s][r+2]==2 && feld[s][r+3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s][r-1]==2 && feld[s][r-2]==2 && feld[s][r-3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
    cout<<"Spieler 2 hat gewonnen!";
    }
    if(feld[s][r]==2 && feld[s+1][r+1]==2 && feld[s+2][r+2]==2 && feld[s+3][r+3]==2)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}

int gewonnen_s1(int feld[7][6],int s, int r)
{
    if(feld[s][r]==1 && feld[s+1][r]==1 && feld[s+2][r]==1 && feld[s+3][r]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s-1][r]==1 && feld[s-2][r]==1 && feld[s-3][r]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r+1]==1 && feld[s][r+2]==1 && feld[s][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s][r-1]==1 && feld[s][r-2]==1 && feld[s][r-3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    if(feld[s][r]==1 && feld[s+1][r+1]==1 && feld[s+2][r+2]==1 && feld[s+3][r+3]==1)
    {
    cout<<"Spieler 1 hat gewonnen!";
    }
    return 0;
}
    0

  • ReALITY5 schrieb:

    Ich habe dann jetzt die Prototypen in wie folgt geändert:

    #include <iostream>
using namespace std;

void gewonnen_s1( int feld[][], int s, int r );
void gewonnen_s2( int feld[][], int s, int r );

    Nein.

    // Deklaration:
void gewonnen_s1( int feld[ 7 ][ 6 ], int s, int r );

// Definition:

void gewonnen_s1( int feld[ 7 ][ 6 ], int s, int r )
{
    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r ] == 1 && feld[ s + 2 ][ r ] == 1 && feld[ s + 3 ][ r ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s - 1 ][ r ] == 1 && feld[ s - 2 ][ r ] == 1 && feld[ s - 3 ][ r ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s ][ r+1 ] == 1 && feld[ s ][ r + 2 ] == 1 && feld[ s ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s ][ r - 1 ] == 1 && feld[ s ][ r - 2 ] == 1 && feld[ s ][ r - 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r + 1 ] == 1 && feld[ s + 2 ][ r + 2 ] == 1 && feld[ s + 3 ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";

    if( feld[ s ][ r ] == 1 && feld[ s + 1 ][ r + 1 ] == 1 && feld[ s + 2 ][ r + 2 ] == 1 && feld[ s + 3 ][ r + 3 ] == 1 )
        cout << "Spieler 1 hat gewonnen!";
}

// Aufruf:

gewonnen_s1( spielfeld, spalte, reihe );

    Aber IMHO sind deine Tests, ob ein Spieler gewonnen hat, nicht besonders elegant implementiert.

    Greetz, Swordfish

    0
  • R

    Dein Beitrag war fehler frei. Mein fehler war es entweder überall die dimensionen rauszunehmen oder sie überall reinzuschreiben, thx nochmal 🙂

    das war mein erstesmal das ich was mit matrizen gemacht habe

    0
  • M

    Swordfish schrieb:

    Nein.

    Ich hoff ja mal, dass du vier Minuten für den Beitrag gebraucht hast und dich somit nicht auf mich beziehst, oder?

    0

  • Nein, siehe edit: quote.

    Greetz, Swordfish

    0
  • R

    Ihr meintet doch das meine Prüfung auf den Sieg schlecht implentiert ist, könnt ihr mir sagen wie ich es besser implementieren könnte?

    0
  • W

    Hallo,

    Ich habe es mir nicht angeguckt, aber es sollte in einer Schleife besser gehen.

    MFG winexec*

    0
  • M
     

    enum Direction { up = -6, down = 6, left = -1, right = 1, upRight = -5, upLeft = -7, downRight = 7, downLeft = 5 };

int getNOfEqual(int feld[7][6], int x, int y, Direction dir)
{
	int counter = 0;
	while(6*x+y + (counter+1)*dir < 42 && 6*x+y + (counter+1)*dir > -1 && *(*feld + (6*x+y + (counter+1)*dir)) == feld[x][y])
		++counter;

	return counter;
}

bool hasWon(int feld[7][6], int x, int y)
{
	if(getNOfEqual(feld, x, y, up) + getNOfEqual(feld, x, y, down) > 2)
		return true;

	if(getNOfEqual(feld, x, y, left) + getNOfEqual(feld, x, y, right) > 2)
		return true;

	if(getNOfEqual(feld, x, y, upRight) + getNOfEqual(feld, x, y, downLeft) > 2)
		return true;

	if(getNOfEqual(feld, x, y, upLeft) + getNOfEqual(feld, x, y, downRight) > 2)
		return true;
}

    Schöner find ich das zwar nicht, es deckt aber im Gegensatz zu deiner Implementation alle Fälle ab.

    0
  • R

    Als sagte Michael E.:

    class Gameboard
{
public:
...
  // besser zu einkapseln
  int grid[7][6];
};

void foo(Gameboard& board)
{
  board.grid[1][2] = 3;
}

void test()
{
  Gameboard gameboard;
  foo(gameboard);
}
    0

  • @Michael E.: Jaaaa, das nenn ich elegant 👍 😉
    @RoboTact: Hä?

    Greetz, Swordfish

    0
  • M

    Swordfish schrieb:

    @Michael E.: Jaaaa, das nenn ich elegant 👍 😉

    Es ist halt ne beschissene Abfrage, das geht nicht elegant 🕶

    @RoboTact: Hä?

    Ich denk mal, das ist ne wörtliche Übersetzung von "As Michael E. said".

    0
  • *

    Hmm insgesammt könnte man das auch einfach so lösen... k die If könnte man wirklich durch ne Schleife ersetzen... aber ansonnsten:

    // 4Win.cpp
#include <iostream>
#include <tchar.h>
#include <conio.h>

int    Close(int** /*ppField*/);
bool   IsPlayerWinner(int /*nPlayer*/, int** /*ppField*/, const int /*nCol*/, const int /*nRow*/, TCHAR* /*lpszPlayername*/);

int _tmain(int /*argc*/, _TCHAR** /*argv*/)
{
	TCHAR	cPlayer1[512];
	TCHAR	cPlayer2[512];
	int		nFieldMax	= 0;
	int**	ppField		= NULL;

	std::cout << _T("=================================================================") << std::endl;
	std::cout << _T("=		Herzlich Willkommen bei 4-Gewinnt		=") << std::endl;
	std::cout << _T("=================================================================\n") << std::endl;
	std::cout << _T("		1. Spieler: ");
	std::cin >> cPlayer1;
	std::cout << _T("		2. Spieler: ");
	std::cin >> cPlayer2;
	std::cout << _T("		Spielfeldumfang (4 - 100): ");
	std::cin >> nFieldMax;

	if (nFieldMax < 4 || nFieldMax > 100)
	{
		std::cout << _T("		Die Eingaben waren nicht korrekt!") << std::endl;
		return (Close(ppField));
	}

	std::cout << _T("\n") << std::endl;

	ppField = new int*[nFieldMax];

	for (int n = 0; n < nFieldMax; ++n)
	{
		ppField[n] = new int[nFieldMax];

		for (int j = 0; j < nFieldMax; ++j)
			ppField[n][j] = 0;
	}

	int		nRow	= 0;
	int		nCol	= 0;

	while (true)
	{
		std::cout << _T("		Geben sie ihre Spalte und Reihe ein, ") << cPlayer1 << std::endl; 
		std::cout << _T("		- Spalte: "); 
		std::cin >> nCol; 
		std::cout << _T("		- Reihe: "); 
		std::cin >> nRow;

		while (nCol > nFieldMax || nRow > nFieldMax || ppField[nCol][nRow] != 0) 
		{ 
			std::cout << _T("		In dieses Feld wurde bereits belegt. Bitte geben Sie ein anderes Feld an!") << std::endl; 
			std::cout << _T("		- Spalte: "); 
			std::cin >> nCol; 
			std::cout << _T("		- Reihe: "); 
			std::cin >> nRow; 
		} 

		ppField[nCol][nRow]		= 1; 

		if (IsPlayerWinner(1, ppField, nCol, nRow, cPlayer1))
			break;

		std::cout << _T("		Geben sie ihre Spalte und Reihe ein, ") << cPlayer2 << std::endl; 
		std::cout << _T("		- Spalte: "); 
		std::cin >> nCol; 
		std::cout << _T("		- Reihe: "); 
		std::cin >> nRow;

		while (nCol > nFieldMax || nRow > nFieldMax || ppField[nCol][nRow] != 0) 
		{ 
			std::cout << _T("		In dieses Feld wurde bereits belegt. Bitte geben Sie ein anderes Feld an!") << std::endl; 
			std::cout << _T("		- Spalte: "); 
			std::cin >> nCol; 
			std::cout << _T("		- Reihe: "); 
			std::cin >> nRow; 
		} 

		ppField[nCol][nRow]		= 2; 

		if (IsPlayerWinner(2, ppField, nCol, nRow, cPlayer2))
			break; 
	}

	return (Close(ppField));
}

int Close(int** ppField)
{
	if (ppField)
		delete [] ppField;

	getch();
    return 0;
}

bool IsPlayerWinner(int nPlayer, int** ppField, const int nCol, const int nRow, TCHAR* lpszPlayername)
{ 
    if ((ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow] == nPlayer && ppField[nCol + 2][nRow] == nPlayer && ppField[nCol + 3][nRow] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol - 1][nRow] == nPlayer && ppField[nCol - 2][nRow] == nPlayer && ppField[nCol - 3][nRow] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol][nRow + 1] == nPlayer && ppField[nCol][nRow + 2] == nPlayer && ppField[nCol][nRow + 3] == nPlayer) ||  
		(ppField[nCol][nRow] == nPlayer && ppField[nCol][nRow - 1] == nPlayer && ppField[nCol][nRow - 2] == nPlayer && ppField[nCol][nRow - 3] == nPlayer) ||
		(ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow + 1] == nPlayer && ppField[nCol + 2][nRow + 2] == nPlayer && ppField[nCol + 3][nRow + 3] == nPlayer) || 
		(ppField[nCol][nRow] == nPlayer && ppField[nCol + 1][nRow + 1] == nPlayer && ppField[nCol + 2][nRow + 2] == nPlayer && ppField[nCol + 3][nRow + 3] == nPlayer))
	{
		std::cout << _T("		") << lpszPlayername << _T(" hat gewonnen!") << std::endl; 
		return true;
	}

	return false;
}
    0
  • M

    (D)Evil schrieb:

    Hmm insgesammt könnte man das auch einfach so lösen...

    Nö :p

    Abgesehen davon, dass du || statt && willst:

    x2222x    // aktuelle Position = 2
    0
  • R

    Ich glaub, auf sowas komm ich irgendwie net allein 😞

    und einiges habe ich noch nie gesehem, also hier syntax mäsig

    0
  • *

    Hmm jop hast recht... ist auch nur vom Prinzip her...
    1. int 4 bool 1
    2. sry das muss natürlich || heißen
    3. Guck dir mal nur die Unterschiede zwischen meinem Weg und deinem an 😉

    0
  • M

    (D)Evil schrieb:

    3. Guck dir mal nur die Unterschiede zwischen meinem Weg und deinem an 😉

    Worauf willst du hinaus? Ich hab dich lediglich darauf hingewiesen, dass bei deinem Ansatz der aktuelle Stein am Rand der Viererkette sein muss.

    0

  • ReALITY5 schrieb:

    Ich glaub, auf sowas komm ich irgendwie net allein 😞

    und einiges habe ich noch nie gesehem, also hier syntax mäsig

    Kommt Zeit, kommt Rat! 👍

    Greetz, Swordfish

    0
Anmelden zum Antworten