4 - gewinnt in C



  • warte, 1. wo siehst du die uhrzeit + datum des posts? und 2. warte ich poste nochmal das ganze programm:

    #include <stdio.h>
    #include <stdlib.h>
    #ifdef __unix__
        #define clrscr() printf("\x1B[2J")
    #elif __BORLANDC__ && __MSDOS__
        #include <conio.h>
    #elif __WIN32__ || _MSC_VER
        #define clrscr() system("cls")
    #else
        #define clrscr() printf("clrscr() - Fehler!!\n")
    #endif
    
    #define X 'X'
    #define O 'O'
    #define LEER ' '
    #define GAME_OVER 0
    #define A_WINNER 1
    #define CONTINUE 2
    
    int main(void){
    	int i;
    		char Viergewinnt[6][7] = {	{' ',' ',' ',' ',' ',' '},
    									{' ',' ',' ',' ',' ',' '},
    									{' ',' ',' ',' ',' ',' '},
    									{' ',' ',' ',' ',' ',' '},
    									{' ',' ',' ',' ',' ',' '},
    									{' ',' ',' ',' ',' ',' '} 
    								 };
    
    		char Spieler1 = X;
    		/* Spieler2 hat das Zeichen 'O'. */
    		char Spieler2 = O;
    		/* Anzahl der Felder, die besetzt werden können */
    		unsigned int felder = 42;
    
    		void print_spielfeld(void);
    		char neuer_zug(char);
    		int if_win(void);
    
    		void print_spielfeld(void); {
    
       clrscr();
       printf("       1   2   3  \n     +---+---+---+\n");
       for(i = 0; i < 3; i++) {
          printf("  %d  | ",i+1);
          printf("%c",Viergewinnt[i][0]);
          printf(" | ");
          printf("%c",Viergewinnt[i][1]);
          printf(" | ");
          printf("%c",Viergewinnt[i][2]);
          printf(" | \n");
          if(i != 2) {
             printf("     +---+---+---+\n");
          }
          else {
             printf("     +---+---+---+\n");
          }
       }
    }
    
    	return 0;
    }
    

    Hier gibt er ein 3x3 Spielfeld (TicTacToe) aus ich will aber ein 6x7, was muss ich da noch beifügen?
    Das komische is, das void ghört wohin? weil bei tictactoe stehts dort und es funkt...



  • ca hier drüber steht die Uhrzeit.

    Blurp_ schrieb:

    Hier gibt er ein 3x3 Spielfeld (TicTacToe) aus ich will aber ein 6x7, was muss ich da noch beifügen?
    Das komische is, das void ghört wohin? weil bei tictactoe stehts dort und es funkt...

    Da TicTacToe ein 3x3 Feld hat könnte man ja mal nach den Dreien im Programm schauen und die mal durch 6 oder 7 ersetzen. Mal sehen was passiert.

    Und dann das ganze mal etwas näher am Standard:

    #include <stdio.h>
    #include <stdlib.h>
    
    void print_spielfeld(char Viergewinnt[6][7]);
    
    int main(void)
    {
            char Viergewinnt[6][7] = {  {' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' '}
                                     };
    
            char Spieler1 = X;
            /* Spieler2 hat das Zeichen 'O'. */
            char Spieler2 = O;
            /* Anzahl der Felder, die besetzt werden können */
            unsigned int felder = 42;
    
        print_spielfeld(Viergewinnt)     
        return 0;
    } // Hier ist main zu Ende
    
    // Außerhalb von main (davor oder danach, aber bitte nur an einer Stelle) können andere Funktionen definiert werden.
    void print_spielfeld(char Viergewinnt[6][7]) 
    {
        int i;
    
    //   clrscr();
       printf("       1   2   3  \n     +---+---+---+\n");
       for(i = 0; i < 3; i++) 
       {
          printf("  %d  | ",i+1);
          printf("%c",Viergewinnt[i][0]);
          printf(" | ");
          printf("%c",Viergewinnt[i][1]);
          printf(" | ");
          printf("%c",Viergewinnt[i][2]);
          printf(" | \n");
          if(i != 2) {  // Keine Ahnung was das soll
             printf("     +---+---+---+\n");  // hier wird eh das gleiche gedruckt
          }
          else {
             printf("     +---+---+---+\n");  // hier wird eh das gleiche gedruckt
          }
       }
    }
    // Als Trockenübung können da auch noch Fehler drin sein
    


  • Danke mal für deine große Hilfe 🙂

    Kurze Frage, wielange bleibst du heute noch online, bzw hast zeit mir zu helfen?



  • 20 Minuten.



  • ok, dann egal 😃 ich schau dass ich noch etaws zusammenbkomme bis morgen 😃

    Danke für deine große Hilfe aufjedenfall !



  • Hab das jz mal ausgeführt, aber iwie is das genauso wie das von vorher...bist du dir sicher, dass er da dann das 4gewinnt feld ausgibt?



  • Ich bin mir sicher, dass das TicTacToe Feld ausgegeben wird.
    Denn daran habe ich nichts geändert. Die Dreien (3) sind noch da wo sie waren.



  • //   clrscr();
       printf("       1   2   3   4   5   6   7	\n     +---+---+---+\n");
       for(i = 0; i < 6; i++)
       {
          printf("  %d  | ",i+1);
          printf("%c",Viergewinnt[0][0]);
          printf(" | ");
          printf("%c",Viergewinnt[1][1]);
          printf(" | ");
          printf("%c",Viergewinnt[2][2]);
          printf(" | \n");
          if(i != 7) {  // Keine Ahnung was das soll
             printf("     +---+---+---+\n");  // hier wird eh das gleiche gedruckt
          }
          else {
             printf("     +---+---+---+\n");  // hier wird eh das gleiche gedruckt
          }
       }
    }
    [\cpp]      printf("  %d  | ",i+1);
          printf("%c",Viergewinnt[i][0]);
    

    Irgendwie denk ich mir dass ich die Zeile 7 mal ausgeben muss, also bis [i][6], hab ich da recht?

    printf("     +---+---+---+\n");  // hier wird eh das gleiche gedruckt
    

    und das, ist was genau? x(



  • Ich habe das so von dir übernommen.

    Zeile 13 und 16 machen das Selbe.
    Warum da jetzt die Unterscheidung zwischen != 2 gemacht wird? Keine Ahnung.

    Blurp_ schrieb:

    Irgendwie denk ich mir dass ich die Zeile 7 mal ausgeben muss, also bis [i][6], hab ich da recht?

    Probier es aus!
    Nur so kannst du es lernen.
    Mit einer IDE (bei dir Visuale Studio) ist das doch gar kein Problem mehr. Wenn es nicht passt, machst du die Änderung Rückgangig.



  • Okya, also, wenn ich das jz 7 mal schreib dann wird das nichts, da gibt er alles irgendwo aus und es ist nicht ganz in den paar Zeilen,ich hab jz die Zeile

    printf("     +---+---+---+---+---+---+---+\n");  // hier wird eh das gleiche gedruckt
    

    dann geht das spielfeld bis 7 rüber.
    Das hab ich auch geändert

    printf("       1   2   3   4   5   6   7	\n     +---+---+---+---+---+---+---+\n");
    


  • Okay, ich schreib dir mal wie ich es jz gemacht habe, ich darf mit dem vorgegebenen tictactoe arbeiten, deswegen ha ich dasumgeändert:

    /* tictactoe.c */
    #include <stdio.h>
    #include <stdlib.h>
    #ifdef __unix__
        #define clrscr() printf("\x1B[2J")
    #elif __BORLANDC__ && __MSDOS__
        #include <conio.h>
    #elif __WIN32__ || _MSC_VER
        #define clrscr() system("cls")
    #else
        #define clrscr() printf("clrscr() - Fehler!!\n")
    #endif
    
    #define X 'X'
    #define O 'O'
    #define LEER ' '
    #define GAME_OVER 0
    #define A_WINNER 1
    #define CONTINUE 2
    
    /* Inhalt des 3 x 3 großen Felds */
    char Viergewinnt[6][7] = {  {' ',' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' ',' '},
                                        {' ',' ',' ',' ',' ',' ',' '}
                                     };
    
    /* Spieler1 hat das Zeichen 'X'. */
    char Spieler1 = X;
    /* Spieler2 hat das Zeichen 'O'. */
    char Spieler2 = O;
    /* Anzahl der Felder, die besetzt werden können */
    unsigned int felder = 42;
    
    /* Funktionsprototypen */
    void print_spielfeld(void);
    char neuer_zug(char);
    int if_win(void);
    
    /* Gibt den aktuellen Zustand des Spielfelds aus. */
    void print_spielfeld(void) {
       int i;
    
       clrscr();
       printf("       1   2   3   4   5   6   7  \n     +---+---+---+\n");
       for(i = 0; i < 7; i++) {
          printf("  %d  | ",i+1);
          printf("%c",Viergewinnt[i][0]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][1]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][2]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][3]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][4]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][5]);
          printf(" | ");
    	  printf("%c",Viergewinnt[i][6]);
          printf(" | ");
    
          if(i != 2) {
             printf("     +---+---+---+---+---+---+\n");
          }
          else {
             printf("     +---+---+---+---+---+---+\n");
          }
       }
    }
    /* Führt einen neuen Zug aus.
     * char ch: Zeichen des Spielers, der an der Reihe ist, 'X'
     * oder 'O'
     * Rückgabewert: Zeichen des Spielers, der eben an der Reihe war.
     * Falls ein Feld besetzt ist, wird der Rückgabewert vertauscht,
     * damit der aktuelle Spieler nochmals seinen Zug machen kann.
     * Hat ein Spieler gewonnen, gibt die Funktion die
     * symbolische Konstante GAME_OVER zurück.
     */
    char neuer_zug(char ch) {
       unsigned int row, colum;
    
       printf("\nSpieler \"%c\" ist an der Reihe\n\n",ch);
       printf("Zeile  (1-3): ");
       scanf("%u",&row);
       printf("Spalte (1-3): ");
       scanf("%u",&colum);
    
       if(Viergewinnt[row-1][colum-1] == LEER) {
          /* Zeichen in das mehrdimensionale Array */
          Viergewinnt[row-1][colum-1] = ch;
          print_spielfeld();
          /* Haben wir schon einen Gewinner? */
          if(if_win() == A_WINNER)
             return GAME_OVER;
       }
       else { /* Ein bereits besetztes Feld */
          print_spielfeld();
          printf("\n!!! Feld ist bereits gesetzt !!!\n");
          return (ch == X) ?O :X;
       }
       /* Sind bereits alle Felder besetzt? */
       if(--felder > 0)
          return ch;
       else {
          printf("\nAlle Felder sind besetzt - Unentschieden\n");
          return GAME_OVER;
       }
    }
    
    /* Auswertung aller Möglichkeiten, um einen Gewinner zu ermitteln.
     * Rückgabewert: symb. Konstante A_WINNER, falls ein Gewinner
     * ermittelt wurde, oder die symbolische Konstante CONTINUE zum
     * Weiterspielen
     */
    int if_win(void) {
      /* Zuerst Spieler1 'X' */
      if(Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[0][1] == Spieler1 &&
         Viergewinnt[0][2] == Spieler1 ||
         Viergewinnt[1][0] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[1][2] == Spieler1 ||
         Viergewinnt[2][0] == Spieler1 &&
         Viergewinnt[2][1] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[1][0] == Spieler1 &&
         Viergewinnt[2][0] == Spieler1 ||
         Viergewinnt[0][1] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][1] == Spieler1 ||
         Viergewinnt[0][2] == Spieler1 &&
         Viergewinnt[1][2] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][2] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][0] == Spieler1) {
            printf("Spieler1 hat gewonnen\n");
            return A_WINNER;
      }
    
      /* Jetzt Spieler2 'O' */
      else if( TicTacToe[0][0] == Spieler2 &&
               TicTacToe[0][1] == Spieler2 &&
               TicTacToe[0][2] == Spieler2 ||
               TicTacToe[1][0] == Spieler2 &&
               TicTacToe[1][1] == Spieler2 &&
               TicTacToe[1][2] == Spieler2 ||
               TicTacToe[2][0] == Spieler2 &&
               TicTacToe[2][1] == Spieler2 &&
               TicTacToe[2][2] == Spieler2 ||
               TicTacToe[0][0] == Spieler2 &&
               TicTacToe[1][0] == Spieler2 &&
               TicTacToe[2][0] == Spieler2 ||
               TicTacToe[0][1] == Spieler2 &&
               TicTacToe[1][1] == Spieler2 &&
               TicTacToe[2][1] == Spieler2 ||
               TicTacToe[0][2] == Spieler2 &&
               TicTacToe[1][2] == Spieler2 &&
               TicTacToe[2][2] == Spieler2 ||
               TicTacToe[0][0] == Spieler2 &&
               TicTacToe[1][1] == Spieler2 &&
               TicTacToe[2][2] == Spieler2 ||
               TicTacToe[0][2] == Spieler2 &&
               TicTacToe[1][1] == Spieler2 &&
               TicTacToe[2][0] == Spieler2)  {
                  printf("Spieler2 hat gewonnen\n");
                  return A_WINNER;
       }
       return CONTINUE;
    }
    
    int main(void) {
       char check = X;
    
       /* Leeres Spielfeld ausgeben */
       print_spielfeld();
    
       do { /* War Spieler mit dem Zeichen 'X' gerade dran ... */
          /* ... dann ist jetzt Spieler mit dem Zeichen 'O' dran ...*/
          if(check==X) {
                check=neuer_zug(O);
          }
          else { /* ... ansonsten der Spieler mit dem Zeichen 'X'. */
            check=neuer_zug(X);
          }
       } while( check != GAME_OVER );
       return EXIT_SUCCESS;
    }
    

    Da bin ich mir nicht ganz sicher was ich dazuschreiben soll: das ist ja für tictactoe, kanns sein dass ich statt:

    int if_win(void) {
      /* Zuerst Spieler1 'X' */
      if(Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[0][1] == Spieler1 &&
         Viergewinnt[0][2] == Spieler1 ||
         Viergewinnt[1][0] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[1][2] == Spieler1 ||
         Viergewinnt[2][0] == Spieler1 &&
         Viergewinnt[2][1] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[1][0] == Spieler1 &&
         Viergewinnt[2][0] == Spieler1 ||
         Viergewinnt[0][1] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][1] == Spieler1 ||
         Viergewinnt[0][2] == Spieler1 &&
         Viergewinnt[1][2] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][2] == Spieler1 ||
         Viergewinnt[0][2] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[2][0] == Spieler1)
    
    if(Viergewinnt[0][0] == Spieler1 &&
         Viergewinnt[0][1] == Spieler1 &&
         Viergewinnt[0][2] == Spieler1 &&
         Viergewinnt[0][3] == Spieler1 ||
    
         Viergewinnt[1][0] == Spieler1 &&
         Viergewinnt[1][1] == Spieler1 &&
         Viergewinnt[1][2] == Spieler1 &&
         Viergewinnt[1][3] == Spieler1 ||
    

    usw usw

    Könnte das so stimmen?



  • Bei TicTacToe ist das Einfach.
    Der Gewinner belegt eine ganze Zeile/Spalte/Diagonale mit seinen Steinen
    Trotzdem würde man das mit Schleifen lösen.

    Bei 4-Gewinnt reichen ja 4 Steine in Folge in einem Teil der Reihe.

    Du kannst das nachprogrammieren, wie du es auch selber machst.

    Du gehst eine Zeile durch und schaust ob der Spieler 4 Steine in Folge hat.

    Steinzähler = 0
      Zähle position von 0 bis 6
      { ist an position ein Stein von Spieler? dann
        { Steinzähler = Steinzähler +1
          ist Steinzähler == 4 dann
           { Gewinner = Spieler
              Fertig 
           }
        }
        sonst Steinzähler = 0   
      }
    

    Wenn er nicht gewonnen hat, du die nächste Zeile.
    Danach das ganze für Spalten und noch für die Diagonalen ( \ und / )

    Und man braucht nur eine Erkennung für beide Spieler.

    Es kann ja nur der Spieler gewinnen, der gerade den aktuellen Zug gemacht hat


Anmelden zum Antworten