src/card/card.cpp

/**********************************************************************
 *
 *   FreeDoko a Doppelkopf-Game
 *
 *   Copyright (C) 2001 – 2018 by Diether Knof and Borg Enders
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License as
 *   published by the Free Software Foundation; either version 2 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *   You can find this license in the file 'gpl.txt'.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 *
 *  Contact:
 *    Diether Knof dknof@posteo.de
 *
 *********************************************************************/

#include "constants.h"
#include "card.h"

#include "hand_card.h"
#include "../game/game.h"
#include "../party/rule.h"

Card const Card::empty{};
Card const Card::unknown(Card::unknowncardcolor, Card::unknowncardvalue);
Card const Card::fox(Card::diamond, Card::ace);
Card const Card::dulle(Card::heart, Card::ten);
Card const Card::charlie(Card::club, Card::jack);
Card const Card::club_ace(Card::club, Card::ace);
Card const Card::spade_ace(Card::spade, Card::ace);
Card const Card::heart_ace(Card::heart, Card::ace);
Card const Card::diamond_ace(Card::diamond, Card::ace);
Card const Card::club_ten(Card::club, Card::ten);
Card const Card::spade_ten(Card::spade, Card::ten);
Card const Card::heart_ten(Card::heart, Card::ten);
Card const Card::diamond_ten(Card::diamond, Card::ten);
Card const Card::club_king(Card::club, Card::king);
Card const Card::spade_king(Card::spade, Card::king);
Card const Card::heart_king(Card::heart, Card::king);
Card const Card::diamond_king(Card::diamond, Card::king);
Card const Card::club_queen(Card::club, Card::queen);
Card const Card::spade_queen(Card::spade, Card::queen);
Card const Card::heart_queen(Card::heart, Card::queen);
Card const Card::diamond_queen(Card::diamond, Card::queen);
Card const Card::club_jack(Card::club, Card::jack);
Card const Card::spade_jack(Card::spade, Card::jack);
Card const Card::heart_jack(Card::heart, Card::jack);
Card const Card::diamond_jack(Card::diamond, Card::jack);
Card const Card::club_nine(Card::club, Card::nine);
Card const Card::spade_nine(Card::spade, Card::nine);
Card const Card::heart_nine(Card::heart, Card::nine);
Card const Card::diamond_nine(Card::diamond, Card::nine);

/** -> result
 **
 ** @param    color_name   name of the color
 **
 ** @return   color 'name'
 **/
Card::Color
Card::color(string const& color_name)
{
  if (color_name == to_string(Card::club))
    return Card::club;
  else if (color_name == to_string(Card::spade))
    return Card::spade;
  else if (color_name == to_string(Card::heart))
    return Card::heart;
  else if (color_name == to_string(Card::diamond))
    return Card::diamond;
  else
    DEBUG_ASSERTION(false,
                    "Card::color(color_name):\n"
                    "  color '" << color_name << "' unknown");

  return Card::nocardcolor;
} // static Card::Color Card::color(string color_name)

/** -> result
 **
 ** @param    value_name   name of the value
 **
 ** @return   value 'name'
 **/
Card::Value
Card::value(string const& value_name)
{
  if (value_name == to_string(Card::nine))
    return Card::nine;
  else if (value_name == to_string(Card::jack))
    return Card::jack;
  else if (value_name == to_string(Card::queen))
    return Card::queen;
  else if (value_name == to_string(Card::king))
    return Card::king;
  else if (value_name == to_string(Card::ten))
    return Card::ten;
  else if (value_name == to_string(Card::ace))
    return Card::ace;
  else
    DEBUG_ASSERTION(false,
		    "Card::value(value_name):\n"
		    "  value '" << value_name << "' unknown");

  return nocardvalue;
} // static Card::Value Card::value(string value_name)

/** constructor
 ** reads 'color' and 'value' from 'name'
 **
 ** @param    name   the card name
 **/
Card::Card(string const& name)
{
  istringstream istr(name);
  this->read(istr);
} // Card::Card(string name)

/** read the card from the stream
 **
 ** @param    istr   stream to read the card from
 **
 ** @return   stream
 **/
istream&
Card::read(istream& istr)
{
  Color color;
  Value value;
  istr >> color >> value;
  *this = Card(color, value);
  return istr;
} // istrean& Card::read(istream& istr)

/** -> result
 ** This value is used to use 'vector<.>' instead of 'map<Card, .>'
 ** because of performance reasons (~15% better when using in 'CardCounter')
 **
 ** @return   integer value of the card
 **/
int
Card::to_int() const noexcept
{
  if (this->color() == nocardcolor)
    return 0;
  switch (this->value()) {
  case Card::nocardvalue:
  case Card::unknowncardvalue:
    return 0;
  case Card::nine:
    return (this->color() * 6 + 1);
  case Card::jack:
    return (this->color() * 6 + 2);
  case Card::queen:
    return (this->color() * 6 + 3);
  case Card::king:
    return (this->color() * 6 + 4);
  case Card::ten:
    return (this->color() * 6 + 5);
  case Card::ace:
    return (this->color() * 6 + 6);
  }; // switch (this->value())

  return 0;
} // int Card::to_int() const

/** -> result
 **
 ** @param    game   the game
 **
 ** @return   the tcolor of the card
 **/
Card::TColor
Card::tcolor(Game const& game) const
{
  if (this->istrump(game))
    return Card::trump;
  else
    return this->color();
} // Card::TColor Card::tcolor(Game game) const

/** -> result
 **
 ** @param    game   the game
 **
 ** @return   true if card is trump in the game
 **/
bool
Card::istrump(Game const& game) const
{
  return this->istrump(game.type(), game.rule()(Rule::Type::dullen));
} // bool Card::istrump(Game game) const

/** -> result
 **
 ** @param    gametype   the gametype
 ** @param    dullen   whether dullen are allowed
 **
 ** @return   true if card is trump in the game
 **/
bool
Card::istrump(GameType const gametype, bool const dullen) const
{
  if (this->isdulle(gametype, dullen))
    return true;

  switch (gametype) {
  case GameType::thrown_nines:
    return (this->value() == nine);
  case GameType::thrown_kings:
    return (this->value() == king);
  case GameType::thrown_nines_and_kings:
    return (   (this->value() == nine)
            || (this->value() == king) );
  case GameType::thrown_richness:
    return true;
  case GameType::normal:
  case GameType::poverty:
  case GameType::fox_highest_trump:
  case GameType::redistribute:
  case GameType::genscher:
  case GameType::marriage:
  case GameType::marriage_solo:
  case GameType::marriage_silent:
  case GameType::solo_diamond:
    return (   (this->color() == diamond)
            || (this->value() == jack)
            || (this->value() == queen) );
  case GameType::solo_jack:
    return (this->value() == jack);
  case GameType::solo_queen:
    return (this->value() == queen);
  case GameType::solo_king:
    return (this->value() == king);
  case GameType::solo_queen_jack:
    return (   (this->value() == jack)
            || (this->value() == queen) );
    break;
  case GameType::solo_king_jack:
    return (   (this->value() == jack)
            || (this->value() == king) );
  case GameType::solo_king_queen:
    return (   (this->value() == queen)
            || (this->value() == king) );
  case GameType::solo_koehler:
    return (   (this->value() == jack)
            || (this->value() == queen)
            || (this->value() == king) );
  case GameType::solo_club:
    return (   (this->color() == club)
            || (this->value() == jack)
            || (this->value() == queen) );
  case GameType::solo_heart:
    return (   (this->color() == heart)
            || (this->value() == jack)
            || (this->value() == queen) );
  case GameType::solo_spade:
    return (   (this->color() == spade)
            || (this->value() == jack)
            || (this->value() == queen) );
  case GameType::solo_meatless:
    return false;
  } // switch(gametype)

  return false;
} // bool Card::istrump(GameType gametype, bool dullen) const

/** -> result
 **
 ** @param    game   the game
 **
 ** @return   true if card is a dulle
 **/
bool
Card::isdulle(Game const& game) const
{
  return this->isdulle(game.type(), game.rule()(Rule::Type::dullen));
} // bool Card::isdulle(Game game) const

/** -> result
 **
 ** @param    gametype   the gametype
 ** @param    dullen   whether dullen are allowed
 **
 ** @return   true if card is a dulle
 **/
bool
Card::isdulle(GameType const gametype, bool const dullen) const
{
  if (!dullen)
    return false;

  if (*this != Card::dulle)
    return false;

  switch (gametype) {
  case GameType::normal:
  case GameType::poverty:
  case GameType::genscher:
  case GameType::marriage:
  case GameType::marriage_solo:
  case GameType::marriage_silent:
  case GameType::solo_club:
  case GameType::solo_heart:
  case GameType::solo_spade:
  case GameType::solo_diamond:
    return true;
  case GameType::solo_meatless:
  case GameType::solo_jack:
  case GameType::solo_queen:
  case GameType::solo_king:
  case GameType::solo_queen_jack:
  case GameType::solo_king_jack:
  case GameType::solo_king_queen:
  case GameType::solo_koehler:
  case GameType::thrown_nines:
  case GameType::thrown_kings:
  case GameType::thrown_nines_and_kings:
  case GameType::thrown_richness:
  case GameType::fox_highest_trump:
  case GameType::redistribute:
    return false;
  } // switch (gametype)

  return false;
} // bool Card::isdulle(GameType gametype, bool dullen) const

/** -> result
 **
 ** @note   if both cards are equal, the first (this) is not less than
 **   the second (card)
 **   (but the dullen -- see rules)
 **
 ** @param    card   the card to compare with
 **
 ** @return   true, if the card is less than 'b', else false
 **
 ** @todo       is this function still called?
 **/
bool
Card::less(HandCard const& card) const
{
  if (card.is_empty())
    return false;

  if (card.possible_hyperswine())
    return (*this != card);
  if (   card.game().swines().hyperswines_announced()
      && (*this == card.game().cards().hyperswine()))
      return false;
  if (card.possible_swine())
    return (*this != card);

  return card.game().cards().less(*this, card);
} // bool HandCard::less(Card card) const

/** -> result
 **
 ** @param    tcolor              tcolor
 ** @param    marriage_selector   marriage selector
 **
 ** @result    whether the marriage is determined by a 'tcolor'-trick
 **/
bool
is_selector(Card::TColor const tcolor,
            MarriageSelector const marriage_selector)
{
  switch (marriage_selector) {
  case MarriageSelector::team_set:
  case MarriageSelector::silent:
    return false;
  case MarriageSelector::first_foreign:
    return true;
  case MarriageSelector::first_trump:
    return (tcolor == Card::trump);
  case MarriageSelector::first_color:
    return (tcolor != Card::trump);
  case MarriageSelector::first_club:
    return (tcolor == Card::club);
  case MarriageSelector::first_spade:
    return (tcolor == Card::spade);
  case MarriageSelector::first_heart:
    return (tcolor == Card::heart);
  } // switch (marriage_selector)

  return false;
} // bool is_selector(Card::TColor tcolor, MarriageSelector marriage_selector)

/** @return   the corresponding single picture solo
 **/
GameType
solo(Card::Value const picture) noexcept
{
  switch (picture) {
  case Card::jack:
    return GameType::solo_jack;
  case Card::queen:
    return GameType::solo_queen;
  case Card::king:
    return GameType::solo_king;
  default:
    DEBUG_ASSERTION(false,
                    "solo(picture = " << picture << ")\n"
                    "   no picture");
    return GameType::normal;
  }
}

/** @return   the corresponding color solo
 **/
GameType
solo(Card::Value const picture1, Card::Value const picture2) noexcept
{
  if (picture1 == Card::jack  && picture2 == Card::queen)
    return GameType::solo_queen_jack;
  if (picture2 == Card::jack  && picture1 == Card::queen)
    return GameType::solo_queen_jack;
  if (picture1 == Card::jack  && picture2 == Card::king)
    return GameType::solo_king_jack;
  if (picture2 == Card::jack && picture1 == Card::king)
    return GameType::solo_king_jack;
  if (picture1 == Card::queen  && picture2 == Card::king)
    return GameType::solo_king_queen;
  if (picture2 == Card::queen && picture1 == Card::king)
    return GameType::solo_king_queen;
  DEBUG_ASSERTION(false,
                  "solo(picture1 = " << picture1 << ", picture2 = " << picture2 << ")\n"
                  "   picture1 and picture2 no pictures or equal");
  return GameType::normal;
}

/** @return   the corresponding color solo
 **/
GameType
solo(Card::Color const color) noexcept
{
  switch (color) {
  case Card::club:
    return GameType::solo_club;
  case Card::spade:
    return GameType::solo_spade;
  case Card::heart:
    return GameType::solo_heart;
  case Card::diamond:
    return GameType::solo_diamond;
  default:
    DEBUG_ASSERTION(false,
                    "solo(color = " << color << ")\n"
                    "   no color");
    return GameType::normal;
  }
}

/** -> result
 **
 ** @param    value   card value
 **
 ** @return   name of the value
 **/
string
to_string(Card::Value const value) noexcept
{
  switch(value) {
  case Card::nine:
    return "nine";
    (void)_("Card::Value::nine");
  case Card::jack:
    return "jack";
    (void)_("Card::Value::jack");
  case Card::queen:
    return "queen";
    (void)_("Card::Value::queen");
  case Card::king:
    return "king";
    (void)_("Card::Value::king");
  case Card::ten:
    return "ten";
    (void)_("Card::Value::ten");
  case Card::ace:
    return "ace";
    (void)_("Card::Value::ace");
  case Card::nocardvalue:
    return "no card value";
    (void)_("Card::Value::no card value");
  case Card::unknowncardvalue:
    return "unknown card value";
    (void)_("Card::Value::unknown card value");
  } // switch(value)

  return {};
} // string to_string(Card::Value value)

/** -> result
 **
 ** @param    tcolor   card tcolor
 **
 ** @return   name of the tcolor
 **/
string
to_string(Card::TColor const tcolor) noexcept
{
  switch(tcolor) {
  case Card::club:
    return "club";
    (void)_("Card::Color::club");
  case Card::spade:
    return "spade";
    (void)_("Card::Color::spade");
  case Card::heart:
    return "heart";
    (void)_("Card::Color::heart");
  case Card::diamond:
    return "diamond";
    (void)_("Card::Color::diamond");
  case Card::trump:
    return "trump";
    (void)_("Card::Color::trump");
  case Card::nocardcolor:
    return "no card color";
    (void)_("Card::Color::no card color");
  case Card::unknowncardcolor:
    return "unknown card color";
    (void)_("Card::Color::unknown card color");
  } // switch(tcolor)

  return {};
} // string to_string(Card::TColor tcolor)

/** @result    the name of the card
 **/
string
to_string(Card const& card) noexcept
{
  if (card.is_empty())
    return "empty";
  else if (card.is_unknown())
    return "unknown";
  else
    return (to_string(card.color()) + " " + to_string(card.value()));
} // string to_string(Card card)

/** translation
 **
 ** @param    value   card value
 **
 ** @return   translation
 **/
string
gettext(Card::Value const value)
{
  return gettext("Card::Value::" + to_string(value));
}

/** translation
 **
 ** @param    color   card color
 **
 ** @return   translation
 **/
string
gettext(Card::Color const color)
{
  return gettext("Card::Color::" + to_string(color));
}

/** translation
 **
 ** @param    value   card value
 **
 ** @return   translation
 **/
string
gettext(Card const& card)
{
  // gettext: %t = color, %t = value
  return _("Card::%t %t",
           _(card.color()), _(card.value()));
}

/** -> result
 **
 ** @param    lhs   left hand side
 ** @param    rhs   right hand side
 **
 ** @return   whether 'lhs' is greater than 'rhs'
 **          (in the order: 'club', 'spade', 'heart', 'diamond'
 **/
bool
operator>(Card::Color const lhs, Card::Color const rhs)
{
  switch (lhs) {
  case Card::club:
    return (   (rhs == Card::spade)
            || (rhs == Card::heart)
            || (rhs == Card::diamond) );
  case Card::spade:
    return (   (rhs == Card::heart)
            || (rhs == Card::diamond) );
  case Card::heart:
    return (rhs == Card::diamond);
  case Card::diamond:
    return false;
  default:
    DEBUG_ASSERTION(false,
                    "operator>(lhs, rhs): illegal value");

    break;
  } // switch (lhs)

  return false;
} // bool operator>(Card::Color lhs, Card::Color rhs)

/** writes the card value in the output stream
 **
 ** @param    ostr    output stream
 ** @param    value   card value
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Card::Value const value)
{
  return (ostr << to_string(value));
} // ostream& operator<<(ostream& ostr, Card::Value value);

/** read the card value out of the stream
 **
 ** @param    istr    input stream
 ** @param    value   card value
 **
 ** @return   output stream
 **/
istream&
operator>>(istream& istr, Card::Value& value)
{
  string value_name;
  istr >> value_name;

  value = Card::value(value_name);

  return istr;
} // istream& operator>>(istream& istr, Card::Value& value);

/** writes the card color in the output stream
 **
 ** @param    ostr     output stream
 ** @param    tcolor   card color
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Card::TColor const tcolor)
{
  return (ostr << to_string(tcolor));
} // ostream& operator<<(ostream& ostr, Card::TColor tcolor);

/** read the card color out of the stream
 **
 ** @param    istr    input stream
 ** @param    color   card color
 **
 ** @return   output stream
 **/
istream&
operator>>(istream& istr, Card::Color& color)
{
  string color_name;
  istr >> color_name;
  color = Card::color(color_name);

  return istr;
} // istream& operator>>(istream& istr, Card::Color& color);

/** writes the card in the output stream
 **
 ** @param    ostr   output stream
 ** @param    card   card
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Card const& card)
{
  return (ostr << to_string(card));
} // ostream& operator<<(ostream& ostr, Card const& card);

/** read the card out of the stream
 **
 ** @param    istr   input stream
 ** @param    card   card
 **
 ** @return   output stream
 **/
istream&
operator>>(istream& istr, Card& card)
{
  return card.read(istr);
} // istream& operator>>(istream& istr, Card& card);