Capture The Sarrum

// ConsoleApplication7.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <iostream>

#include <string>
#include <stdlib.h>

using namespace std;

const int BoardDimension = 8;

void DisplayWhoseTurnItIs(char WhoseTurn)
{
    if (WhoseTurn == 'W') {
        cout << "It is White's Turn" << endl;
    }
    else
    {
        cout << "It is Black's Turn" << endl;
    }
}

void DisplayWinner(char WhoseTurn)
{
    if (WhoseTurn == 'W') {
        cout << "Black's Sarrum has been captured. White win!" << endl;
    }
    else
    {
        cout << "White's Sarrum has been captured. Black wins!" << endl;
    }
    cout << endl;
}

bool CheckIfGameWillBeWon(string Board[8][8], int FinishRank, int FinishFile)
{
    if (Board[FinishRank][FinishFile].at(1) == 'S') {
        return true;
    }
    else
    {
        return false;
    }

}

void DisplayBoard(string Board[8][8])
{
    int RankNo, FileNo;
    cout << endl;
    for (RankNo = 1;RankNo <= BoardDimension;RankNo++)
    {
        cout << " _________________________" << endl;
        cout << RankNo << " ";

        for (FileNo = 1;RankNo <= BoardDimension;FileNo++)
        {
            cout << "|" << Board[RankNo][FileNo];
        }
        cout << "|" << endl;
    }
    cout << " _________________________" << endl;
    cout << endl;
    cout << " 1 2 3 4 5 6 7 8";
    cout << endl;
    cout << endl;
}
bool CheckRedumMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile, char ColourOfPiece)
{
    if (ColourOfPiece == 'W')
    {
        if (FinishRank == (StartRank - 1))
        {
            if ((FinishFile == StartFile) && (Board[FinishRank][FinishFile] == " "))
            {
                return true;
            }
            else if (abs(FinishFile - StartFile) == 1 && (Board[FinishRank][FinishFile].at(0) == 'B'))
            {
                return true;
            }
        }
    }
    else
    {
        if (FinishRank == StartRank + 1)
        {
            if ((FinishFile == StartFile) && (Board[FinishRank][FinishFile] == " "))
            {
                return true;
            }
            else if (abs(FinishFile - StartFile) == 1 && (Board[FinishRank][FinishFile].at(0) == 'W'))
            {
                return true;
            }
        }
    }
    return false;

}

bool CheckSarrumMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile)
{
    if ((abs(FinishFile - StartFile) <= 1) && (abs(FinishRank - StartRank) <= 1))
    {
        return true;
    }
    return false;
}

bool CheckGisgigirMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile)

{
    bool GisgigirMoveIsLegal = false;
    int count, RankDifference, FileDifference;

    RankDifference = FinishRank - StartRank;
    FileDifference = FinishFile - StartFile;

    if (RankDifference == 0)
    {
        if (FileDifference >= 1)
        {
            GisgigirMoveIsLegal = true;
            for (count = 1;count<FileDifference;count++)
            {
                if (Board[StartRank][StartFile + count] != " ")
                {
                    GisgigirMoveIsLegal = false;
                }
            }
        }
        else if (FileDifference <= -1)
        {
            GisgigirMoveIsLegal = true;
            for (count = -1;count>FileDifference;count--)
            {
                if (Board[StartRank][StartFile + count] != " ")
                {
                    GisgigirMoveIsLegal = false;
                }
            }
        }
    }
    else if (FileDifference == 0)
    {
        if (RankDifference >= 1)
        {
            GisgigirMoveIsLegal = true;
            for (count = 1;count<RankDifference;count++)
            {
                if (Board[StartRank + count][StartFile] != " ")
                {
                    GisgigirMoveIsLegal = false;
                }
            }
        }
        else if (RankDifference <= 1)
        {
            GisgigirMoveIsLegal = true;
            for (count = -1;count>RankDifference;count--)
            {
                if (Board[StartRank + count][StartFile] != " ")
                {
                    GisgigirMoveIsLegal = false;
                }
            }

        }
    }
    return GisgigirMoveIsLegal;
}
bool CheckNabuMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile)
{
    if ((abs(FinishFile - StartFile) == 1) && (abs(FinishRank - StartRank) == 1))
    {
        return true;

    }
    return false;
}

bool CheckMarzazPaniMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile)
{
    if (((abs(FinishFile - StartFile) == 1) && (abs(FinishRank - StartRank) == 0)) || ((abs(FinishFile - StartFile) == 0) && (abs(FinishRank - StartRank) == 1)))
    {
        return true;
    }
    return false;
}

bool CheckEtluMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile)
{
    if (((abs(FinishFile - StartFile) == 2) && (abs(FinishRank - StartRank) == 0)) || ((abs(FinishFile - StartFile) == 0) && (abs(FinishRank - StartRank) == 2)))
    {
        return true;
    }
    return false;
}

bool CheckMoveIsLegal(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile, char WhoseTurn)
{
    char PieceType, PieceColour;
    if ((FinishFile == StartFile) && (FinishRank == StartRank))
    {
        return false;
    }
    PieceType = Board[StartRank][StartFile].at(1);
    PieceColour = Board[StartRank][StartFile].at(0);
    if (WhoseTurn == 'W')
    {
        if (PieceColour != 'W')
        {
            return false;
        }
        if (Board[FinishRank][FinishFile].at(0) == 'W')
        {
            return false;
        }
    }
    else
    {
        if (PieceColour != 'B')
        {
            return false;
        }
        if (Board[FinishRank][FinishFile].at(0) == 'B')
        {
            return false;
        }
    }
    switch (PieceType) {
    case 'R':
        return CheckRedumMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile, PieceColour);
        break;
    case 'S':
        return CheckSarrumMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
        break;
    case 'M':
        return CheckMarzazPaniMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
        break;
    case 'G':
        return CheckGisgigirMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
        break;
    case 'N':
        return CheckNabuMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
        break;
    case 'E':
        return CheckEtluMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile);
        break;

    default:
        return false;
        break;
    }
}

void InitialiseBoard(string Board[8][8], char SampleGame)
{
    int RankNo, FileNo;

    if (SampleGame == 'Y')
    {
        for (RankNo = 1;RankNo <= BoardDimension;RankNo++)
        {
            for (FileNo = 1;FileNo <= BoardDimension;FileNo++)
            {
                Board[RankNo][FileNo] = " ";
            }
        }
        Board[1][2] = "BG";
        Board[1][4] = "BS";
        Board[1][8] = "WG";
        Board[2][1] = "WR";
        Board[3][1] = "WS";
        Board[3][2] = "BE";
        Board[3][8] = "BE";
        Board[6][8] = "BR";
    }
    else
    {
        for (RankNo = 1;RankNo <= BoardDimension;RankNo++)
        {
            for (FileNo = 1;FileNo <= BoardDimension;FileNo++)
            {
                if (RankNo == 2)
                {
                    Board[RankNo][FileNo] = "BR";
                }
                else if (RankNo == 7)
                {

                    Board[RankNo][FileNo] = "WR";
                }
                else if (RankNo == 1 || RankNo == 8)
                {
                    if (RankNo == 1)
                    {
                        Board[RankNo][FileNo] = "B";
                    }
                    if (RankNo == 8)
                    {
                        Board[RankNo][FileNo] = "W";
                    }
                    switch (FileNo) {
                    case 1:
                    case 8:
                        Board[RankNo][FileNo] = Board[RankNo][FileNo] + "G";
                        break;
                    case 2:
                    case 7:
                        Board[RankNo][FileNo] = Board[RankNo][FileNo] + "E";
                        break;
                    case 3:
                    case 6:
                        Board[RankNo][FileNo] = Board[RankNo][FileNo] + "N";
                        break;
                    case 4:
                        Board[RankNo][FileNo] = Board[RankNo][FileNo] + "M";
                        break;
                    case 5:
                        Board[RankNo][FileNo] = Board[RankNo][FileNo] + "S";
                        break;
                    }
                }
                else {
                    Board[RankNo][FileNo] = " ";
                }

            }
        }

    }

}

void GetMove(int StartSquare, int FinishSquare)
{
    cout << "Enter coordinates of sqauare containing piece to move to(file first): ";
    cin >> StartSquare;
    cout << "Enter coordinates of square to move piece to: ";
    cin >> FinishSquare;
}

void MakeMove(string Board[8][8], int StartRank, int StartFile, int FinishRank, int FinishFile, char WhoseTurn)
{
    if ((WhoseTurn == 'W') && (FinishRank = 1) && (Board[StartRank][StartFile].at(1) = 'R'))
    {
        Board[FinishRank][FinishFile] = "WM";
        Board[StartRank][StartFile] = " ";
    }
    else if ((WhoseTurn == 'B') && (FinishRank = 8) && (Board[StartRank][StartFile].at(1) = 'R'))
    {
        Board[FinishRank][FinishFile] = "BM";
        Board[StartRank][StartFile] = " ";
    }
    else
    {
        Board[FinishRank][FinishFile] = Board[StartRank][StartFile];
        Board[StartRank][StartFile] = " ";
    }
}

int main()
{
    string Board[BoardDimension][BoardDimension];
    bool GameOver, MoveIsLegal;
    int StartSquare=0, FinishSquare=0, StartRank, StartFile, FinishRank, FinishFile;
    char PlayAgain, SampleGame, WhoseTurn;
    PlayAgain = 'Y';

    do

    {
        WhoseTurn = 'W';
        GameOver = false;
        cout << "Do you want to play the sample game(enter Y for Yes)?";
        cin >> SampleGame;
        InitialiseBoard(Board, SampleGame);

        do
        {
            DisplayBoard(Board);
            DisplayWhoseTurnItIs(WhoseTurn);
            MoveIsLegal = false;

            do
            {
                GetMove(StartSquare, FinishSquare);
                StartRank = StartSquare % 10;
                StartFile = StartSquare / 10;
                FinishRank = FinishSquare % 10;
                FinishFile = FinishSquare / 10;
                MoveIsLegal = CheckMoveIsLegal(Board, StartRank, StartFile, FinishRank, FinishFile, WhoseTurn);
                if (MoveIsLegal == false)
                {
                    cout << "That is an illegal move-please try again" << endl;

                }

            } while (!MoveIsLegal);

            GameOver = CheckIfGameWillBeWon(Board, FinishRank, FinishFile);
            MakeMove(Board, StartRank, StartFile, FinishRank, FinishFile, WhoseTurn);
            if (GameOver == true)
            {
                DisplayWinner(WhoseTurn);

            }
            if (WhoseTurn == 'W')
            {
                WhoseTurn = 'B';
            }
            else
            {
                WhoseTurn = 'W';
            }

        } while (!GameOver);

        cout << "Do you want to play again(enter Y for Yes)?";
        cin >> PlayAgain;

    } while (PlayAgain == 'Y');
    return 0;
}