4Gewinnt Spielfeld Kästchen



  • aktuell sieht mein spielfeld so aus:

    http://www2.pic-upload.de/13.05.09/5rmv2l.jpg

    wie kriege ich sowas hin
    http://beechsite.info/gfx/prog_4gewinnt_large.jpg

    also so kästchen und so.
    muss kein doppelrahmen sein.

    so das man jeden einzelnen feld mit rahmen sieht.

    der aktuelle code sieht so aus:

    //-----------------------------------------------------------------------------
    // 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;
    
        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()     //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)      //Spiel
    {
    
        char taste;
    
        banner();
    
        char spieler1[20], spieler2[20];
    
        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 << ""<< endl;
    cout <<" ";
    cout << spieler1<<": ";
    color(text);
    }else
    {
    color(player2);
    cout << ""<< endl;
    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 << ""<< endl;
                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
    
    if (player == PLAYER1)
    {
    color(player1);
    cout << ""<< endl;
    cout <<" ";
    cout << spieler1<<" hat gewonnen!";
    color(text);
    }
    else
    {
    color(player2);
    cout << ""<< endl;
    cout <<" ";
    cout << spieler2<<" hat gewonnen!";
    color(text);
    }
    cout << ""<< endl;
    cout << ""<< endl;
    cout << ""<< endl;
    cout << ""<< endl;
    cout<<" Beliebige Taste dr\201cken um zum Men\201 zugelangen"<<endl;
                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;
    }
    


  • Alter...Deine Frage ist etwas zu flach. Stell eine konkrete Frage zu einem konkreten Problem, mit konkreten Code und schick uns hier nicht 20mrd Zeilen Code.



  • mein aktueller spielfeld ist ja ohne rahmen und so

    ich wollte einfach das mein spielfeld umrandet ist.Das jede Spalte und Zeile ein Rahmen hat wie auf dem foto oben



  • Das beantwortet nicht meinen Post.Wo ist dein Problem? Beschreib genau wo du aktuell hängst und nicht "ich will das so und so machen, aber das klappt nicht, hier der code".... 🙄



  • ich weiss überhaupt nicht welche nteil ich abändern muss und wie ich da ne tabelle anzeigne lassen kann



  • Dann versuch doch erstmal ein Programm zu entwerfen, was auf der Console in Rechteck "malt" mithilfe von den Ascii-Zeichen.
    http://www.tcp-ip-info.de/tcp_ip_und_internet/ascii.htm

    Dazu brauchste werte wie
    186,187,188,200,201,205



  • hmm werde mal probieren



  • Ein Spielfeld das so aussieht wie oben in dem Bild gezeigt wird man mit Ascii Zeichen nicht hinbekommen.

    Das Bild sieht so aus als hätte sich da wer mit einer Grafiklib was schönes in 2D gezeichnet (opengl, directx). Wobei wie könnte man sowas sonst noch machen? Direkt in den Framebuffer schreiben (wenn man weiß wies geht ^^)?

    Keros



  • Hallo,

    ich erinner mal an diesem Fred hier:
    http://www.c-plusplus.net/forum/viewtopic-var-t-is-240529.html

    Dort hast du nach einer einfachen Grundlage der IF abfrage sehr oft nachgefragt und dann immer noch nicht den Rat der Helfenden befolgt, bis es dir einer vorgekaut hat.

    Ich denke mal nicht das du diesen Code geschrieben hast...

    Mein Tipp:
    Lern cpp Grundlagen und versuch solch ein programm selbst zu schreiben, dann weißt du auch wo du bei der darstellung der tabelle ansetzten musst und du lernst mehr als hier nachzufragen...

    Gruß


  • Administrator

    Keros schrieb:

    Ein Spielfeld das so aussieht wie oben in dem Bild gezeigt wird man mit Ascii Zeichen nicht hinbekommen.

    Das Bild sieht so aus als hätte sich da wer mit einer Grafiklib was schönes in 2D gezeichnet (opengl, directx).

    Da könntest du dich noch schwer täuschen:
    http://de.wikipedia.org/wiki/Codepage_437

    Wie im Wikipedia Eintrag geschrieben, sind diese speziellen Zeichen sogar im Unicode Standard enthalten. Zusammen mit dem Setzen von Farbewerten kann man sich da was schönes zusammenbasteln 😉

    Grüssli



  • Hmm bei näheren hinsehen könnte das echt zusammenpassen.

    Ich geh auch mal testen 😃

    Keros

    Ok ist eindeutig Ascii auch wenn bei mir die großen Blöcke etwas kleiner sind.




Log in to reply