Zahlen verschieben bei 4 GEwinnt



  • original sah das spielfeld so aus:

    ------
    123456

    ich habe die spielfelder nun etwas breiter gemacht in dem ich eine lücke reingebaut habe sieht also so aus:

    - - - - - -
    1 2 3 4 5 6

    blos wenn ich jetzt ein stein legen will und auf die 6 klicke legt der den stein nicht auf die 6 sondern irgendwo bei zwischen 3und4.
    das heisst der hat den LEERZEICHEN ABSTAND für die zahlen nicht genommen.

    screens:

    hier habe ich den stein auf die 6 gelegt:

    http://www.pic-upload.de/07.05.09/sj8kdv.jpg

    //-----------------------------------------------------------------------------
    // 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()
    {
    
        for ( int row = 0; row < PLAYFIELD_HEIGHT; row ++ )   // Über die Zeilen iterieren
        {
        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
        }
    
        for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )     // Unteren Spielfeldrand ausgeben
        {
            cout << " ";
            cout << "-";
        }
        cout << endl;
    
        for (int column = 0; column < PLAYFIELD_WIDTH; column ++ )  // Spaltennummern ausgeben
        {
            cout << " ";
            cout << column;
        }
        cout << endl << 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 << " Bitte Namen eingeben"<< 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;
    }
    


  • ist das spiel von dir? denke mal nicht.
    zeile 93,

    cout << "  ";
    


  • was muss ich mit dem code den genau machen damit die zahlen auch eine leerstelle kriegen?

    Habe daraus das gmacht:

    else
    cout << " ";
    cout << " ";
    cout << " ";

    jetzt haben die zahlen zwar lücken aber jetzt passt gar nix.

    wenn ich 0 klicke schmeisst der die 0 links neben der dargestellten 0.

    nur die 1 klappt. klicke ich auf 1 tut er diesen auch auf die 1 rauf.


Log in to reply