//Dominika Piotrowska 180311 ID2
//Project 1 – card game

#include<iostream>
#include<ctime>
#include <unistd.h>

using namespace std;

#define FILE_AVERAGE "average.txt"
#define FILE_WINS "numberOfWins.txt"
#define FILE_AVERAGE_2 "average2.txt"

#define SLEEP_TIME 0

#define MAX_SIZE_OF_DECK 52
#define NUMBER_OF_COLORS 4
#define NUMBER_OF_FIGURES 13
const char CLUBS[] = { "\xe2\x99\xa3" };
const char DIAMONDS[] = { "\xe2\x97\x86" };
const char HEARTS[] = { "\xe2\x99\xa5" };
const char SPADES[] = { "\xe2\x99\xa0" };

struct card {
    char rank;
    char color[4];
    unsigned short value;
    unsigned short valueColor;
};

struct player {
    card deck[MAX_SIZE_OF_DECK]{};
    int numberOfWins = 0;
    int numberOfCards = 0;
    void (*strategy)(player&, player&) = nullptr;

};

void zeroing(card array[]);
int choosingVariant(char variant);
void initialization(int sizeOfDeck, card deck[]);
void shuffling(int sizeOfDeck, card deck[]);
int check(int pomValue, int pomValueColor, card deck[], int i);
void dealingCards(int sizeOfDeck, card deck[], player& player1, player& player2);
void initialHands(player& player1, player& player2);
void battle(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements, card randomDeck[], int isSmartwar);
void warSmartWar(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int& numberOfMovements, int isVariantA, card randomDeck[], int isSmartWar);
void randomStrategy(player& currentPlayer, player& secondPlayer);
void furiousStrategy(player& furiousPlayer, player& secondPlayer);
void peacefulStrategy(player& peacefulPlayer, player& secondPlayer);
void winningRandom(player& winningPlayer, player& losingPlayer);
void randomAdding(player& winningPlayer, player& losingPlayer, int counter, card randomDeck[]);
void variantA(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, int& numberOfMovements, card randomDeck[], int isSmartWar);
void variantB(player& winningPlayer, player& losingPlayer, int& counter);
void moving(player& currentPlayer);
void clear(player& currentPlayer, int number);
void winning(player& winningPlayer, player& losingPlayer);
void war(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int isVariantA, int& numberOfMovements, int& counterHelp, card randomDeck[], int isSmartWar);
void movingWar(player& winningPlayer, player& losingPlayer, int counter);
void displayWar(player& player1, player& player2, card deck1[], card deck2[]);
void endingWar(player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, card randomDeck[], int isSmartWar);
void battleSmartWar(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements, card randomDeck[], int isSmartWar,int i);
void ending(player& player1, player& player2, int numberOfMovements, int& sumOfMovements);
void choosePlayerStrategy(player&);
int valueOfStartingDeck(card* deck, int sizeOfDeck);
int main()
{


    card deck[MAX_SIZE_OF_DECK];
    card randomDeck[MAX_SIZE_OF_DECK];
    zeroing(randomDeck);
    srand(time(NULL));


    player player1;
    player player2;
    player1.numberOfWins = 0;
    player2.numberOfWins = 0;
    int sizeOfDeck = 0;
    char variant = 0;
    int sumOfMovements = 0;
    int option = 1;
    cout << "What do you want to do?" << endl;
    cout << "1. Demonstrate a simulation of a game. " << endl;
    cout << "2. Experiment 1. Simulate war game for x times and save to the file average number of movements." << endl;
    cout << "3. Experiment 1. Smart war game simulations." << endl;
    cout << "4. Experiment 2. Smart war game strategies." << endl;
    cout << "5. Experiment 2. Correlation." << endl;
    cout << "You choose option ";
    cin >> option;
    if (option != 4)//in option 4 size of deck must be 52
    {
        cout << "Choose size of deck: ";
        cin >> sizeOfDeck;
    }
    int isVariantA = 0;
    int isSmartWar = 0;
    if (option == 1 || option == 2||option==5)
    {
        cout << "Choose one of two possible variants of the game." << endl;
        cout << "A . If a player runs out of cards during a war he immediately loses." << endl;
        cout << "B . If a player (say X) runs out of cards during a war, then:" << endl << "1) if X starting the war had only one card, then his opponent (sayY) is placing two cards on X’s stack, then two cards on Y’s," << endl << "2) if X starting the war had two cards, then his opponent Y is placing one card on X’s stack, then one card on Y’s," << endl << "3) if Y runs of cards while playing, then X is loosing." << endl;
        cout << "You choose: ";
        cin >> variant;
        isVariantA = choosingVariant(variant);
    }
    if (option == 1)
    {
        initialization(sizeOfDeck, deck);
        dealingCards(sizeOfDeck, deck, player1, player2);
        battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements,randomDeck,isSmartWar);
    }
    else if (option == 2)
    {
        int numberOfGames = 0;
        cout << "How many times do you want to simulate this game?" << endl;
        cout << "You choose ";
        cin >> numberOfGames;
        for (int i = 0; i < numberOfGames; i++)
        {
            zeroing(player1.deck);
            zeroing(player2.deck);
            initialization(sizeOfDeck, deck);
            dealingCards(sizeOfDeck, deck, player1, player2);
            battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);
        }
        cout << endl << "Player1 won " << player1.numberOfWins << " times";
        cout << endl << "Player2 won " << player2.numberOfWins << " times";
        cout << endl << "IN " << numberOfGames << " GAMES " << sumOfMovements << " WERE MADE.";
        FILE* average = fopen(FILE_AVERAGE, "a");
        int averageOfMovements = sumOfMovements / numberOfGames;

        fprintf(average, "average movements %d\n", averageOfMovements);
        fprintf(average, "size of deck %d\n", sizeOfDeck);
        fprintf(average, "variant %c\n", variant);
        fclose(average);
        cout << endl << "AVERAGE NUMBER OF MOVEMENTS PER GAME " << averageOfMovements << endl;

    }
    else if (option == 3)
    {
        int numberOfGames = 0;
        cout << "How many times do you want to simulate this game?" << endl;
        cout << "You choose ";
        cin >> numberOfGames;
        isVariantA = 1;
        isSmartWar = 1;
        player1.strategy = randomStrategy;
        player2.strategy = randomStrategy;

        for (int i = 0; i < numberOfGames; i++)
        {
            zeroing(player1.deck);
            zeroing(player2.deck);
            initialization(sizeOfDeck, deck);
            dealingCards(sizeOfDeck, deck, player1, player2);
            battleSmartWar(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar,i);
        }
        cout << endl << "Player1 won " << player1.numberOfWins << " times";
        cout << endl << "Player2 won " << player2.numberOfWins << " times";
        cout << endl << "IN " << numberOfGames << " GAMES " << sumOfMovements << "WERE MADE.";
        FILE* average2 = fopen(FILE_AVERAGE_2, "a");
        int averageOfMovements = sumOfMovements / numberOfGames;

        fprintf(average2, "average movements %d\n", averageOfMovements);
        fprintf(average2, "size of deck %d\n", sizeOfDeck);
        fclose(average2);
        cout << endl << "AVERAGE NUMBER OF MOVEMENTS PER GAME" << averageOfMovements << endl;

    }
    else if (option == 4)
    {

        isVariantA = 1;
        isSmartWar = 1;
        sizeOfDeck = 52;
        cout << "Choose strategy for 1 Player: " << endl;
        cout << "1.Random." << endl;
        cout << "2.Furious." << endl;
        cout << "3.Peaceful." << endl;
        choosePlayerStrategy(player1);

        cout << "Choose strategy for 2 Player: " << endl;
        cout << "1.Random." << endl;
        cout << "2.Furious." << endl;
        cout << "3.Peaceful." << endl;
        choosePlayerStrategy(player2);


        int numberOfGames = 0;
        cout << "How many times do you want to simulate this game?" << endl;
        cout << "You choose ";
        cin >> numberOfGames;
        for (int i = 0; i < numberOfGames; i++)
        {
            zeroing(player1.deck);
            zeroing(player2.deck);
            initialization(sizeOfDeck, deck);
            dealingCards(sizeOfDeck, deck, player1, player2);
            battleSmartWar(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar,i);

        }
        cout << endl << "Player1 won " << player1.numberOfWins << " times";
        cout << endl << "Player2 won " << player2.numberOfWins << " times";
        FILE* wins = fopen(FILE_WINS, "a");

        fprintf(wins, "player 1 wins %d\n", player1.numberOfWins);
        fprintf(wins, "player 2 wins %d\n", player2.numberOfWins);

        fprintf(wins, "strategy player 1 ");
        if (player1.strategy == randomStrategy)
            fprintf(wins, "RANDOM\n");
        else if (player1.strategy == furiousStrategy)
            fprintf(wins, "FURIOUS\n");
        else
            fprintf(wins, "PEACEFUL\n");

        fprintf(wins, "strategy player 2 ");
        if (player2.strategy == randomStrategy)
            fprintf(wins, "RANDOM\n");
        else if (player2.strategy == furiousStrategy)
            fprintf(wins, "FURIOUS\n");
        else
            fprintf(wins, "PEACEFUL\n");
        fclose(wins);
    }
    else if (option == 5)
    {

        initialization(sizeOfDeck, deck);
        dealingCards(sizeOfDeck, deck, player1, player2);
        cout << "p1 deck value: " << valueOfStartingDeck(player1.deck, sizeOfDeck) << endl;
        cout << "p2 deck value: " << valueOfStartingDeck(player2.deck, sizeOfDeck) << endl;
        battle(sizeOfDeck, player1, player2, isVariantA, sumOfMovements, randomDeck, isSmartWar);

    }


    return 0;

}

int choosingVariant(char variant)
{
    int option = 0;
    switch (variant)
    {
        case 'A':
            option = 1;
            break;
        case 'B':
            option = 0;
            break;
        default:
            break;
    }
    return option;
}

void initialization(int sizeOfDeck, card deck[])
{
    zeroing(deck);
    shuffling(sizeOfDeck, deck);
    for (int i = 0; i < sizeOfDeck; i++)
    {
        if (deck[i].value < 9)
        {
            deck[i].rank = (deck[i].value + 49);
        }
        else
        {
            switch (deck[i].value)
            {
                case 9:
                    deck[i].rank = 'X';
                    break;
                case 10:
                    deck[i].rank = 'J';
                    break;
                case 11:
                    deck[i].rank = 'Q';
                    break;
                case 12:
                    deck[i].rank = 'K';
                    break;
                case 13:
                    deck[i].rank = 'A';
                    break;
            }
        }
        switch (deck[i].valueColor)
        {
            case 1:
                strcpy(deck[i].color, CLUBS);
                break;
            case 2:
                strcpy(deck[i].color, DIAMONDS);
                break;
            case 3:
                strcpy(deck[i].color, HEARTS);
                break;
            case 4:
                strcpy(deck[i].color, SPADES);
                break;
        }
    }
}

int check(int pomValue, int pomValueColor, card deck[], int i)//check if such a card is already in the deck
{
    for (int index = 0; index < i; index++)
    {
        if (pomValue == deck[index].value && pomValueColor == deck[index].valueColor)
        {
            return 1;
        }
    }
    deck[i].value = pomValue;
    deck[i].valueColor = pomValueColor;
    return 0;
}

void shuffling(int sizeOfDeck, card deck[])
{

    for (int i = 0; i < sizeOfDeck; i++)
    {
        int pomValue;
        int pomValueColor;
        do {
            pomValue = rand() % (sizeOfDeck / NUMBER_OF_COLORS) + (NUMBER_OF_FIGURES - sizeOfDeck / NUMBER_OF_COLORS + 1);
            pomValueColor = rand() % (NUMBER_OF_COLORS)+1;
        } while (check(pomValue, pomValueColor, deck, i));
    }
}

void dealingCards(int sizeOfDeck, card deck[], player& player1, player& player2)
{
    player1.numberOfCards = sizeOfDeck / 2;
    player2.numberOfCards = sizeOfDeck / 2;
    for (int i = 0; i < sizeOfDeck; i++)
    {
        if (i < (sizeOfDeck / 2))
        {
            player1.deck[i] = deck[i];
        }
        else
        {
            player1.deck[i].value = 0;
            player1.deck[i].valueColor = 0;
            player1.deck[i].rank = 0;
            strcpy(player1.deck[i].color, "");
        }
    }
    for (int i = 0; i < sizeOfDeck; i++)
    {
        if (i < sizeOfDeck / 2)
        {
            player2.deck[i] = deck[i + (sizeOfDeck / 2)];
        }
        else
        {
            player2.deck[i].value = 0;
            player2.deck[i].valueColor = 0;
            player2.deck[i].rank = 0;
            strcpy(player2.deck[i].color, "");
        }
    }
}
void initialHands(player& player1, player& player2)
{
    cout << "----------------------------------------------" << endl;
    cout << "----------------------------------------------" << endl;
    cout << "Initial hands PLAYER 1" << endl << endl;
    for (int i = 0; i < player1.numberOfCards; i++)
    {
        cout << "PLAYER1 [" << i << "]\t\t" << player1.deck[i].rank  << player1.deck[i].color << endl;
    }
    cout << "----------------------------------------------" << endl;
    cout << "----------------------------------------------" << endl;
    cout << "Initial hands PLAYER 2" << endl << endl;
    for (int i = 0; i < player2.numberOfCards; i++)
    {
        cout << "PLAYER2 [" << i << "]\t\t" << player2.deck[i].rank <<  player2.deck[i].color << endl;
    }
}
void battleSmartWar(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements,card randomDeck[],int isSmartWar,int i)
{
    int numberOfMovements = 0;
    int numberOfChoicesMade = 0;

    initialHands(player1, player2);
    while (player1.numberOfCards != 0 && player2.numberOfCards != 0)
    {
        numberOfMovements++;
        numberOfChoicesMade++;
        if(i % 2 == 0) {

            if (numberOfChoicesMade % 2 == 0) {
                cout << endl << "PLAYER 1\t \t";
                cout << "PLAYER 2" << endl;
                cout << player1.deck[0].rank << player1.deck[0].color << " | " << player1.deck[1].rank
                     << player1.deck[1].color << "\t \t \t";
                cout << player2.deck[0].rank << player2.deck[0].color << endl;
                player1.strategy(player1, player2);
            } else {
                cout << endl << "PLAYER 1\t \t";
                cout << "PLAYER 2" << endl;
                cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
                cout << player2.deck[0].rank << player2.deck[0].color << " | " << player2.deck[1].rank
                     << player2.deck[1].color << endl;
                player2.strategy(player2, player1);
            }
        }
        else {
            if (numberOfChoicesMade % 2 == 1) {
                cout << endl << "PLAYER 1\t \t";
                cout << "PLAYER 2" << endl;
                cout << player1.deck[0].rank << player1.deck[0].color << " | " << player1.deck[1].rank
                     << player1.deck[1].color << "\t \t \t";
                cout << player2.deck[0].rank << player2.deck[0].color << endl;
                player1.strategy(player1, player2);
            } else {
                cout << endl << "PLAYER 1\t \t";
                cout << "PLAYER 2" << endl;
                cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
                cout << player2.deck[0].rank << player2.deck[0].color << " | " << player2.deck[1].rank
                     << player2.deck[1].color << endl;
                player2.strategy(player2, player1);
            }
        }
        cout << endl << "PLAYER 1\t \t";
        cout << "PLAYER 2" << endl;
        cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
        cout << player2.deck[0].rank << player2.deck[0].color << endl;
        sleep(SLEEP_TIME);
        if (player1.deck[0].value > player2.deck[0].value)
        {
            winningRandom(player1, player2);
            cout << "Player 1 won a battle." << endl;
        }
        else if (player1.deck[0].value < player2.deck[0].value)
        {
            winningRandom(player2, player1);
            cout << "Player 2 won a battle." << endl;
        }
        else//WAR
        {
            cout << endl << "          WAR" << endl << endl;

            if (player1.numberOfCards < 3 || player2.numberOfCards < 3)
            {
                if (player1.numberOfCards > player2.numberOfCards)
                {
                    player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
                    player2.numberOfCards = 0;
                }
                else
                {
                    player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
                    player1.numberOfCards = 0;
                }
            }
            else
            {
                numberOfMovements++;
                int counter = 1;
                player1.numberOfCards = player1.numberOfCards - 3;//they can lose 3 cards
                player2.numberOfCards = player2.numberOfCards - 3;
                warSmartWar(sizeOfDeck, player1, player2, player1.deck+2, player2.deck+2, counter, numberOfMovements, isVariantA, randomDeck, isSmartWar);
            }
        }


    }
    ending(player1, player2, numberOfMovements, sumOfMovements);
}

void randomStrategy(player& currentPlayer, player& secondPlayer)//choosing one of two cards
{
    if (currentPlayer.numberOfCards == 1) return;
    int i=0;
    i = rand() % 2;
    if (i == 1)
    {
        card pomCard = currentPlayer.deck[i];
        currentPlayer.deck[i] = currentPlayer.deck[i - 1];
        currentPlayer.deck[i - 1] = pomCard;
    }
}

void furiousStrategy(player& furiousPlayer, player &secondPlayer)
{
    if (furiousPlayer.deck[1].value == secondPlayer.deck[0].value)
    {
        card pomCard = furiousPlayer.deck[1];
        furiousPlayer.deck[1] = furiousPlayer.deck[0];
        furiousPlayer.deck[0] = pomCard;
    }
    else if (furiousPlayer.deck[0].value > secondPlayer.deck[0].value)
    {
        if (furiousPlayer.deck[1].value > secondPlayer.deck[0].value && furiousPlayer.deck[1].value<furiousPlayer.deck[0].value)
        {
            card pomCard = furiousPlayer.deck[1];
            furiousPlayer.deck[1] = furiousPlayer.deck[0];
            furiousPlayer.deck[0] = pomCard;
        }

    }
    else if (furiousPlayer.deck[0].value < secondPlayer.deck[0].value)
    {
        if (furiousPlayer.deck[1].value > secondPlayer.deck[0].value)
        {
            card pomCard = furiousPlayer.deck[1];
            furiousPlayer.deck[1] = furiousPlayer.deck[0];
            furiousPlayer.deck[0] = pomCard;
        }
        else if (furiousPlayer.deck[1].value < furiousPlayer.deck[0].value)
        {
            card pomCard = furiousPlayer.deck[1];
            furiousPlayer.deck[1] = furiousPlayer.deck[0];
            furiousPlayer.deck[0] = pomCard;
        }

    }

}

void peacefulStrategy(player& peacefulPlayer, player& secondPlayer)
{
    if (peacefulPlayer.numberOfCards == 1) return;
    else if (peacefulPlayer.deck[0].value < peacefulPlayer.deck[1].value)
    {
        if (peacefulPlayer.deck[0].value == secondPlayer.deck[0].value)
        {
            card pomCard = peacefulPlayer.deck[1];
            peacefulPlayer.deck[1] = peacefulPlayer.deck[0];
            peacefulPlayer.deck[0] = pomCard;
        }

    }
    else
    if (peacefulPlayer.deck[1].value != secondPlayer.deck[0].value)
    {
        card pomCard = peacefulPlayer.deck[1];
        peacefulPlayer.deck[1] = peacefulPlayer.deck[0];
        peacefulPlayer.deck[0] = pomCard;
    }
}

void winningRandom(player& winningPlayer, player& losingPlayer)//adding cards in random order after winning the battle
{
    int i;
    i = rand() % 2;

    card pomWinner = winningPlayer.deck[0];
    card pomLoser = losingPlayer.deck[0];
    moving(winningPlayer);
    winningPlayer.numberOfCards++;
    moving(losingPlayer);
    losingPlayer.numberOfCards--;
    if (i == 1)
    {
        winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomWinner;
        winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomLoser;
    }
    else
    {
        winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomLoser;
        winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomWinner;
    }


}

void randomAdding(player& winningPlayer, player& losingPlayer, int counter, card randomDeck[])//creating a table with cards which should go to winners hand in random order
{
    int index = 0;
    for (int i = 0; i < ((counter * 2) + 1); i++)
    {
        do
        {
            index = rand() % (2 * ((counter * 2) + 1));
        } while (randomDeck[index].value != 0);

        randomDeck[index]= winningPlayer.deck[0];
        moving(winningPlayer);
        winningPlayer.numberOfCards--;
    }

    for (int i = 0; i < ((counter * 2) + 1); i++)
    {
        do
        {
            index = rand() % (2 * ((counter * 2) + 1));
        } while (randomDeck[index].value != 0);

        randomDeck[index]= losingPlayer.deck[0];
        moving(losingPlayer);
        losingPlayer.numberOfCards--;
    }

    for (int i = 0; i < (2 * ((counter * 2) + 1)); i++)
    {
        winningPlayer.deck[winningPlayer.numberOfCards + i] = randomDeck[i];
    }

    zeroing(randomDeck);
    winningPlayer.numberOfCards = winningPlayer.numberOfCards + (2 * ((counter * 2) + 1));
}

void warSmartWar(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int& numberOfMovements, int isVariantA, card randomDeck[],int isSmartWar)
{
    if (deck1[0].value == deck2[0].value)
    {
        counter++;
        numberOfMovements++;
        if (player1.numberOfCards <= 1 || player2.numberOfCards <= 1)
        {

            endingWar(player1, player2, deck1, deck2, counter, isVariantA, randomDeck, isSmartWar);

        }
        else
        {
            displayWar(player1, player2, deck1, deck2);
            cout << endl << "          WAR" << endl << endl;
            player1.numberOfCards = player1.numberOfCards - 2;//player can lose 2 cards
            player2.numberOfCards = player2.numberOfCards - 2;
            warSmartWar(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, numberOfMovements,isVariantA,randomDeck,isSmartWar );
        }

    }
    else if (player1.numberOfCards < 0)
    {
        player1.numberOfCards = 0;
        player2.numberOfCards = sizeOfDeck;
    }
    else if (player2.numberOfCards < 0)
    {
        player2.numberOfCards = 0;
        player1.numberOfCards = sizeOfDeck;
    }
    else
    {
        endingWar(player1, player2, deck1, deck2, counter, isVariantA,randomDeck,isSmartWar);
    }

}


void battle(int sizeOfDeck, player& player1, player& player2, int isVariantA, int& sumOfMovements,card randomDeck[],int isSmartWar)
{
    int numberOfMovements = 0;

    initialHands(player1, player2);
    while (player1.numberOfCards != 0 && player2.numberOfCards != 0)
    {
        int counterHelp = 0;
        numberOfMovements++;
        cout << endl << "PLAYER 1 \t \t";
        cout << "PLAYER 2" << endl;
        cout << player1.deck[0].rank << player1.deck[0].color << "\t \t \t \t";
        cout << player2.deck[0].rank << player2.deck[0].color << endl;
        sleep(SLEEP_TIME);
        if (player1.deck[0].value > player2.deck[0].value)
        {
            winning(player1, player2);
            cout << "Player 1 won a battle." << endl;
        }
        else if (player1.deck[0].value < player2.deck[0].value)
        {
            winning(player2, player1);
            cout << "Player 2 won a battle." << endl;
        }
        else//WAR
        {
            cout << endl << "          WAR" << endl << endl;
            if (isVariantA)
            {
                if (player1.numberOfCards < 3 || player2.numberOfCards < 3)
                {
                    if (player1.numberOfCards > player2.numberOfCards)
                    {
                        player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
                        player2.numberOfCards = 0;
                    }
                    else
                    {
                        player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
                        player1.numberOfCards = 0;
                    }
                }
                else
                {
                    numberOfMovements++;
                    int counter = 1;
                    player1.numberOfCards = player1.numberOfCards - 3;//player can lose 3 cards
                    player2.numberOfCards = player2.numberOfCards - 3;
                    war(sizeOfDeck, player1, player2, player1.deck + 2, player2.deck + 2, counter, isVariantA, numberOfMovements, counterHelp,randomDeck,isSmartWar);
                }
            }
            else//VariantB
            {
                int counter = 1;
                if (player1.numberOfCards == 1 || player1.numberOfCards == 2)
                {
                    if (player1.numberOfCards == 1)
                        numberOfMovements++;
                    counterHelp++;
                    variantB(player2, player1, counter);
                }
                else if (player2.numberOfCards == 1 || player2.numberOfCards == 2)
                {
                    if (player2.numberOfCards == 1)
                        numberOfMovements++;
                    counterHelp++;
                    variantB(player1, player2, counter);
                }
                player1.numberOfCards = player1.numberOfCards - 3;
                player2.numberOfCards = player2.numberOfCards - 3;
                war(sizeOfDeck, player1, player2, player1.deck + 2, player2.deck + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);

            }

        }
    }

    if (player1.numberOfCards > player2.numberOfCards)
        player1.numberOfCards = player1.numberOfCards + player2.numberOfCards;
    else if (player1.numberOfCards < player2.numberOfCards)
        player2.numberOfCards = player2.numberOfCards + player1.numberOfCards;
    ending(player1, player2, numberOfMovements, sumOfMovements);
}

void ending(player& player1, player& player2, int numberOfMovements, int& sumOfMovements)
{
    cout << "THE END" << endl;
    if (player1.numberOfCards == 0 && player2.numberOfCards != 0)
    {
        cout << "PLAYER 1 HAS LOST ALL CARDS" << endl;
        cout << "PLAYER 2 IS A WINNER";
        player2.numberOfWins++;
    }
    else if (player2.numberOfCards == 0 && player1.numberOfCards != 0)
    {
        cout << "PLAYER 2 HAS LOST ALL CARDS" << endl;
        cout << "PLAYER 1 IS A WINNER";
        player1.numberOfWins++;
    }
    else
        cout << "DRAW";
    cout << endl << numberOfMovements << " MOVEMENTS WERE MADE ";
    sumOfMovements = sumOfMovements + numberOfMovements;
}

void choosePlayerStrategy(player &player)
{
    int option = 1;
    cin >> option;
    switch (option) {
        case 1:
            player.strategy = randomStrategy;
            break;
        case 2:
            player.strategy = furiousStrategy;
            break;
        case 3:
            player.strategy = peacefulStrategy;
            break;
        default:
            break;
    }


}


void winning(player& winningPlayer, player& losingPlayer)//adding cards to winners hand
{
    card pomWinner = winningPlayer.deck[0];
    card pomLoser = losingPlayer.deck[0];
    moving(winningPlayer);
    winningPlayer.numberOfCards++;
    moving(losingPlayer);
    losingPlayer.numberOfCards--;
    winningPlayer.deck[winningPlayer.numberOfCards - 2] = pomWinner;
    winningPlayer.deck[winningPlayer.numberOfCards - 1] = pomLoser;

}

void moving(player& currentPlayer)
{
    for (int i = 0; i < currentPlayer.numberOfCards - 1; i++)
    {
        currentPlayer.deck[i] = currentPlayer.deck[i + 1];
    }
    clear(currentPlayer, 1);

}

void movingWar(player& winningPlayer, player& losingPlayer, int counter)
{
    for (int i = 0; i < ((counter * 2) + 1); i++)
    {
        card pomWinner = winningPlayer.deck[0];
        moving(winningPlayer);
        winningPlayer.numberOfCards++;
        winningPlayer.deck[winningPlayer.numberOfCards - 2 - i] = pomWinner;
    }
    for (int i = 0; i < ((counter * 2) + 1); i++)
    {
        card pomLoser = losingPlayer.deck[0];
        moving(losingPlayer);
        losingPlayer.numberOfCards--;
        winningPlayer.deck[winningPlayer.numberOfCards - (counter * 2 + 1 - i)] = pomLoser;

    }
}

void war(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int& counter, int isVariantA, int& numberOfMovements, int& counterHelp,card randomDeck[],int isSmartWar)
{

    if (!isVariantA)
        numberOfMovements++;
    if (deck1[0].value == deck2[0].value)
    {
        counter++;
        if (isVariantA)
        {
            variantA(sizeOfDeck, player1, player2, deck1, deck2, counter, isVariantA, numberOfMovements, randomDeck, isSmartWar);
        }
        else//VariantB
        {

            if (player2.numberOfCards == 0 && counterHelp == 1)
            {
                displayWar(player1, player2, deck1, deck2);
                cout << "Player 1 won a war." << endl;
            }
            else if (player1.numberOfCards == 0 && counterHelp == 1)
            {

                displayWar(player1, player2, deck1, deck2);
                cout << "Player 2 won a war." << endl;
            }
            else if (player1.numberOfCards == 0 || player1.numberOfCards == 1 || player2.numberOfCards == 0 || player2.numberOfCards == 1)
            {

                if ((player1.numberOfCards == 0 && player2.numberOfCards>4) || (player1.numberOfCards == 1 && player2.numberOfCards>2))
                {
                    numberOfMovements++;
                    if (player1.numberOfCards == 0)
                        numberOfMovements++;
                    player1.numberOfCards++;
                    variantB(player2, player1, counter);
                    player1.numberOfCards--;
                    displayWar(player1, player2, deck1, deck2);
                    cout << endl << "          WAR" << endl << endl;
                    player1.numberOfCards = player1.numberOfCards - 2;
                    player2.numberOfCards = player2.numberOfCards - 2;
                    war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
                }
                else if ((player2.numberOfCards == 0 && player1.numberOfCards>4) || (player2.numberOfCards == 1 && player1.numberOfCards>2))
                {
                    numberOfMovements++;
                    if (player2.numberOfCards == 0)
                        numberOfMovements++;
                    player2.numberOfCards++;
                    variantB(player1, player2, counter);
                    player2.numberOfCards--;
                    displayWar(player1, player2, deck1, deck2);
                    cout << endl << "          WAR" << endl << endl;
                    player1.numberOfCards = player1.numberOfCards - 2;
                    player2.numberOfCards = player2.numberOfCards - 2;
                    war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
                }


            }

            else
            {
                displayWar(player1, player2, deck1, deck2);
                cout << endl << "          WAR" << endl << endl;
                player1.numberOfCards = player1.numberOfCards - 2;
                player2.numberOfCards = player2.numberOfCards - 2;
                war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counterHelp, randomDeck, isSmartWar);
            }
        }
    }
    else if (player1.numberOfCards < 0)
    {
        player1.numberOfCards = 0;
        player2.numberOfCards = sizeOfDeck;
    }
    else if (player2.numberOfCards < 0)
    {
        player2.numberOfCards = 0;
        player1.numberOfCards = sizeOfDeck;
    }
    else
    {
        endingWar(player1, player2, deck1, deck2, counter, isVariantA,randomDeck,isSmartWar);
    }

}

void displayWar(player& player1, player& player2, card deck1[], card deck2[])
{
    cout << endl << "PLAYER 1\t \t";
    cout << "PLAYER 2" << endl;
    cout << deck1[0].rank << deck1[0].color << "\t \t \t \t";
    cout << deck2[0].rank << deck2[0].color << endl;
    sleep(SLEEP_TIME);
}

void variantA(int sizeOfDeck, player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, int& numberOfMovements,card randomDeck[],int isSmartWar)
{
    numberOfMovements++;
    if (player1.numberOfCards <= 1 || player2.numberOfCards <= 1)
    {
        endingWar(player1, player2, deck1, deck2, counter, isVariantA, randomDeck, isSmartWar);
    }
    else
    {
        displayWar(player1, player2, deck1, deck2);
        cout << endl << "          WAR" << endl << endl;
        player1.numberOfCards = player1.numberOfCards - 2;
        player2.numberOfCards = player2.numberOfCards - 2;
        war(sizeOfDeck, player1, player2, deck1 + 2, deck2 + 2, counter, isVariantA, numberOfMovements, counter,randomDeck,isSmartWar);
    }
}

void clear(player& currentPlayer, int number)
{
    currentPlayer.deck[currentPlayer.numberOfCards - number].value = 0;
    currentPlayer.deck[currentPlayer.numberOfCards - number].valueColor = 0;
    currentPlayer.deck[currentPlayer.numberOfCards - number].rank = 0;
    strcpy(currentPlayer.deck[currentPlayer.numberOfCards - number].color, "");
}

void variantB(player& winningPlayer, player& losingPlayer, int& counter)
{	if (losingPlayer.numberOfCards == 1){
        if (counter == 1){
            losingPlayer.deck[1] = winningPlayer.deck[1];
            losingPlayer.deck[2] = winningPlayer.deck[2];
            for (int i = 1; i < (winningPlayer.numberOfCards - 2); i++)
                winningPlayer.deck[i] = winningPlayer.deck[i + 2];
            clear(winningPlayer, 1);
            clear(winningPlayer, 2);
            losingPlayer.numberOfCards = losingPlayer.numberOfCards + 2;
            winningPlayer.numberOfCards = winningPlayer.numberOfCards - 2;
        }
        else{
            losingPlayer.deck[counter * 2 - 1] = winningPlayer.deck[counter * 2 - 1];
            losingPlayer.deck[counter * 2] = winningPlayer.deck[counter * 2];
            for (int i = counter * 2; i < (winningPlayer.numberOfCards + 2); i++)
                winningPlayer.deck[i - 1] = winningPlayer.deck[i + 1];
            clear(winningPlayer, -1);
            clear(winningPlayer, -2);
            losingPlayer.numberOfCards = losingPlayer.numberOfCards + 2;
            winningPlayer.numberOfCards = winningPlayer.numberOfCards - 2;
        }
    }
    else if (losingPlayer.numberOfCards == 2){
        if (counter == 1){
            losingPlayer.deck[2] = winningPlayer.deck[2];
            for (int i = 1; i < (winningPlayer.numberOfCards - 2); i++)
                winningPlayer.deck[i + 1] = winningPlayer.deck[i + 2];
            clear(winningPlayer, 1);
            losingPlayer.numberOfCards = losingPlayer.numberOfCards + 1;
            winningPlayer.numberOfCards = winningPlayer.numberOfCards - 1;
        }
        else{
            losingPlayer.deck[counter * 2] = winningPlayer.deck[counter * 2];
            for (int i = counter * 2; i < (winningPlayer.numberOfCards + 2); i++)
                winningPlayer.deck[i] = winningPlayer.deck[i + 1];
            clear(winningPlayer, -2);
            losingPlayer.numberOfCards = losingPlayer.numberOfCards + 1;
            winningPlayer.numberOfCards = winningPlayer.numberOfCards - 1;
        }
    }

}
void endingWar(player& player1, player& player2, card deck1[], card deck2[], int counter, int isVariantA, card randomDeck[], int isSmartWar)
{
    if (deck1[0].value > deck2[0].value){
        player1.numberOfCards = player1.numberOfCards + (2 * counter + 1);
        player2.numberOfCards = player2.numberOfCards + (2 * counter + 1);
        displayWar(player1, player2, deck1, deck2);
        if (isSmartWar) {
            randomAdding(player1, player2, counter, randomDeck);
        }
        else
            movingWar(player1, player2, counter);
        cout << "Player 1 won a war." << endl;
    }
    else if (deck1[0].value < deck2[0].value){
        player1.numberOfCards = player1.numberOfCards + (2 * counter + 1);
        player2.numberOfCards = player2.numberOfCards + (2 * counter + 1);
        displayWar(player1, player2, deck1, deck2);
        if (isSmartWar) {
            randomAdding(player2, player1, counter, randomDeck);
        }
        else
            movingWar(player2, player1, counter);
        cout << "Player 2 won a war." << endl;
    }
    else if (deck1[0].value == deck2[0].value && isVariantA){
        displayWar(player1, player2, deck1, deck2);
        if (player1.numberOfCards > player2.numberOfCards){
            cout << "Player 1 won a war." << endl;
            player2.numberOfCards = 0;
        }
        else if (player1.numberOfCards < player2.numberOfCards){
            cout << "Player 2 won a war." << endl;
            player1.numberOfCards = 0;
        }
        else if ((player1.numberOfCards == 0 && player2.numberOfCards == 0) || (player1.numberOfCards == 1 && player2.numberOfCards == 1)){
            player1.numberOfCards = 0;
            player2.numberOfCards = 0;
            cout << "DRAW";
        }

    }
}


void zeroing(card array[])
{
    for (int i = 0; i < MAX_SIZE_OF_DECK; i++) {
        strcpy(array[i].color, "");
        array[i].rank = 0;
        array[i].value = 0;
        array[i].valueColor = 0;
    }
}


int valueOfStartingDeck(card* deck, int sizeOfDeck)
{
    int value = 0;
    for (int i = 0; i < sizeOfDeck / 2; i++)
    {
        int cardValue = deck[i].value;
        if (cardValue != 0)
        {
            if ((sizeOfDeck / NUMBER_OF_COLORS) % 2 == 1)
                value += cardValue + (sizeOfDeck - MAX_SIZE_OF_DECK) / (2 * NUMBER_OF_COLORS) - 7;
            else {

                if (cardValue < ((MAX_SIZE_OF_DECK - 4 - sizeOfDeck) / (2 * NUMBER_OF_COLORS) + 8))
                    value += cardValue + (sizeOfDeck - (MAX_SIZE_OF_DECK - 4)) / (2 * NUMBER_OF_COLORS) - 8;
                else
                    value += cardValue + (sizeOfDeck - (MAX_SIZE_OF_DECK - 4)) / (2 * NUMBER_OF_COLORS) - 7;
            }
        }
    }
    return value;
}