Bitte um Hilfe (Spielstand programmieren)!



  • Hallo!

    Ich bin noch Neuling, was die Programmierung im Allgemeinen und speziell C++ betrifft. Für mein Studium muss ich ein Dame-Spiel programmieren. Der Code steht auch soweit und das Spiel funktioniert auch (über den Compiler). Nun fehlt mir nur noch die Ausgabe des Spielstandes, wer wieviele Steine bereits geschlagen hat.
    Es wäre mega toll, wenn mir jmd helfen könnte bitte! 🙂

    Hier mal der Code:

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

    #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]) );
        }
        printf("\n");
        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)
    {
    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;

    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;
    

    }



  • Du hast vergessen eine Frage zu deinem Problem zu stellen.

    inb4 markdown is hard



  • @Cardiac Ich zitiere mich selbst: "Nun fehlt mir nur noch die Ausgabe des Spielstandes, wer wieviele Steine bereits geschlagen hat.
    Es wäre mega toll, wenn mir jmd helfen könnte bitte! "



  • @Picus sagte in Bitte um Hilfe (Spielstand programmieren)!:

    @Cardiac Ich zitiere mich selbst: "Nun fehlt mir nur noch die Ausgabe des Spielstandes, wer wieviele Steine bereits geschlagen hat.
    Es wäre mega toll, wenn mir jmd helfen könnte bitte! "

    Du hast vergessen eine Frage zu stellen.



  • @Picus formatiere bitte deinen Code richtig.
    Kompletten Code mit der Maus markieren und dann auf das </> Symbol neben der Auswahlbox mit dem C++ klicken.

    In welchen Variablen speicherst du den Spielstand?



  • Da geht's weiter: Score Funktion einbauen


Log in to reply