chili pill's code ported to windows

#include "kickstart.core.hpp"   //! card suit symbols.  https://github.com/alf-p-steinbach/kickstart>

// Machinery to support a simple find/replace editing to replace cout output with UTF-8 ks::output:
const struct Ostream_hack {} utf8_out;

template< class T >
inline auto operator<<( const Ostream_hack o, const T& value )
    -> Ostream_hack
{
    using namespace kickstart;
    output( ""s << value );
    return o;
}

#include <time.h>       //! for ::time

#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>

enum Suit {SPADES , DIAMONDS, CLUBS, HEARTS};

const unsigned int JACK = 11, QUEEN = 12, KING = 13, ACE = 14;

class Card {
  private:
     unsigned int number;
     Suit suit;

  public:

     Card(unsigned int n, Suit s) : number(n), suit(s) {}

     Card () {}

     void showCard() const;

     Suit getSuit() const;

     void setCard(unsigned int n, Suit s);

     bool operator > (const Card &c) const;

     bool operator == (const Card &c) const;

     bool isEqual (const Card &c) const;

};

void Card:: showCard() const {
   if(number >= 5 && number <= 10)
         utf8_out << number ;

   else
      switch (number) {
      case JACK: utf8_out << 'J'; break;
      case QUEEN: utf8_out << 'Q'; break;
      case KING: utf8_out << 'K'; break;
      case ACE: utf8_out << 'A'; break;
     }

   switch (suit) {
   case SPADES: utf8_out << "♠ "; break;
   case DIAMONDS: utf8_out << "♦ "; break;
   case HEARTS: utf8_out << "♥ "; break;
   case CLUBS: utf8_out << "♣ "; break;
     }
}


bool Card:: operator > (const Card &c) const {
    if(suit == c.suit) {
     return  (number > c.number) ? true: false;
    }

    return false;
}

Suit Card:: getSuit() const {
  return suit;
}

void Card:: setCard(unsigned int n, Suit s) {
    number = n;
    suit = s;
}

bool Card:: operator == ( const Card &c) const {
    return (suit == c.suit) ? true : false;
}

bool Card:: isEqual(const Card &c) const {
    return (number == c.number && suit == c.suit) ? true : false;
}

void showDeck(Card []);
void shuffleCards(Card []);
void setCards(Card []);
void sortCards(std:: vector<Card> &);
//if is Cpu turn after player plays
int play(Card &, std:: vector<Card> & );

//if is cpu wins
int play(std:: vector<Card> &);

//check if player has a similar card suit

bool haveSimilarSuitCard(const Card &card , std:: vector<Card> &cards) {
  for(auto c : cards) {
       if(card == c ) {
            return true;
        }
     }

     return false;
}

void showPlayerCards(std:: vector<Card> & cards) {
  for(auto c : cards)
      c.showCard();
  utf8_out << '\n';
}


int main() {

///////////////////////////////////////////
    Card deck[40];

    setCards(deck);

   // showDeck(deck);
///////////////////////////////////////////
    //utf8_out << "\nShuffled Cards\n\n";
    shuffleCards(deck);

   // showDeck(deck);

///////////////////////////////////////////
/* Share cards */
    std:: vector<Card> player1 (std:: begin(deck), std:: begin(deck) + 5);
    /*first 5 cards go to player 1*/
    std:: vector<Card> player2 (std:: begin(deck)+5, std:: begin(deck) + 10);
    /*second 5 cards go to player 2*/

   utf8_out << "\n";
  // utf8_out << "Player 1 cards : ";
 //  showPlayerCards(player1);
  // utf8_out << "Player 2 cards : ";
   //showPlayerCards(player2);

   utf8_out << "S P A\n";

 utf8_out << "\n----------------------------------------------------\n";

     utf8_out << "The game is simple each player is dealt with 5 cards the player who presents the card with higher suit and already leading in the last round wins, it doesn't matter if you are winning the last round is all that matters....\nAlso if a player plays card you have to play a card with similar suit otherwise 'Way3 Ogba!!!' in my local language means you have violated a crucial rule but dont worry the system does not allow you to make such mistakes...\n";

     utf8_out << "------------------------------------------------------\n";

     utf8_out << "NOTE: after you choose a card, that card is popped out of sight so entering same number on different occasions will choose another card :)\n\nNOTE :.//Count the position of your cards and enter it position\n";

    PlayersTurn:
    do {
      int choose;
     utf8_out << "\nYour cards : ";
      showPlayerCards(player1);
      utf8_out << "Enter number to choose card : ";
      std:: cin >> choose;
      if(choose < 1 || choose > player1.size()){
        std:: cerr << "Number out of bounds\n";
        continue;
      }
      //user enters correct number
      else  {
          Card card1 = player1[choose - 1];
        utf8_out << "\nPlayer 1 card : ";  card1.showCard(); utf8_out << '\n';
          player1.erase(player1.begin() + (choose-1));
          int p = play(card1, player2);
          Card card2 = player2[p];
         utf8_out << "Player 2 card : "; card2.showCard();
          player2.erase(player2.begin() + p);
          utf8_out << '\n';

          if(card2 > card1) {
               if(player2.size() == 0) {
                 //then game is over
                 utf8_out << "\nPlayer 2 wins...  GAME OVER!";
                 return EXIT_SUCCESS;
               }
                goto player2Leads;
          }
      }
   }

   while(player1.size() != 0);

   utf8_out << "\nPlayer 1 wins... GAME OVER\n";
   return EXIT_SUCCESS;

   player2Leads:
       utf8_out << "\n\nPlayer 2 wins this round by presenting a more stronger card suit, but this game is not over :) yet, you now have 5% chance of winning unless maybe you want to prove me wrong 😂😂\n\n\n";

   do {
      utf8_out << "Player 2 plays : ";
          int p = play(player2);
          Card card2 = player2[p];
          card2.showCard();
          player2.erase(player2.begin() + p);
   player1Turn:
          int choose;
          utf8_out << "\n\nYour cards : ";
          showPlayerCards(player1);
          utf8_out << "Enter number to choose card : ";
          std:: cin >> choose;

          if(choose < 1 || choose > player1.size()) {
          std:: cerr << "Number out of bounds\n";
            goto player1Turn;
          }

        else {
          Card card1 = player1[choose - 1];

          if(!(card1 == card2)) {
            if(haveSimilarSuitCard(card2, player1)) {
              utf8_out << "\nYou have a card with similar Card suit, sorry! You have to bring it out\n";

              goto player1Turn;
            }
          }

         utf8_out << "\nPlayer 2 card : "; card2.showCard();
       utf8_out << "\nPlayer 1 card : "; card1.showCard(); utf8_out << "\n";


       player1.erase(player1.begin() + (choose-1));
          utf8_out << '\n';
     if(card1 > card2)  {
               if(player1.size() == 0){

    utf8_out << "Phew! very lucky you won in the last round, GOOD LUCK   Player 1 wins... GAME OVER!";
                return EXIT_SUCCESS;
             }
                 else { utf8_out << "\nCongratulations on winning this round, you are on your road to victory, keep maintaning your victory by making good choices or should i say guessess!😂😂\n\n";
                  goto PlayersTurn;
                }
             }
          }
      }

      while(player1.size() != 0);

      utf8_out << "\nPlayer 2 wins... GAME OVER\n";
   return EXIT_SUCCESS;

}

void showDeck(Card deck[]) {
  for(size_t j = 0; j < 40; ++j) {
        deck[j].showCard();
        if(((j+1)%10) == 0) utf8_out << '\n';
    }
}

void shuffleCards(Card deck[]) {
     std:: srand(int(time(NULL)));      //! cast

    for(size_t j = 0; j < 40; ++j) {
        int r = rand() % 40;
        std:: swap(deck[j],deck[r]);
    }
}

void sortCards(std:: vector<Card> &cards) {
  for(int x = 1; x < cards.size(); ++x) {
    for(int y = 0; y <= x; ++y) {
       if(cards[y] > cards[x]) {
         std:: swap(cards[y], cards[x]);
       }
    }
  }
}

void setCards(Card deck[]) {
    for(size_t j = 0; j < 40; ++j) {
     deck[j].setCard((j%10)+5, Suit((j/10)));
    }
}

int play(Card &card, std:: vector<Card> &player2) {
     bool containsSuit = false;
     std:: vector<Card> possibleCards;

    for(auto c : player2) {
       //if player2 has cards with common suit store in possible cards
        if(c == card) {
          possibleCards.push_back(c);
          containsSuit = true;
       }
    }


    if(containsSuit) {

    sortCards(possibleCards);

     for(size_t j = 0; j < possibleCards.size(); ++j ) {
     if(possibleCards[j] > card) {
    auto f = std:: find(player2.begin(), player2.end(), possibleCards[j]);

      return int(f - player2.begin());      //! cast
    }
 }


 std:: srand(int(time(NULL)));      //! cast -- also dubious, a second call of srand.


      //if no better card was found

        int size = int( possibleCards.size() );     //! cast


        int randomCard = std:: rand() % size;

        auto f = std:: find(player2.begin(), player2.end(), possibleCards[randomCard]);

        return int(f - player2.begin());        //! cast

      }


  //if no such card of the same suit is found
    int size = int(player2.size());         //! cast

   int randomCard = std:: rand() % size;

     auto f = std:: find(player2.begin(), player2.end(), player2[randomCard]);

       return int(f - player2.begin());     //! cast
}

int play(std:: vector<Card> &player2) {
    std:: srand(int(time(NULL)));           //! cast
    size_t size = player2.size();
    int r = std:: rand() % size;

    return (r);
}