src/game/marriage.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 "game.h"

#include "gameplay.h"
#include "gameplay_actions/marriage.h"
#include "gameplay_actions/genscher.h"

#include "../party/rule.h"
#include "../player/player.h"
#include "../card/trick.h"
#include "../ui/ui.h"

/** constructor
 **
 ** @param    game   corresponding game
 **/
GameMarriage::GameMarriage(Game& game) noexcept :
  game_(&game)
{ }

/** constructor
 **
 ** @param    marriage   marriage to copy
 ** @param    game   corresponding game
 **/
GameMarriage::GameMarriage(GameMarriage const& marriage, Game& game) noexcept :
  game_(&game),
  selector_(marriage.selector_),
  determination_trickno_(marriage.determination_trickno_)
{ }

/** @return   the marriage selector
 **/
MarriageSelector
GameMarriage::selector() const noexcept
{ return this->selector_; }

/** @return   the tricknumber, the marriage was determined
 **/
unsigned
GameMarriage::determination_trickno() const noexcept
{ return this->determination_trickno_; }

/** test, whether a genscher is played
 **
 ** @param    played_card   the played card
 **/
void
GameMarriage::check_for_genscher(HandCard const& played_card)
{
  auto& game = *this->game_;
  auto const& rule = game.rule();

  if (!rule(Rule::Type::genscher))
    return ;

  if (   ::is_solo(game.type())
      || (game.type() == GameType::poverty))
    return ;

  if (!played_card.istrumpking())
    return ;

  if (game.players().current_player().hand().count_trump_kings()
      != rule(Rule::Type::number_of_same_cards))
    return ;

  Player const* const genscher_partner
    = game.players().current_player().genscher_partner();

  if (!genscher_partner)
    return ;

  game.players().set_soloplayer(game.players().current_player());
  auto const& soloplayer = game.players().soloplayer();
  // set the teams: 're' for the genscher players, 'contra' for the others
  for (auto& p : game.players()) {
    auto const team = ( (   (p == game.players().current_player())
                         || (p == *genscher_partner))
                       ? Team::re
                       : Team::contra);
    game.teaminfo_.set(p, team);
    p.set_team(team);
  } // for (p : this->player)
  game.set_type(GameType::genscher);

  game.announcements().remove_all_but_re_contra();

  // tell all players about the genscher
  for (auto& p : game.players())
    p.genscher(game.players().current_player(), *genscher_partner);

  game.gameplay_->gameplay_action(GameplayActions::Genscher(soloplayer.no(),
                                                            genscher_partner->no()));
  if (!game.isvirtual()) {
    ::ui->genscher(soloplayer, *genscher_partner);
    this->signal_genscher_(soloplayer, *genscher_partner);
    ::ui->gameplay_action(GameplayActions::Genscher(soloplayer.no(),
                                                    genscher_partner->no()));
    game.signal_gameplay_action_(GameplayActions::Genscher(soloplayer.no(),
                                                           genscher_partner->no()));
  }
} // void GameMarriage::check_for_genscher(HandCard played_card)


/** test, whether a silent marriage is played
 **
 ** @return
 **/
void
GameMarriage::check_for_silent_marriage()
{
  if (::game_status == GameStatus::game_redistribute)
    return ;

  DEBUG_ASSERTION((::game_status == GameStatus::game_reservation),
                  "GameMarriage::check_for_silent_marriage()\n"
                  "  game status is not 'reservation' "
                  "but '" << ::game_status << "'");

  auto& game = *this->game_;
  auto const& rule = game.rule();

  if (game.type() != GameType::normal)
    return ;

  for (auto& p : game.players()) {
    if (p.hand().count_club_queens()
        == rule(Rule::Type::number_of_same_cards)) {
      game.players().set_soloplayer(p);
      game.set_type(GameType::marriage_silent);
      this->selector_ = MarriageSelector::silent;
      this->determination_trickno_ = UINT_MAX;
      break;
    } // if (silent marriage)
  } // for (p : game.players())
} // void GameMarriage::check_for_silent_marriage()

/** test, if the silent marriage is solved
 **/
void
GameMarriage::determine_silent_marriage()
{
  auto& game = *this->game_;
  auto const& rule = game.rule();

  if (   (game.type_ != GameType::marriage_silent)
      || (this->selector() != MarriageSelector::silent))
    return ;

  // whether the silent marriage is known to all
  bool solved = false;

  { // check whether both club queens have been played
    if (game.cards().count_played(Card::club_queen)
        == rule(Rule::Type::number_of_same_cards) )
      solved = true;
  } // check whether both club queens have been played

  { // check whether all other players are known to be contra
    unsigned contra_no = 0;
    for (auto& p : game.players())
      if (game.teaminfo().get(p) == Team::contra)
        contra_no += 1;

    if (contra_no == game.playerno() - 1)
      solved = true;
  } // check whether all other players are known to be contra

  if (solved) {
    this->selector_ = MarriageSelector::team_set;
    this->determination_trickno_ = game.tricks().current_no();
  } // if (solved)
} // void GameMarriage::determine_silent_marriage()

/** test, if the marriage is solved
 **
 ** @return
 **/
void
GameMarriage::determine_marriage()
{
  if (!this->is_undetermined())
    return ;

  auto& game = *this->game_;
  auto const& rule = game.rule();
  auto const& tricks = game.tricks();
  auto const& current_trick = tricks.current();
  auto const& soloplayer = game.players().soloplayer();

  // whether the player has to play alone
  // note that 'tricks().current_no()' begins at '0'
  // but 'determination' at '1'
  bool alone = (tricks.current_no() >= rule(Rule::Type::marriage_determination));
  auto const& winnerplayer = current_trick.winnerplayer();

  if (   rule(Rule::Type::marriage_first_one_decides)
      && is_selector(current_trick.startcard().tcolor(),
                     this->selector())
      && (winnerplayer == soloplayer) )
    alone = true;


  if (   is_selector(current_trick.startcard().tcolor(),
                     this->selector())
      && (winnerplayer != soloplayer) ) {
    // set the teams
    for (auto& p : game.players()) {
      auto const team = ((   (p == soloplayer)
                          || (p == winnerplayer))
                         ? Team::re
                         : Team::contra);
      game.teaminfo_.set(p, team);
      p.set_team(team);
    }
    this->selector_ = MarriageSelector::team_set;
    this->determination_trickno_ = tricks.current_no();
    // update the teaminfo of the players
    for (auto& p : game.players()) {
      p.marriage(soloplayer, winnerplayer);
    }

    game.gameplay_->gameplay_action(GameplayActions::Marriage(soloplayer.no(),
                                                              winnerplayer.no()));
    if (!game.isvirtual()) {
      ::ui->marriage(soloplayer, winnerplayer);
      this->signal_marriage_(soloplayer, winnerplayer);
      ::ui->gameplay_action(GameplayActions::Marriage(soloplayer.no(),
                                                      winnerplayer.no()));
      game.signal_gameplay_action_(GameplayActions::Marriage(soloplayer.no(),
                                                             winnerplayer.no()));
    }

    alone = false;
  } // if selected trick is caught


  if (   (this->selector() != MarriageSelector::team_set)
      && !alone) {
    // test, whether there is a remaining card of the color
    bool has_card = false; // whether a player has a card of the color
    for (auto& p : game.players()) {
      switch(this->selector()) {
      case MarriageSelector::silent:
      case MarriageSelector::team_set:
      case MarriageSelector::first_foreign:
        has_card = true;
        break;
      case MarriageSelector::first_trump:
        if (p.hand().contains(Card::trump))
          has_card = true;
        break;
      case MarriageSelector::first_color:
        if (   p.hand().contains(Card::club)
            || p.hand().contains(Card::spade)
            || p.hand().contains(Card::heart))
          has_card = true;
        break;
      case MarriageSelector::first_club:
        if (p.hand().contains(Card::club))
          has_card = true;
        break;
      case MarriageSelector::first_spade:
        if (p.hand().contains(Card::spade))
          has_card = true;
        break;
      case MarriageSelector::first_heart:
        if (p.hand().contains(Card::heart))
          has_card = true;
        break;
      } // switch (this->selector())
    } // for (p : this->players())

    if (!has_card)
      alone = true;
  } // if (!alone)

  if (alone) {
    this->determination_trickno_ = tricks.current_no();
    game.set_type(GameType::marriage_solo);
    for (auto& p : game.players()) {
      auto const team = (  (p == soloplayer)
                         ? Team::re
                         : Team::contra);
      game.teaminfo_.set(p, team);
      p.set_team(team);
    } // for (p : this->players())
    this->selector_ = MarriageSelector::team_set;

    for (auto& p : game.players())
      p.marriage(soloplayer, soloplayer);

    game.gameplay_->gameplay_action(GameplayActions::Marriage(soloplayer.no(),
                                                              soloplayer.no())
                                   );
    if (!game.isvirtual()) {
      ::ui->marriage(soloplayer, soloplayer);
      this->signal_marriage_(soloplayer, soloplayer);
      ::ui->gameplay_action(GameplayActions::Marriage(soloplayer.no(),
                                                      soloplayer.no())
                           );
      game.signal_gameplay_action_(GameplayActions::Marriage(soloplayer.no(),
                                                             soloplayer.no())
                                  );
    }
  } // if (this->acttrick() >= rule(Rule::Type::determination))

  // it can be, that the team of the swines owner or the first fox catcher
  // has changed
  if (rule(Rule::Type::swine_only_second)
      && game.swines().swines_announced()
      && game.swines().first_fox_caught()
      && (this->selector() == MarriageSelector::team_set)){
    if (!game.isvirtual())
      ::ui->redraw_all();
  } // if (first fox of swines in trick)
} // void GameMarriage::determine_marriage()

/** reset the values
 **/
void
GameMarriage::reset() noexcept
{
  this->selector_ = MarriageSelector::team_set;
  this->determination_trickno_ = 0;
}

/** @return   whether the game is a marriage and undetermined
 **/
bool
GameMarriage::is_undetermined() const noexcept
{
  return (   (this->game_->type() == GameType::marriage)
          && (this->selector() != MarriageSelector::team_set));
} // bool GameMarriage::marriage().is_undetermined() const

/** @return   signal for a marriage
 **/
Signal<void(Player const&, Player const&)>&
GameMarriage::signal_marriage() noexcept
{ return this->signal_marriage_; }

/** @return   signal, when the partner for a genscher shall be selected
 **/
Signal<void()>&
GameMarriage::signal_get_genscher_partner() noexcept
{ return this->signal_get_genscher_partner_; }

/** @return   signal, when a genscher is made
 **/
Signal<void(Player const&, Player const&)>&
GameMarriage::signal_genscher() noexcept
{ return this->signal_genscher_; }