enum piece {EMPTY, BLACK, WHITE};

#include <vector>
#include <iostream>
#include <string>
using namespace std;
#include "connectfour.h"

// Oh yeah! this is where I proto the overloaded operators
ostream& operator<<(ostream& Out, piece oPiece); // allows cout of piece type
ostream& operator<<(ostream& Out, ConnectFour oBoard); // allows cout of ConnectFour type

// Now for my extra function:
void processWinner(ConnectFour theBoard, string player1, string player2);
// processes who won

int main()
{
    ConnectFour theBoard;
    string player1,
           player2;
    cout << "This is Connect Four!\nThis is a game of wits.\n"
         << "When prompted, you input the column number (displayed above the column)\n"
         << "that you wish to place your piece in.\n"
         << "The first player to get 4 pieces in a row (vertically, horizontally,\n"
         << "or diagonally) wins! Let's begin by giving you each a name.\n"
         << "Would the first player please input their name: ";
    cin >> player1;
    cout << "Woud the second player please input their name: ";
    cin >> player2;
    
    cout << "Let's begin.\n";
    
    system("pause");
    
    
    for ( ; theBoard.full() == 0 ; )
    // Main game loop, exits if the board becomes full.
    {
        system("cls");
        
        if ( theBoard.currentplayer() == BLACK )
        {
             cout << player1 << ", colour black (B)";
        }
        else
        {
            cout << player2 << ", colour white (W)";
        }
        int chosenCol;
        cout << ", it is your turn.\n"
             << theBoard << "\n\n"
             << "What column would you like to place your piece in? -1 quits. ";
        
        cin >> chosenCol;
        if ( chosenCol == -1 ) //quit if they say -1
        {
             break;
        }
        
        while ( cin.fail() || chosenCol > 6 || chosenCol < -1 || theBoard.get(chosenCol, 0) != EMPTY )
        {
              cin.clear();
              cin.ignore(100,'\n');
              
              cout << "You are in trouble now! You can't place a piece in that column.\n"
                   << "What column would you like to place your piece in? -1 quits. ";
              cin >> chosenCol;
        }
        
        if ( chosenCol == -1 ) // quit if they say -1 (in case they putin invalid values)
        {
             break;
        }
        
        theBoard.move(chosenCol);
        if ( theBoard.winner() != EMPTY )
        {
             break;
        }
    }
    
    //process the winner
    processWinner(theBoard, player1, player2);
    
    system("pause");
    return 0;
}

ostream& operator<<(ostream& Out, piece oPiece)
{// overloaded << operator allowing the cout of 'piece's
         if ( oPiece == EMPTY || oPiece == 0 )
         {
              Out << " "; // if it's an EMPTY piece, I'll display a space
         }
         
         if ( oPiece == BLACK || oPiece == 1 )
         {
              Out << "B"; // If it's BLACK, display a B
         }
         
         if ( oPiece == WHITE || oPiece == 2 )
         {
              Out << "W"; // If it's WHITE, display a W
         }
         
         return Out;
};

ostream& operator<<(ostream& Out, ConnectFour oBoard)
{// overloaded operator allowing the cout of 'ConnectFour's
         Out << " 0  1  2  3  4  5  6\n";
         for ( int Row = 0 , Col = 0; Row < 6 ; Col++ )
         {/* a loop incrementing the column number, that ends when the row number is larger
         than the size of the columns */
             Out << "|" << oBoard.get(Col, Row) << "|"; /* goes through column by column and 
             outputs the ROWth term in the column */
             if ( Col == 6 ) /* if I went through every column, I need to end the line
             and then I need to goto the next row in the columns */
             {
                  Out << endl; // end the line
                  Row++; // next row
                  Col = 0 - 1 ; /* now you know why COL isn't unsigned.
                  the increment makes it 0 in the next loop. */
             }
         }
         Out << "---------------------\n";
         return Out;
};

// function to process the winner
void processWinner(ConnectFour theBoard, string player1, string player2)
{
    if ( theBoard.winner() == EMPTY )
    {
         cout << "\nIt would appear a though we have a tie!\n"
              << "I hope it's more exciting next time around...\n";
    }
    if ( theBoard.winner() == WHITE )
    {
         cout << player2 << " has won the game! Congratulations, " << player2 << "!\n"
              << "Sorry, " << player1 << "; better luck next time!\n";
    }
    if ( theBoard.winner() == BLACK )
    {
         cout << player1 << " has won the game! Congratulations, " << player1 << "!\n"
              << "Sorry, " << player2 << "; better luck next time!\n";
    }
    return;
};

#include <vector>
using namespace std;

enum piece {EMPTY, BLACK, WHITE};
// enumerate three values for a 'piece' 

typedef vector <piece> column;
// define a datatype named column that is a vector of the enumerated datatype piece

class ConnectFour
{
private:
    vector <column> Board;
    // a vector named Board that contains vectors of the datatype column

    piece CurrentPlayer;
    // a piece named CurrentPlayer

public:
    ConnectFour();
    // default constructor

    bool move (int col);
    // places a piece of the current player in column col.
    // returns false if move is invalid, true if the move is valid.

    piece get(int col, int row);
    // returns the piece at the location (col,row)

    piece winner();
    // returns the winner.  EMPTY means that no one has won yet.

    piece currentplayer();
    // returns the current player

    bool full();
    // returns true if the board is full; returns false otherwise
};

#include <vector>
#include <iostream>
using namespace std;
#include "connectfour.h"

ConnectFour::ConnectFour()
// default constructor
{
           // an empty column
           column emptyColumn (6, EMPTY);
           
           // loop to push_back 7 empty columns
           for (unsigned int i = 0 ; i < 7 ; i++ )
           {
               Board.push_back(emptyColumn);
           }
           
           CurrentPlayer = BLACK;
           
};

bool ConnectFour::move (int col)
// places a piece of the current player in column col.
// returns false if move is invalid, true if the move is valid.
{
           //if they chose a full column, they can't do that!
           if ( Board[col][0] != 0 )
           {
                return 0;
           }
           
           // main loop, going through the column and placing the piece at the last 0 slot
           int ROW;
           for ( ROW = 0 ; ROW < 7 ; ROW++ )
           {
               if ( Board[col][ROW] != 0 ) // if I get a non-0 slot...
               {
                    ROW--; // go back a row...
                    Board[col][ROW] = CurrentPlayer; // set that spot to the currentplayer's colour...
                    break;// then leave the loop.
               }
               if ( ROW == 6 && Board[col][ROW] == 0 ) // if the last spot is 0...
               {
                    Board[col][ROW] = CurrentPlayer; // set it to the currentplayer's colour...
                    break; // then leave the loop.
               }
           }
           
           // switch players
           if ( CurrentPlayer == 1 )
           {
                CurrentPlayer = WHITE;
           }
           if ( CurrentPlayer == 2 )
           {
                CurrentPlayer = BLACK;
           }
           
           return 1;
};

piece ConnectFour::get(int col, int row)
// returns the piece at the location (col,row)
{
           piece thePiece = Board[col][row];
           return thePiece;
};

piece ConnectFour::winner()
// returns the winner.  EMPTY means that no one has won yet.
{
           int count = 0; // counter of the no. of pieces in a row
           piece currentColour; // the color of the piece I am checking.
           
           // first possibility : Horizontal
           
           for ( int r = 0, c = 0 ; c < 4 ; r++ )
           {/* stops when we pass the last possible column for a horizontal win
           and moves through row by row */
               
               //first test if we have a empty square and move down the column if we do
               if ( Board[c][r] == 0 )
               {
                    continue;
               }
               else // start searching for more pieces of that color in that row
               {
                    currentColour = Board[c][r];
                    count = 1;
                    int tempCol = c; /* so I can revert to the column I was in if
                    the colour doesn't match. */
                    
                    /* start search loop at one col further than the last piece,
                    ending with an interior break or return */
                    for ( c++ ; ; c++ )
                    {
                        if ( Board[c][r] == currentColour ) // if we have a match
                        {
                             count++;// one more of that type
                             if ( count == 4 ) // if we have four in a row
                             {
                                  return currentColour;
                             }
                             continue; //then try again
                        }
                        else // if there isn't a match...
                        {
                             c = tempCol; //return to column we started searching from
                             count = 0; // set our counter to 0
                             break; // go back to searching for pieces
                        }
                    }
               }
               
               // if we get to the bottom of the column, move to the next.
               if ( r == Board[0].size() - 1 )
               {
                    c++;
                    r = -1; /* b/c of increment I have to set it to become
                    0 in the beginning of the loop */
               }
           }
           // if there is a horizontal win, it would have 'return'ed by now
           
           // Second Possibility: vertical win
           for ( int r = 0, c = 0 ; c < Board.size() || r > 2; c++ )
           {/* stops when we pass the last possible row for a vertical win
           and moves through column by column */
               
               //first test if we have a 0 square and move to the next column if we do
               if ( Board[c][r] == 0 )
               {
                    continue;
               }
               
               else // start searching for more pieces of that color in that column
               {
                    currentColour = Board[c][r];
                    count = 1;
                    int tempRow = r; /* so I can revert to the row I was in if
                    the colour doesn't match at any point in time. */
                    
                    /* start search loop one row below the last one,
                    ending with an interior break or return */
                    for ( r++ ; ; r++ )
                    {
                        if ( Board[c][r] == currentColour ) // if we have a match
                        {
                             count++;// one more of that type
                             if ( count == 4 ) // if we have four in a row
                             {
                                  return currentColour;
                             }
                             continue; //then try again if it isn't the 4th
                        }
                        else // if there isn't a match...
                        {
                             r = tempRow; // return to row we started searching from
                             count = 0; // set our counter to 0
                             break; // go back to searching for pieces
                        }
                    }
               }
               
               // if we get to the last column, move to the next row.
               if ( c == Board.size() - 1 )
               {
                    r++;
                    c = -1; /* b/c of increment I have to set it to become
                    0 in the beginning of the loop */
               }
           }
           
           // Third possibility: diagonal upward
           
           for ( int r = 3, c = 0 ; c < 4 ; c++ )
           {/* starts at the first possible spot for a starting piece for a daigup win,
           and ends when we pass the last column where it's possible to start a
           diagup win, and goes through column by column. */
               
               //first test if we have a 0 square and move to the next column if we do
               if ( Board[c][r] == 0 )
               {
                    continue;
               }
               
               else // start searching for more pieces of that color in that column
               {
                    currentColour = Board[c][r];
                    count = 1;
                    int tempRow = r; /* so I can revert to the row I was in if
                    the colour doesn't match at any point in time. */
                    int tempCol = c; /* so I can revert to the column I was in if
                    the colour doesn't match at any point in time. */
                    
                    /* start search loop one row above the last piece and one column further,
                    ending with a break or return on the interior */
                    for ( r++ , c++ ; ; r++, c++ )
                    {
                        if ( Board[c][r] == currentColour ) // if we have a match
                        {
                             count++;// one more of that type
                             if ( count == 4 ) // if we have four in a row
                             {
                                  return currentColour;
                             }
                             continue; //then try again if it isn't the 4th
                        }
                        else // if there isn't a match...
                        {
                             r = tempRow; // return to row we started searching from
                             c = tempCol; // return to column we started searching from
                             count = 0; // set our counter to 0
                             break; // go back to searching for pieces
                        }
                    }
               }
               
               // if we get past the last possible column, move to the next row.
               if ( c == 3 )
               {
                    r++;
                    c = -1; /* b/c of increment I have to set it to become
                    0 in the beginning of the loop */
               }
           }
           
           // Fourth possibility: diagonal downward
           
           for ( int r = 0, c = 0 ; c < 4, r < 3 ; c++ )
           {/* starts at the first possible spot for a starting piece for a daigdown win,
           and ends when we pass the last column or row where it's possible to start a
           diagdown win, and goes through column by column. */
               
               //first test if we have a 0 square and move to the next column if we do
               if ( Board[c][r] == 0 )
               {
                    continue;
               }
               
               else // start searching for more pieces of that color in that column
               {
                    currentColour = Board[c][r];
                    count = 1;
                    int tempRow = r; /* so I can revert to the row I was in if
                    the colour doesn't match at any point in time. */
                    int tempCol = c; /* so I can revert to the column I was in if
                    the colour doesn't match at any point in time. */
                    
                    /* start search loop one row below the last piece and one column further,
                    ending with a break or return on the interior */
                    for ( r-- , c++ ; ; r--, c++ )
                    {
                        if ( Board[c][r] == currentColour ) // if we have a match
                        {
                             count++;// one more of that type
                             if ( count == 4 ) // if we have four in a row
                             {
                                  return currentColour;
                             }
                             continue; //then try again if it isn't the 4th
                        }
                        else // if there isn't a match...
                        {
                             r = tempRow; // return to row we started searching from
                             c = tempCol; // return to column we started searching from
                             count = 0; // set our counter to 0
                             break; // go back to searching for pieces
                        }
                    }
               }
               
               // if we get past the last possible column, move to the next row.
               if ( c == 3 )
               {
                    r++;
                    c = -1; /* b/c of increment I have to set it to become
                    0 in the beginning of the loop */
               }
           }
           
           // if it hasn't returned yet, it's a no-win situation, so the winner is EMPTY.
           return EMPTY;
};

piece ConnectFour::currentplayer()
// returns the current player
{
           return CurrentPlayer;
};

bool ConnectFour::full()
// returns true if the board is full; returns false otherwise
{
           // search the top row for empty spaces, if there is one, it's not full ^_^
           for ( int row = 0, col = 0 ; col < Board.size() ; col++ )
           {
               if ( Board[col][row] == 0 )
               {
                    return 0;
               }
           }
           return 1;
};