Gewinner Ausgabe beim Spiel



  • if ( nInARow(row, column, player,WIN_COUNT) )  // Beende das Spiel, falls eine Gewinnsituation aufgetreten ist oder das
                  {                         // Spielbrett voll ist
    
               printf(" Spieler %d hat gewonnen!\n", player);
    
                getch();
                break;
            }
            else if ( boardIsFull() )
            {
                printf("Unentschieden!\n");
                getch();
                break;
            }
    
            player = (player == PLAYER1) ? PLAYER2 : PLAYER1;             // der nächste Spieler ist an der Reihe
    
        }
    

    Aktuell wird der gewinner ja durch:

    printf(" Spieler %d hat gewonnen!\n", player);
    

    angezeigt.

    wie kriege ich es hin also mit else und sowas.
    Das er für beide spieler extra cout zeilen habe?

    also ungefähr so

    else
    {
    cout<<"spieler 1 hat gewonnen";
    else if
    {
    cout <<"Spieler 2 hat gewonnen";

    damit will ich bezwecken das er die spieler namen anzeigt.

    sprich

    Thomas hat gewonnen



  • wieso denn nicht ungf so ohne if() else()

    cout<<playername[x]," hat gewonnen !";

    wenn man die Spieler namen vorher definiert, oder habe ich was falsch verstanden ?



  • Du musst die Spielernamen am Anfang deines Programms einlesen und es dann so ausgeben

    //...
    cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
    //...
    


  • namen werden von den beiden spielern immer eingegeben:

    cout << " Spieler 1:";
        cout << " ";
        cin  >> spieler1;
        cout << ""<< endl;
        cout << " Spieler 2:";
        cout << " ";
        cin  >> spieler2;
    



  • Jorckel schrieb:

    Du musst die Spielernamen am Anfang deines Programms einlesen und es dann so ausgeben

    //...
    cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
    //...
    

    habe ich ja wie man ein oberen post sieht.

    bloss

    cout << spieler1 << " hat gewonnen!";

    würde ja nur sagen das spieler 1 immer gewinnt



  • dazu müsste man wissen, wie "spiler x" als gewinner identifiziert wird.

    ich geh mal von etwas dieser art aus:

    #include <iostream>
    #include <string>
    #include <cstdlib>
    
    using namespace std;
    
    main()
    {
    
    cout<<"wie heißt du Spieler 1 ?: "<<namevonspieler[1];
    getline(cin,namevonspieler[1]); // einlesen als String
    cout<<"wie heißt du Spieler 2 ?: "<<namevonspieler[2];
    getline(cin,namevonspieler[2]); // einlesen als String
    cout<<"das Spiel kann beginnen"
    cin.get();
    
    // und so weiter was das auch immer für ein game ist ...
    
    int winner;
    if(punktesp[1] > punktesp[2]) // sp1 hat mehr punkte als sp2
    winner = 1; // gewinner ist sp1
    else
    winner = 2;
    
    //oder ähnlich, je nach spieler anzahl
    
    if(winner = 1)
    cout<<namevonspieler[1]<<" hat das spiel gewonnen";
    else
    cout<<namevonspieler[2]<<" hat das spiel gewonnen";
    cin.get();
    return 0;
    }
    

    ich nehme an ungefähr so soll das aussehen oder ?



  • @ Harald44 das was du im aller ersten Post gepostet hast ist kein C++

    Harald44 schrieb:

    Jorckel schrieb:

    Du musst die Spielernamen am Anfang deines Programms einlesen und es dann so ausgeben

    //...
    cout << spieler1 << " hat gewonnen!"; //spieler1 ist die Variable
    //...
    

    habe ich ja wie man ein oberen post sieht.

    bloss

    cout << spieler1 << " hat gewonnen!";

    würde ja nur sagen das spieler 1 immer gewinnt

    Nein würde es nicht heißen, es würde heißen das der Spieler ausgegeben wird, welche am Start des Programmes ausgegeben hat.

    Schau dir lieber nochmal die Grundlagen, wie Eingabe,Ausgabe,Variablen und Arrays an. 😉



  • Harald44 schrieb:

    if ( nInARow(row, column, player,WIN_COUNT) )  // Beende das Spiel, falls eine Gewinnsituation aufgetreten ist oder das
                  {                         // Spielbrett voll ist
    

    ich wette das ist kopiert worden, vielleicht solltest du dir zu anfang was einfacheres ansehen, nur so als tipp, nimms mir nicht übel
    [/quote]



  • ja habe ich auch nicht selbst geschrieben. Ist ja ein Schulprojekt.

    Der Lehrer hat selbst gesagt da wir nur paar Monate Algo haben und nicht in der Lage sind ein eigenes programm zu programmieren, das wir aus dem internet eins runterladen und es abändern können.

    hier der gesamte code:

    //-----------------------------------------------------------------------------
    // INCLUDES
    //-----------------------------------------------------------------------------
    
    #include <stdlib.h>
    #include <stdio.h>
    #include <assert.h>
    #include <windows.h>
    #include <conio.h>
    #include <iostream.h>
    #include "vollbild.h"
    
    const unsigned short player1 = 14;
    const unsigned short player2 = 10;
    const unsigned short text = 15;
    const unsigned short bannerf1 = 15;
    const unsigned short bannerf2 = 14;
    
    //-----------------------------------------------------------------------------
    // TYPEN
    //-----------------------------------------------------------------------------
    
    enum BoardCell                /// Belegungsarten einer Spielbrettzelle
    {
       NO_PIECE,                /// Kein Spielstein
       PLAYER1,                /// Spielstein von Spieler 1
       PLAYER2                /// Spielstein von Spieler 2
    };
    
    //-----------------------------------------------------------------------------
    // KONSTANTEN (Konfiguration des Spieles)
    //-----------------------------------------------------------------------------
    
    const int PLAYFIELD_WIDTH  = 7;     /// Breite des Spielfeldes
    const int PLAYFIELD_HEIGHT = 6;    /// Höhe des Spielfeldes
    const int WIN_COUNT        = 4;   /// Anzahl der konsekutiven Steine für eine Gewinnsituation
    
    //-----------------------------------------------------------------------------
    // GLOBALE VARIABLEN
    //-----------------------------------------------------------------------------
    
    BoardCell board[PLAYFIELD_HEIGHT][PLAYFIELD_WIDTH]; /// Spielbrett
    int numFreeCells[PLAYFIELD_WIDTH];                 /// Anzahl der freien Zellen in einer Spalte
    
    //-----------------------------------------------------------------------------
    // FUNKTIONEN
    //-----------------------------------------------------------------------------
    
    void color(unsigned short color)
    {
        HANDLE hcon = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleTextAttribute(hcon,color);
    }
    
    void initBoard()
    {
    
      for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ ) // Über die Spalten iterieren
      {
      for ( int row = 0; row < PLAYFIELD_HEIGHT; row ++ )   // Über die Zeilen iterieren
        {
         board[row][column] = NO_PIECE;       // Inhalt der Spielfeldzelle zurücksetzen
        }
         numFreeCells[column] = PLAYFIELD_HEIGHT;    // Anzahl der freien Zellen pro Spalte initialisieren
    
       }
     }
    
    //-----------------------------------------------------------------------------
    
    void printBoard()
    {
        cout << endl << endl;
        cout << " ";
    for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )  // Spaltennummern ausgeben
        {
            cout << "";
            cout << column;
        }
        cout << endl;
    
        cout << " ";
    for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )     // Oberen Spielfeldrand ausgeben
        {
    
            cout << "-";
        }
        cout << endl;
    
        cout << " ";
        for ( int row = 0; row < PLAYFIELD_HEIGHT; row ++ )   // Über die Zeilen iterieren
        {
        cout << " ";
        for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ )   // Über die Spalten iterieren
            {
    
                if (board[row][column] == PLAYER1)          // Inhalt der Zelle ausgeben
                {
                    color(player1);
                    cout << "X";
                    color(text);
                }
                else if (board[row][column] == PLAYER2)
                {
                    color(player2);
                    cout << "O";
                    color(text);
                }
                else
                    cout << " ";
                      }
    
            cout << endl;                     // Nächste zeile
        }
    
        cout << " ";
        for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )     // Unteren Spielfeldrand ausgeben
        {
    
            cout << "-";
        }
        cout << endl;
        cout << endl;
    
    }
    
    //-----------------------------------------------------------------------------
    
    BoardCell getCell( int row, int column )
    {
    
        if (row >= 0 && row < PLAYFIELD_HEIGHT && column >= 0 && column < PLAYFIELD_WIDTH)
            return board[row][column];
        else
            return NO_PIECE;
    }
    
    //-----------------------------------------------------------------------------
    
    int countPieces(int row, int column, int dx, int dy, BoardCell player)
    {
    
      assert(row>=0 && row < PLAYFIELD_HEIGHT && column>=0 && column < PLAYFIELD_WIDTH); // Stelle sicher, dass Referenzposition innerhalb des Spielfeldes liegt
    
      if (getCell(row,column) == player)
      {
    
        int count = 1;       // Zähler initialisieren (mindestens 1 Stein)
    
        int sy1=row;              // Scankoordinaten
        int sx1=column;
    
        while ( getCell(sy1+dy,sx1+dx) == player )   // Erhöhe Zähler, solange von Referenzposition row,column ausgehend
        {                                           // in Richtung dy,dx weitere Steine von Spieler player folgen
    
          sy1+=dy;          // Scankoordinaten aktualisieren
          sx1+=dx;
    
          count++;         // Weiterzählen
        }
    
        int sy2=row;           // Scankoordinaten
        int sx2=column;
    
        while ( getCell(sy2-dy,sx2-dx) == player )       // Erhöhe Zähler, solange von Referenzposition row,column ausgehend
            {                                            // in Richtung -dy,-dx weitere Steine von Spieler player folgen
    
          sy2-=dy;    // Scankoordinaten aktualisieren
          sx2-=dx;
    
          count++;        // Weiterzählen
        }
    
        return count;      // Zähler zurückgeben
    
      }
      else
        return 0;
    
    }
    
    //-----------------------------------------------------------------------------
    
    bool nInARow( int row, int column, BoardCell player, int n)
    {
        assert(row >= 0 && row < 6 && column >= 0 && column < 7);
        assert(board[row][column] == player);
    
        if (countPieces(row,column,1,0,player)>=n) return true;     // Horizontaler Fall
    
        if (countPieces(row,column,0,1,player)>=n) return true;    // Vertikaler Fall
    
        if (countPieces(row,column,1,1,player)>=n) return true;    // Hauptdiagonale "\"
    
        if (countPieces(row,column,-1,1,player)>=n) return true;  // Nebendiagonale "/"
    
        return false;       // Keiner der Fälle ist eingetreten => keine Gewinnsituation
    }
    
    //-----------------------------------------------------------------------------
    
    bool boardIsFull()
    {
        for ( int column = 0; column < PLAYFIELD_WIDTH; column ++ )
        {
            if ( numFreeCells[column] > 0 ) return false;  // Falls mindestens eine nicht volle Spalte gefunden wird
            }   // so ist das Brett nicht leer
    
        return true;      // Spielbrett voll
    }
    
    void banner()
    {
           //Banner
    
            color(text);
         cout<<""<<endl;   
         cout<<" °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"<<endl;
         color(bannerf2);
         cout<<" .............................................................................."<<endl;
         cout<<" ..##............######...########.##......##.####.##....##.##....##.########.."<<endl;
         cout<<" ..##....##.....##....##..##.......##..##..##..##..###...##.###...##....##....."<<endl;
         cout<<" ..##....##.....##........##.......##..##..##..##..####..##.####..##....##....."<<endl;
         cout<<" ..##....##.....##...####.######...##..##..##..##..##.##.##.##.##.##....##....."<<endl;
         cout<<" ..#########....##....##..##.......##..##..##..##..##..####.##..####....##....."<<endl;
         cout<<" ........##.....##....##..##.......##..##..##..##..##...###.##...###....##....."<<endl;
         cout<<" ........##......######...########..###..###..####.##....##.##....##....##....."<<endl;
         cout<<" .............................................................................."<<endl;
         color(text);
         cout<<" °°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°";
         color(bannerf2);
         cout<<" by GSGT Games ";
         color(text);
         cout<<"°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°"<<endl;
         color(bannerf1);
    
    }
    
    void anleitung()
    {
         system("cls");
         banner();
    
        cout << "" << endl;
        cout << "" << endl;
        cout<<"\t\t\t\t***************"<<endl;
        cout<<"\t\t\t\t*";
        cout<<"  Anleitung  ";
        cout<<"*"<<endl;
        cout<<"\t\t\t\t***************"<<endl;
    
       cout<<""<<endl;  
       cout<<""<<endl;
       cout<<""<<endl;
       cout<<"  Ziel des Spieles ist es, als erster 4 Steine seiner Farbe in eine"<<endl;
       cout<<"  Reihe zu bekommen."<<endl;
       cout<<""<<endl;
       cout<<"  Die Steinfarben sind f\x81r Spieler 1";
       color(player1);
       cout<<" (GELB)";
       color(text);
       cout<<" und Spieler 2";
       color(player2);
       cout<<" (GR\x9aN)"<<endl;
       color(text);
       cout<<""<<endl;
       cout<<"  Es wird abwechselnd je 1 Stein der eigenen Farbe"<<endl;
       cout<<"  in die Felder fallen gelassen."<<endl;
       cout<<""<<endl;
       cout<<"  Dies kann man tun mit den Tasten 0,1,2,3,4,5,6. "<<endl;
       cout<<"  Wobei 0 f\x81r die ganz linke Spalte sowie 6 f\x81r ganz rechte Spalte steht."<<endl;
       cout<<"  Durch Strategie und Taktik versucht man nun, mit den eigenen Steinen"<<endl;
       cout<<"  eine 4er-Reihe zu bilden."<<endl;
       cout<<""<<endl;
       cout<<"  Die Reihen k\x94nnen entweder"<<endl;
       cout<<"  -senkrecht"<<endl;
       cout<<"  -waagerecht"<<endl;
       cout<<"  -diagonal"<<endl;
       cout<<"  angeordnet sein."<<endl;
       cout<<""<<endl;
       cout<<"  Dabei darf man aber nie den Gegner aus den Augen lassen,"<<endl;
       cout<<"  denn wenn er eine Zwickm\x81hle bildet, kann bald alles zu sp\x84t sein!"<<endl;
       cout<<"  Man muss also gleichzeitig verhindern, dass er zuvor eine"<<endl;
       cout<<"  4er-Reihe zustande bringt."<<endl;
       cout<<""<<endl;
       cout<<""<<endl;
       cout<<""<<endl;
       cout<<"                Beliebige Taste dr\201cken um zum Men\201 zugelangen"<<endl;
         getch();
    
         system("cls");
    }
    
    int spiel(void)
    {
    
        char taste;
    
        banner();
    
        char spieler1[15], spieler2[15];
    
        cout << "" << endl;
        cout << "" << endl;
        cout<<"\t\t\t\t***************"<<endl;
        cout<<"\t\t\t\t*";
        cout<<"    Namen  ";
        cout<<"  *"<<endl;
        cout<<"\t\t\t\t***************"<<endl;
        cout << ""<< endl;
        cout << ""<< endl;
        cout << ""<< endl;
        color(player1);
        cout << " Spieler 1:";
        cout << " ";
        cin  >> spieler1;
        cout << ""<< endl;
        color(player2);
        cout << " Spieler 2:";
        cout << " ";
        cin  >> spieler2;
        color(text);
    
        system("cls");
        banner();  
    
        initBoard();          // Initialisiere das Spielbrett und gebe es aus
        printBoard();
    
        BoardCell player = PLAYER1;    // Aktueller Spieler
    
        while ( true )
        {
    
            int column;    // Fordere Spieler zur Eingabe eines Spielzuges auf
    
            if (player == PLAYER1)
    {
    color(player1);
    cout <<" ";
    cout << spieler1<<": ";
    color(text);
    }else
    {
    color(player2);
    cout <<" ";
    cout << spieler2<<": ";
    color(text);
    }
    
            int res = scanf("%d", &column);
    
            while ( res != 1 || column < 0 || column >= PLAYFIELD_WIDTH || numFreeCells[column] == 0 )        // Wiederhole, falls Eingabe ungültig
               {      // (kein Integer eingegeben  oder  ungültige Spaltennummer  oder  Spalte bereits voll)
                if ( res != 1 )
                    fflush(stdin);
                cout <<" ";
                cout << "Ung\201ltig. Nochmal: ";
                res = scanf("%d", &column);
            }
    
            numFreeCells[column] --;             // Aktualisiere den Zustand des Spielbrettes
            int row = numFreeCells[column];
            board[row][column] = player;
    
            system("cls");
            banner();
            printBoard();                 // Gebe das Spielbrett aus
    
    if ( nInARow(row, column, player,WIN_COUNT) )  // Beende das Spiel, falls eine Gewinnsituation aufgetreten ist oder das
                  {                         // Spielbrett voll ist
    
               printf(" Spieler %d hat gewonnen!\n", player);
    
                getch();
                break;
            }
            else if ( boardIsFull() )
            {
                printf("Unentschieden!\n");
                getch();
                break;
            }
    
            player = (player == PLAYER1) ? PLAYER2 : PLAYER1;             // der nächste Spieler ist an der Reihe
    
        }
    }
    
    //-----------------------------------------------------------------------------
    // MAIN
    //-----------------------------------------------------------------------------
    
    int main()           /// Hauptprogramm
    {
        char taste;
    
        vollbild(true);
    
        menue:
    
        banner();
    
        cout << "" << endl;
        cout << "" << endl;
        cout<<"\t\t\t\t***************"<<endl;
        cout<<"\t\t\t\t*";
        cout<<"     Men\201  ";
        cout<<"  *"<<endl;
        cout<<"\t\t\t\t***************"<<endl;
    
        cout << "" << endl;
        cout << "" << endl;
        cout << "" << endl;
        cout << " (S)piel starten" << endl;
        cout << "" << endl;
        cout << " (A)nleitung" << endl;
        cout << "" << endl;
        cout << " (B)eenden" << endl;
    
       taste = getch();
    
        switch(taste)
        {
            case 'S':
            case 's':
                 system("cls");
                 spiel();
                 system("cls");
                 goto menue;
    
            break;
    
            case 'A':
            case 'a':
                 anleitung();
                 system("cls");
                 goto menue;
            break;
    
            case 'B':
            case 'b':
                 return 0;
    
            default:
                 system("cls");
                 goto menue;
    
          }
    
        return 0;
    }
    


  • Hallo,

    ich würde gerne mit deinem Programm 4 ewinnt etwas spielen, als mit dem code.

    Aber dafür fehlt mir die vollbild.h 😞

    Hast du diese noch?



  • ja lade ich heute nachmittag hoch oder so.

    hatj emand ne idee wie ich das machen kann mit dem ausgeben des gewinnerS?



  • Harald44 schrieb:

    hatj emand ne idee wie ich das machen kann mit dem ausgeben des gewinnerS?

    Die Antworten, sowie Suchbegriffe wurden dir schon ausreichend gegeben.



  • ja ich weiss bin kein profi dadrin. kann keiner helfen?



  • printf(" Spieler %d hat gewonnen!\n", player);
    
    -->
    // Die Variable player ist also 1 oder 2
    // und in spieler1 und spieler2 sind die Namen gespeichert
    -->
    wenn (player istgleich 1) dann
    {
     schreibe spieler1 hat gewonnen (natürlich den Inhalt der variable ausgeben)
    }
    ansonsten
    {
     schreibe spieler2 hat gewonnen
    }
    

    Eigentlich zu viel hilfe ^^

    Keros



  • habe das nun so:

    player = (player == PLAYER1);
    if
    {
    cout << spieler1<<"hat gewonnen!";
    }
    else if
    {
    cout << spieler2<<"hat gewonnen!";
    }
    

    der meckert das ein fehler ist in der klammer nach dem IF



  • [quote="Harald44"]namen werden von den beiden spielern immer eingegeben:

    cout << " Spieler 1:";
        cout << " ";
        cin  >> spieler1;
        cout << ""<< endl;
        cout << " Spieler 2:";
        cout << " ";
        cin  >> spieler2;
    

    [quote]

    wenn du das machst, sollte nach dem IF kein Fehler sien, ich denke jetzt das er die variable spieler1 nicht hat...



  • Sorry aber grundlagen wie eine if aufgebaut ist musst du dir selber ansehen das wird dir hier keiner vorkauen.

    Vor allem weil man das gleich nach Hello World in jeder Sprache beigebracht bekommt. Das hat nix mit Profi und so zu tun sondern sind einfach nur Grundlagen. Ohne diese sollte dich den Prof mit, sagen wir mal wiederholen bewerten 😉

    Du brauchst dir ja nur mal den geladenen Code ansehen und darin wirst du viele if Anweisungen sehen und wie sie aufgebaut sind.

    Keros



  • ähm, ja... die Bedingung fehlt bei if 😉



  • Ich hebe auch mal 4Gewinnt programmiert, sehr unschön, aber es funktioniert.:D

    viergewinnt.h

    class viergewinnt
    {  int p[7][5];
       int s;
       int chance;
       public:
            viergewinnt();
            void setP1(int wahl);
            void setP2(int wahl);
            void matrix();
            char getm(int x, int y);
            void ruecksetzten();
            bool nextP(); 
            int win();
            void setFW(int farbe);
            int zugPC();    
    };
    

    viergewinnt.cpp

    #include <iostream>
    #include "viergewinnt.h"
    #include <windows.h> 
    #include <math.h>
    using namespace std;
    
    viergewinnt::viergewinnt()
    {  s=0;
       for(int i=0; i<7; i++)
          for(int i2=0; i2<5; i2++)
          p[i][i2]=0;
    }
    void viergewinnt::ruecksetzten()
    {  s=0;
       for(int i=0; i<7; i++)
          for(int i2=0; i2<5; i2++)
          p[i][i2]=0;
    }
    bool viergewinnt::nextP()
    {
        if(s==0)return true;
        else return false; 
    }
    void viergewinnt::setP1(int wahl)
    {  if(wahl >=1 && wahl <=7)
       { 
         switch(wahl)
        {
            case 1:if     (p[0][0]==0){p[0][0]=1;s=1;}
                   else if(p[0][1]==0){p[0][1]=1;s=1;}
                   else if(p[0][2]==0){p[0][2]=1;s=1;}
                   else if(p[0][3]==0){p[0][3]=1;s=1;}
                   else if(p[0][4]==0){p[0][4]=1;s=1;}break;
            case 2:if     (p[1][0]==0){p[1][0]=1;s=1;}
                   else if(p[1][1]==0){p[1][1]=1;s=1;}
                   else if(p[1][2]==0){p[1][2]=1;s=1;}
                   else if(p[1][3]==0){p[1][3]=1;s=1;}
                   else if(p[1][4]==0){p[1][4]=1;s=1;}break;
            case 3:if     (p[2][0]==0){p[2][0]=1;s=1;}
                   else if(p[2][1]==0){p[2][1]=1;s=1;}
                   else if(p[2][2]==0){p[2][2]=1;s=1;}
                   else if(p[2][3]==0){p[2][3]=1;s=1;}
                   else if(p[2][4]==0){p[2][4]=1;s=1;}break;
            case 4:if     (p[3][0]==0){p[3][0]=1;s=1;}
                   else if(p[3][1]==0){p[3][1]=1;s=1;}
                   else if(p[3][2]==0){p[3][2]=1;s=1;}
                   else if(p[3][3]==0){p[3][3]=1;s=1;}
                   else if(p[3][4]==0){p[3][4]=1;s=1;}break;
            case 5:if     (p[4][0]==0){p[4][0]=1;s=1;}
                   else if(p[4][1]==0){p[4][1]=1;s=1;}
                   else if(p[4][2]==0){p[4][2]=1;s=1;}
                   else if(p[4][3]==0){p[4][3]=1;s=1;}
                   else if(p[4][4]==0){p[4][4]=1;s=1;}break;
            case 6:if     (p[5][0]==0){p[5][0]=1;s=1;}
                   else if(p[5][1]==0){p[5][1]=1;s=1;}
                   else if(p[5][2]==0){p[5][2]=1;s=1;}
                   else if(p[5][3]==0){p[5][3]=1;s=1;}
                   else if(p[5][4]==0){p[5][4]=1;s=1;}break;
            case 7:if     (p[6][0]==0){p[6][0]=1;s=1;}
                   else if(p[6][1]==0){p[6][1]=1;s=1;}
                   else if(p[6][2]==0){p[6][2]=1;s=1;}
                   else if(p[6][3]==0){p[6][3]=1;s=1;}
                   else if(p[6][4]==0){p[6][4]=1;s=1;}break;
        }
        }     
    }
    
    void viergewinnt::setP2(int wahl)
    {  
       if(wahl >=1 && wahl <=7)
       { 
       switch(wahl)
        {
            case 1:if     (p[0][0]==0){p[0][0]=2;s=0;}
                   else if(p[0][1]==0){p[0][1]=2;s=0;}
                   else if(p[0][2]==0){p[0][2]=2;s=0;}
                   else if(p[0][3]==0){p[0][3]=2;s=0;}
                   else if(p[0][4]==0){p[0][4]=2;s=0;}break;
            case 2:if     (p[1][0]==0){p[1][0]=2;s=0;}
                   else if(p[1][1]==0){p[1][1]=2;s=0;}
                   else if(p[1][2]==0){p[1][2]=2;s=0;}
                   else if(p[1][3]==0){p[1][3]=2;s=0;}
                   else if(p[1][4]==0){p[1][4]=2;s=0;}break;
            case 3:if     (p[2][0]==0){p[2][0]=2;s=0;}
                   else if(p[2][1]==0){p[2][1]=2;s=0;}
                   else if(p[2][2]==0){p[2][2]=2;s=0;}
                   else if(p[2][3]==0){p[2][3]=2;s=0;}
                   else if(p[2][4]==0){p[2][4]=2;s=0;}break;
            case 4:if     (p[3][0]==0){p[3][0]=2;s=0;}
                   else if(p[3][1]==0){p[3][1]=2;s=0;}
                   else if(p[3][2]==0){p[3][2]=2;s=0;}
                   else if(p[3][3]==0){p[3][3]=2;s=0;}
                   else if(p[3][4]==0){p[3][4]=2;s=0;}break;
            case 5:if     (p[4][0]==0){p[4][0]=2;s=0;}
                   else if(p[4][1]==0){p[4][1]=2;s=0;}
                   else if(p[4][2]==0){p[4][2]=2;s=0;}
                   else if(p[4][3]==0){p[4][3]=2;s=0;}
                   else if(p[4][4]==0){p[4][4]=2;s=0;}break;
            case 6:if     (p[5][0]==0){p[5][0]=2;s=0;}
                   else if(p[5][1]==0){p[5][1]=2;s=0;}
                   else if(p[5][2]==0){p[5][2]=2;s=0;}
                   else if(p[5][3]==0){p[5][3]=2;s=0;}
                   else if(p[5][4]==0){p[5][4]=2;s=0;}break;
            case 7:if     (p[6][0]==0){p[6][0]=2;s=0;}
                   else if(p[6][1]==0){p[6][1]=2;s=0;}
                   else if(p[6][2]==0){p[6][2]=2;s=0;}
                   else if(p[6][3]==0){p[6][3]=2;s=0;}
                   else if(p[6][4]==0){p[6][4]=2;s=0;}break;
        }
        }      
    }
    
    char viergewinnt::getm(int x, int y)
    {   if(p[x][y] == 2){setFW(10);return 'O';}
        if(p[x][y] == 1){setFW(12);return 'X';}
        if(p[x][y] == 0)return ' ';
    }
    
    void viergewinnt::setFW(int farbe)
    {
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), farbe);     
    }
    
    void viergewinnt::matrix()
    {  setFW(15);
       cout<<endl<<"    1   2   3   4   5   6   7 "<<endl;
       for(int i=4; i>=0; i--)
       { 
          cout<<"  +---+---+---+---+---+---+---+"<<endl;
           cout<<"  | ";setFW(15);
           cout<<getm(0,i);
           setFW(15);cout<<" | ";
           cout<<getm(1,i);
           setFW(15);cout<<" | ";
           cout<<getm(2,i);
           setFW(15);cout<<" | ";
           cout<<getm(3,i);
           setFW(15);cout<<" | ";
           cout<<getm(4,i);
           setFW(15);cout<<" | ";
           cout<<getm(5,i);
           setFW(15);cout<<" | ";
           cout<<getm(6,i);
           setFW(15);cout<<" | "<<endl;
    
    }
    
    cout<<"  +---+---+---+---+---+---+---+"<<endl;
    }
    
    int viergewinnt::win()
    {  for(int i=1; i<3; i++)
      {if(p[0][0] == i && p[0][1] == i && p[0][2] == i && p[0][3] == i)return 1;
       if(p[0][1] == i && p[0][2] == i && p[0][3] == i && p[0][4] == i)return 1;
       if(p[1][0] == i && p[1][1] == i && p[1][2] == i && p[1][3] == i)return 1;
       if(p[1][1] == i && p[1][2] == i && p[1][3] == i && p[1][4] == i)return 1;
       if(p[2][0] == i && p[2][1] == i && p[2][2] == i && p[2][3] == i)return 1;
       if(p[2][1] == i && p[2][2] == i && p[2][3] == i && p[2][4] == i)return 1;
       if(p[3][0] == i && p[3][1] == i && p[3][2] == i && p[3][3] == i)return 1;
       if(p[3][1] == i && p[3][2] == i && p[3][3] == i && p[3][4] == i)return 1;
       if(p[4][0] == i && p[4][1] == i && p[4][2] == i && p[4][3] == i)return 1;
       if(p[4][1] == i && p[4][2] == i && p[4][3] == i && p[4][4] == i)return 1;
       if(p[5][0] == i && p[5][1] == i && p[5][2] == i && p[5][3] == i)return 1;
       if(p[5][1] == i && p[5][2] == i && p[5][3] == i && p[5][4] == i)return 1;
       if(p[6][0] == i && p[6][1] == i && p[6][2] == i && p[6][3] == i)return 1;
       if(p[6][1] == i && p[6][2] == i && p[6][3] == i && p[6][4] == i)return 1;
    
       if(p[0][0] == i && p[1][0] == i && p[2][0] == i && p[3][0] == i)return 1;
       if(p[1][0] == i && p[2][0] == i && p[3][0] == i && p[4][0] == i)return 1;
       if(p[2][0] == i && p[3][0] == i && p[4][0] == i && p[5][0] == i)return 1;
       if(p[3][0] == i && p[4][0] == i && p[5][0] == i && p[6][0] == i)return 1;
    
       if(p[0][1] == i && p[1][1] == i && p[2][1] == i && p[3][1] == i)return 1;
       if(p[1][1] == i && p[2][1] == i && p[3][1] == i && p[4][1] == i)return 1;
       if(p[2][1] == i && p[3][1] == i && p[4][1] == i && p[5][1] == i)return 1;
       if(p[3][1] == i && p[4][1] == i && p[5][1] == i && p[6][1] == i)return 1;
    
       if(p[0][2] == i && p[1][2] == i && p[2][2] == i && p[3][2] == i)return 1;
       if(p[1][2] == i && p[2][2] == i && p[3][2] == i && p[4][2] == i)return 1;
       if(p[2][2] == i && p[3][2] == i && p[4][2] == i && p[5][2] == i)return 1;
       if(p[3][2] == i && p[4][2] == i && p[5][2] == i && p[6][2] == i)return 1;
    
       if(p[0][3] == i && p[1][3] == i && p[2][3] == i && p[3][3] == i)return 1;
       if(p[1][3] == i && p[2][3] == i && p[3][3] == i && p[4][3] == i)return 1;
       if(p[2][3] == i && p[3][3] == i && p[4][3] == i && p[5][3] == i)return 1;
       if(p[3][3] == i && p[4][3] == i && p[5][3] == i && p[6][3] == i)return 1;
    
       if(p[0][4] == i && p[1][4] == i && p[2][4] == i && p[3][4] == i)return 1;
       if(p[1][4] == i && p[2][4] == i && p[3][4] == i && p[4][4] == i)return 1;
       if(p[2][4] == i && p[3][4] == i && p[4][4] == i && p[5][4] == i)return 1;
       if(p[3][4] == i && p[4][4] == i && p[5][4] == i && p[6][4] == i)return 1;
    
       if(p[0][0] == i && p[1][1] == i && p[2][2] == i && p[3][3] == i)return 1;
       if(p[0][1] == i && p[1][2] == i && p[2][3] == i && p[3][4] == i)return 1;
       if(p[1][1] == i && p[2][2] == i && p[3][3] == i && p[4][4] == i)return 1;
       if(p[1][0] == i && p[2][1] == i && p[3][2] == i && p[4][3] == i)return 1;
       if(p[2][1] == i && p[3][2] == i && p[4][3] == i && p[5][4] == i)return 1;
       if(p[2][0] == i && p[3][1] == i && p[4][2] == i && p[5][3] == i)return 1;
       if(p[3][1] == i && p[4][2] == i && p[5][3] == i && p[6][4] == i)return 1;
       if(p[3][0] == i && p[4][1] == i && p[5][2] == i && p[6][3] == i)return 1;
    
       if(p[6][1] == i && p[5][2] == i && p[4][3] == i && p[3][4] == i)return 1;
       if(p[6][0] == i && p[5][1] == i && p[4][2] == i && p[3][3] == i)return 1;
       if(p[5][1] == i && p[4][2] == i && p[3][3] == i && p[2][4] == i)return 1;
       if(p[5][0] == i && p[4][1] == i && p[3][2] == i && p[2][3] == i)return 1;
       if(p[4][1] == i && p[3][2] == i && p[2][3] == i && p[1][4] == i)return 1;
       if(p[4][0] == i && p[3][1] == i && p[2][2] == i && p[1][3] == i)return 1;
       if(p[3][1] == i && p[2][2] == i && p[1][3] == i && p[0][4] == i)return 1;
       if(p[3][0] == i && p[2][1] == i && p[1][2] == i && p[0][3] == i)return 1;
       }
    
    }
    
    int viergewinnt::zugPC()
    {  srand (time(NULL));
        return rand()%7;
    }
    

    main.cpp

    #include <iostream>
    
    using namespace std;
    
    #include "viergewinnt.h"
    int main(int argc, char *argv[])
    {   viergewinnt spiel;
        int wahl, wahlpc;
        spiel.matrix();
        cout<<"    Player vs Player?   - 1"<<endl<<"    Player vs Computer? - 2  ";
        cin>>wahlpc;
        switch(wahlpc)
        {
            case 1: while (spiel.win() != 1)
                    {  
                        if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                        else {spiel.setFW(10);cout<<endl<<"       Spieler 2 (1-7): ";}
                        cin>>wahl;
                        system("cls");
                        if(spiel.nextP())spiel.setP1(wahl);
                        else spiel.setP2(wahl);
                        spiel.matrix();
    
                    }
    
                    if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Spieler 2";spiel.setFW(9);cout<<" WIN!";}
                    else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                    break;
            case 2: while (spiel.win() != 1)
                    {  
                        if(spiel.nextP()) { spiel.setFW(12); cout<<endl<<"       Spieler 1 (1-7): ";}
                        else {spiel.setFW(10);cout<<endl<<"       Comp 2 (1-7): ";}
                        if(spiel.nextP())cin>>wahl;
                        system("cls");
                        if(spiel.nextP())spiel.setP1(wahl);
                        else spiel.setP2(spiel.zugPC());
                        spiel.matrix();
    
                    }
    
                    if(spiel.win() == 1)if(spiel.nextP())  {spiel.setFW(10); cout<<endl<<endl<<"        Computer";spiel.setFW(9);cout<<" WIN!";}
                    else { spiel.setFW(12);cout<<endl<<endl<<"        Spieler 1";spiel.setFW(9);cout<<" WIN!";}
                    break;
    
        }
    
        spiel.ruecksetzten();
    
        system("PAUSE>NUL");
        return EXIT_SUCCESS;
    }
    

    nicht schimpfen... 😃



  • habe das nun so:

    if
    player = (player == PLAYER1)
    {
    cout << spieler1<<"hat gewonnen!";
    }
    else if
    {
    cout << spieler2<<"hat gewonnen!";
    }
    

    jetzt meckert er bei

    player = (player == PLAYER1)


Log in to reply