Score Funktion einbauen



  • Hallo!

    Ich bin noch Neuling, was die Programmierung im Allgemeinen und speziell C++ betrifft. Für mein Studium muss ich ein Dame-Spiel programmieren. Nun fehlt mir nur noch die Ausgabe des Spielstandes, wer wieviele Steine bereits geschlagen hat. Wie und an welcher Stelle des Codes schreibe ich das richtig, welcher Spieler wieviele Steine geschlagen hat? Ich habe einen Versuch im Code drin, welcher aber leider nicht funktioniert hat.
    Es wäre mega toll, wenn mir jmd helfen könnte bitte!

    Hier der Code:

    /*  ===========================================================================
        Dies ist ein einfaches Dame-Spiel, welches direkt über den Compiler
        aufgerufen und gespielt wird. Es gelten die gängigen Spielregeln.
        Jedoch gibt es hier nicht die Möglichkeit sich eine "Dame" durch
        das Erreichen der letzten Reihe des Gegners Seite zu erspielen.
        Die in der letzten Reihe angelangte Figur kann nicht mehr gezogen werden.
        Gespielt wird mit 2 Spielern. Spieler WEISS = W, Spieler SCHWARZ = S.
        Für die Eingabe der Felder des jeweiligen Zuges wird zuerst das
        aktuelle Feld der Figur mit Reihe und Spalte (ohne Zeichen dazwischen)
        angegeben und mit Enter bestätigt. Dann wird das Zugfeld ebenfalls
        mit Reihe und Spalte gewählt und mit Enter bestätigt.
        Anschließend ist der der Gegner am Zug.
        ---------------------------------------------------------------------------
        Erstellt von: 
        ===========================================================================*/
    
    #include<stdio.h> // Standard Header zum Anlegen,Öffnen,Lesen,Schreiben,Überschreiben,Löschen von Files, Texteingabe und -ausgabe
    #include<vector>  // Standard Header zum Nutzen von dynamischen Arrays
    #include<string>  // Standard Header für String Operatoren
    #include<iostream>
    
    using namespace std; // erspart std:: vor cout und weiteren Befehlen
    
    #define REIHE 8 //legt die Anzahl der Brettreihen fest
    #define SPALTE 8 //legt die Anzahl der Brettspalten fest
    
    #define LEER 			1 	// freies Feld, wo man hin ziehen könnte
    #define WEISS 			2 	// Spieler WEISS
    #define SCHWARZ 		3 	// Spieler SCHWARZ
    #define DAMEWEISS 		4 	// Damefigur von Spieler WEISS
    #define DAMESCHWARZ 	5 	// Damefigur von Spieler SCHWARZ
    
    #define ISTWEISS(c)  (c == WEISS || c == DAMEWEISS)
    #define ISTSCHWARZ(c) (c == SCHWARZ || c == DAMESCHWARZ))
    #define ISTLEER(c) (c == 1)
    
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    // Ein Vector, der alle bisherigen Spielzüge speichert
    
    vector<vector<int>> boardmoves;
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    /*  Das Array board enthält die momentane Situation des Spielfeldes, plus, die
        Startbelegung der Felder (3 = Spieler 2, 1 = leeres Feld, 2 = Spieler 1). Es
        handelt sich um ein zweidimensionales Array. */
    
    int board[REIHE][SPALTE]={
        {0,2,0,2,0,2,0,2},
        {2,0,2,0,2,0,2,0},
        {0,2,0,2,0,2,0,2},
        {1,0,1,0,1,0,1,0},
        {0,1,0,1,0,1,0,1},
        {3,0,3,0,3,0,3,0},
        {0,3,0,3,0,3,0,3},
        {3,0,3,0,3,0,3,0}
    };
    
    // Aktueller Spieler
    int ply = WEISS;
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void printDisplay(int d[][SPALTE]);
    void swapIJKL(int d[REIHE][SPALTE], int i, int j, int k, int l); // übernimmt die neue Position der gezogenen Figur
    char value2symbol(int i);
    void printDisplayFancy(int d[][SPALTE]);
    int Playersturn(int d[][SPALTE], int player,int i,int j,int k,int l);
    void saveBoard();
    void takeBackLastMove();
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    // Spielzustand speichern
    void saveBoard()
    {
    	vector<int> m;
    
    	for (int r=0; r<REIHE; r++)
    	{
    		for (int c=0; c<SPALTE; c++)
    		{ m.push_back(board[r][c]); }
    	}
    
    	boardmoves.push_back(m);
    }
    
    // Letzten Zug zurücknehmen
    void takeBackLastMove()
    {
    	// Aber nur zurücknehmen, wenn es noch was zum Zurücknehmen gibt
    	if (boardmoves.size() > 0)
    	{
    		int curpos=0;
    		for (int r=0; r<REIHE; r++)
    		{
    			for (int c=0; c<SPALTE; c++)
    			{
    				board[r][c] = boardmoves[boardmoves.size()-1][curpos];
    				curpos++;
    			}
    		}
    
    		// Entferne letzte Situation aus dem Speicher
    		boardmoves.pop_back();
    	}
    }
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void printDisplayFancy(int d[][SPALTE])
    {
        int rr, cc;
    
    	system("clear");
    
        printf("  +---+---+---+---+---+---+---+---+\n"); //Bildet die Feldlinien
    
        for (rr=0; rr<REIHE; ++rr)
        {
            printf("%d |", rr+1); // Beschriftung der Zeilen
            for (cc=0; cc<SPALTE; ++cc)
            {
                printf(" %c |", value2symbol(d[rr][cc]) ); // Feldkante
            }
            printf("\n"); // \n steht für endl (endline) und macht einen Zeilenumbruch
            printf("  +---+---+---+---+---+---+---+---+\n"); //Bildet die Feldlinien
        }
    
        printf("    a   b   c   d   e   f   g   h\n\n"); // Beschriftung der Spalten
    }
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    void swapIJKL(int d[REIHE][SPALTE], int i, int j, int k, int l)
    {
        int temp;
    
        printf("SWAP: %d,%d to %d,%d\n", i, j, k, l);
    
        temp = d[i][j];
    
        d[i][j] = d[k][l];
    
        d[k][l] = temp;
    }
    
    char value2symbol(int i) // ersetzt den Inhalt des gesprungenen Feldes durch den neuen Inhalt
    {
        switch(i)
        {
            case 0:
                return ' ';
            case 1:
                return '.'; // legt .  als Symbol für ein leeres Feld fest
            case 2:
                return 'W'; // legt W als Symbol für Spieler WEISS fest
            case 3:
                return 'S'; // legt S als Symbol für Spieler SCHWARZ fest
        }
        return ('?');
    }
    
    int Playersturn(int d[][SPALTE], int player,int i,int j,int k,int l)
    {
        int jmp_r;
        int jmp_c;
    
        if(player == WEISS){
            printf("WEISS zieht von %d,%d to %d,%d\n", i, j, k, l);
        } else {
            printf("SCHWARZ zieht von %d,%d to %d,%d\n", i, j, k, l);
        }
    
        if(i < 0 && REIHE <= i){
            printf("i ist verboten\n");
            return -1;
        }
        if(j < 0 && SPALTE <= j){
            printf("j ist verboten");
            return -1;
        }
    
        if(k < 0 && REIHE <= k){
            printf("k ist verboten");
            return -1;
    
        }
        if(l < 0 && SPALTE<= l){
            printf("l ist verboten\n");
            return -1;
        }
    
        if(player == WEISS){
            if(d[i][j] != WEISS){
                printf("Bewege deine eigene Figur!\n");
                return -1;
            }
        } else {
            if(d[i][j] != SCHWARZ){
                printf("Bewege deine eigene Figur!\n");
                return -1;
            }
        }
    
        if(d[k][l] != LEER){
            printf("Du musst auf ein leeres Feld ziehen!");
            return -1;
        }
    
    
        if(player == WEISS){
            if(i >= k){
                printf("Spieler WEISS muss sich nach unten bewegen!\n");
                return -1;
            }
        } else {
            if(i <= k){
                printf("Spieler SCHWARZ muss sich nach oben bewegen!\n");
                return -1;
            }
        }
    
        if(i - k == -1 || i - k == 1){
            if(j - l == 1 || j - l == -1){
                swapIJKL(d,i,j,k,l);
                return 0;
            }
        }
        if(i - k == -2 || i - k == 2){
            if(j - l == -2 || j - l == 2){
                if(i < k){
                    jmp_r = i + 1;
                } else {
                    jmp_r = i - 1;
                }
                if(j < l){
                    jmp_c = j + 1;
                } else {
                    jmp_c = j - 1;
                }
    
                if(player==WEISS && d[jmp_r][jmp_c]!=SCHWARZ)
                {
                    printf("Der Gegner ist nicht schwarz auf %d%d",jmp_r, jmp_c);
                    return -1;
                }
                if(player==SCHWARZ && d[jmp_r][jmp_c] != WEISS){
                    printf("Du kannst nur über den Gegner springen.\n");
                    return -1;
                }
    
                d[jmp_r][jmp_c] = 1;
                swapIJKL(d,i,j,k,l);
                return 0;
            }
        }
    
        printf("Du kannst dich nur diagonal bewegen.\n");
        return -1;
    
    }
    
    
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    // "Undo" Funktion
    bool askForUndo(char x)
    {
    	bool r=false;
    	if (x=='j')
    	{
    		// Zug entfernen und Board neu rendern
    		takeBackLastMove();
    		printDisplayFancy(board);
    
    		// Spieler switchen um unfaire Vorteile zu vermeiden
    		if (ply == SCHWARZ) { ply = WEISS; }
    		else { ply = SCHWARZ; }
    
    		// Undo ist true
    		r=true;
    	}
    	return r;
    }
    
    // Haupteinstiegspunkt und Game-Loop
    
    int main()
    {
      int i, k;
      char j, l;
    
    
      // Spielstand ausgeben
    
      int score_WEISS, score_SCHWARZ;
      cout << "Spielstand: \n\n";
      score_WEISS = j++;
      cout << "WEISS: " << score_WEISS << endl;
      score_SCHWARZ = l++;
      cout << "SCHWARZ: " <<score_SCHWARZ << endl;
    
    
    
        for(;;){
            printDisplayFancy(board);
            while(1)
            {
            	// Nur wenn Züge vorhanden sind kann man in der Zeit zurückgehen
            	if (boardmoves.size() > 0)
            	{
    				printf(" -> Feld zurücksetzen? (j/n) \n");
    				char a;
    				scanf(" %c", &a);
    				if (askForUndo(a) == true) { break; }
    			    }
    
            	// Je nach dem wer dran ist, den Text zeigen
            	if (ply == WEISS)   { printf(" -> WEISS ist am Zug und zieht von Feld (Reihe Spalte):   "); }
            	if (ply == SCHWARZ) { printf(" -> SCHWARZ ist am Zug und zieht von Feld (Reihe Spalte): "); }
    
            	// Move einscannen
    			scanf("%d%c",&i,&j);
    			printf("    nach: ");
    			scanf("%d%c",&k,&l);
    
    			// Diese Situation sichern
    			saveBoard();
    
    			// Zug durchführen
    			if(Playersturn(board, ply, i-1,j - 'a',k-1,l - 'a') == 0)
    			{
    				if (ply == SCHWARZ) { ply = WEISS; }
    				else { ply = SCHWARZ; }
    				break;
    			}
    			// Oder informieren dass das nicht geht
    			printf("Ungültiger Zug. Versuche es erneut.\n");
            }
        }
    
    	getchar();
    	getchar();
    
        return 0;
    }
    


  • @Picus Ich glaube die Aufgabe meint eher, dass du das Dame-Spiel selbst programmieren sollst, nicht nur die Score-Funktion.



  • @Bashar Das verstehe ich grad nicht. Wie meinst du das? Das Spiel ist doch programmiert...!? Es fehlt eben nur noch die besagte Funktion.



  • @Picus sagte in Score Funktion einbauen:

    Das Spiel ist doch programmiert...!?

    Sag' Deinem Compiler mal als erstes, dass er möglichst viele Warnungen ausspucken soll. Ich rate mal: 3.8 Options to Request or Suppress Warnings

    Und dann solltest Du wenn Du Fragen hast evtl. vorher Smart Questions lesen. "Funktioniert nicht" ist keine Fehlerbeschreibung. Da wo Du jetzt // Spielstand ausgeben hast, bevor noch irgendjemand gezogen hat, macht es auf jeden Fall nur wenig sinn. Wahrscheinlich möchtest Du den Spielstand am Ende von jedem Schleifendurchlauf ausgeben.



  • @Picus sagte in Score Funktion einbauen:

    // \n steht für endl (endline) und macht einen Zeilenumbruch

    \n steht für NEWLINE und macht einen Zeilenumbruch.
    endl macht noch einen flush



  • @Picus sagte in Score Funktion einbauen:

    Wie und an welcher Stelle des Codes schreibe ich das richtig, welcher Spieler wieviele Steine geschlagen hat?

    Du solltest auch den Score aktualisieren, wenn ein Stein geschlagen wurde.

    Die Ausgabe kannst du machen, wenn du das Spielfeld ausgibst.


  • Mod

    @Picus Nichts fuer ungut: Dein Post ist ein wenig unbeholfen, und zeigt ein Minimum an Eigeninitiative. Wir machen keine Aufgaben, sondern diskutieren abstrakte oder konkrete Problemstellungen. Bitte lies Dir dies durch: https://www.c-plusplus.net/forum/topic/200753/du-brauchst-hilfe

    Dann am Besten einen neuen Thread aufmachen.



  • @Columbo sagte in Score Funktion einbauen:

    Dann am Besten einen neuen Thread aufmachen.

    Noch einen?


Log in to reply