player/human/human.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 "human.h"
#ifdef POSTPHONED
#include "humanDb.h"
#endif

#include "../../party/rule.h"
#include "../../misc/preferences.h"
#include "../../ui/ui.h"
#include "../../os/bug_report_replay.h"
#include "../../game/gameplay_actions.h"

/** Construktor
 **/
Human::Human() :
  Ai()
{
  // *** HACK
  this->set_type(Player::Type::human);
  this->set_name("");
#ifdef POSTPHONED
  this->db_ = new HumanDb();
#endif
} // Human::Human()

/** construktor
 **
 ** @param    istr   stream with the infos
 **/
Human::Human(istream& istr) :
  Ai(istr)
{
  this->set_type(Player::Type::human);
} // Human::Human(istream& istr)

/** copy-constructor
 **
 ** @param    player   player to copy
 **/
Human::Human(Player const& player) :
  Ai(player)
{
  this->set_type(Player::Type::human);
} // Human::Human(Player player)

/** copy-constructor
 **
 ** @param    player   player to copy
 ** @param    aiconfig   configuration to copy
 **/
Human::Human(Player const& player, Aiconfig const& aiconfig) :
  Ai(player, aiconfig)
{
  this->set_type(Player::Type::human);
} // Human::Human(Player player, Aiconfig aiconfig)

/** copy-constructor
 **
 ** @param    ai   ai to copy
 **/
Human::Human(Ai const& ai) :
  Ai(static_cast<Ai const&>(ai))
{
  this->set_type(Player::Type::human);
} // Human::Human(Ai ai)

/** copy-constructor
 **
 ** @param    human   human to copy
 **/
Human::Human(Human const& human) :
  Ai(static_cast<Ai const&>(human))
{
  this->set_type(Player::Type::human);
} // Human::Human(Human human)

/** clone the player
 **
 ** @return   pointer of a clone
 **/
unique_ptr<Player>
Human::clone() const
{
  return make_unique<Human>(*this);
} // virtual unique_ptr<Player> Human::clone() const

/** returns the reservation of the player
 ** (taken from the ui)
 **
 ** @param    is_duty   whether the player has to play a duty solo
 **   (default: false)
 **
 ** @return   reservation of the player
 **/
Reservation const&
Human::reservation_get(bool const is_duty)
{
  DEBUG_ASSERTION(!this->game().isvirtual(),
		  "Human::reservation_get():\n"
		  "  Game is virtual");

  { // bug report replay
    if (   ::bug_report_replay
	&& ::bug_report_replay->auto_action()
	&& (::bug_report_replay->current_action().type()
	    == GameplayActions::Type::reservation)
	&& (dynamic_cast<GameplayActions::Reservation const&>(::bug_report_replay->current_action()).player
	    == this->no())
       ) {
      this->reservation() = dynamic_cast<GameplayActions::Reservation const&>(::bug_report_replay->current_action()).reservation;
      return this->reservation();
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player) {
    this->reservation() = this->Ai::reservation_get(is_duty);
    return this->reservation();
  }

  (void)is_duty;

  this->reservation() = ::ui->get_reservation(*this);

  return this->reservation();
} // Reservation const& Human::reservation_get(bool const is_duty = false)

/** the game is started
 **/
void
Human::game_start()
{
  this->Ai::game_start();
  if (::preferences(Preferences::Type::announce_swines_automatically)) {
    if (this->game().rule()(Rule::Type::swines_announcement_begin))
      if (this->game().swines().swines_announcement_valid(*this))
	this->game().swines().swines_announce(*this);

  } // if (::preferences(Preferences::Type::announce_swines_automatically))
} // void Human::game_start()

/** @return   no announcement / announcement from the bug report
 **/
Announcement
Human::announcement_request() const
{
  { // bug report replay
    if (   ::bug_report_replay
	&& ::bug_report_replay->auto_action()
	&& (::bug_report_replay->current_action().type()
	    == GameplayActions::Type::announcement)
	&& (dynamic_cast<GameplayActions::Announcement const&>(::bug_report_replay->current_action()).player
	    == this->no())
       ) {
      return dynamic_cast<GameplayActions::Announcement const&>(::bug_report_replay->current_action()).announcement;
    } // if (auto execute)
  } // bug report replay

  return Announcement::noannouncement;
} // Announcement Human::announcement_request() const

/** returns the card played by the human
 **
 ** @return   the card choosen by a human player
 **/
HandCard
Human::card_get()
{
  DEBUG_ASSERTION(!this->game().isvirtual(),
		  "Human::card_get():\n"
		  "  Game is virtual");

  { // bug report replay
    if (   ::bug_report_replay
	&& ::bug_report_replay->auto_action()
       ) {
      if ( (::bug_report_replay->current_action().type()
	    == GameplayActions::Type::swines)
	  && (dynamic_cast<GameplayActions::Swines const&>(::bug_report_replay->current_action()).player
	    == this->no()))
	this->game().swines().swines_announce(*this);

      if ( (::bug_report_replay->current_action().type()
	    == GameplayActions::Type::hyperswines)
	  && (dynamic_cast<GameplayActions::Hyperswines const&>(::bug_report_replay->current_action()).player
	    == this->no()))
	this->game().swines().hyperswines_announce(*this);

      if ( (::bug_report_replay->current_action().type()
	    == GameplayActions::Type::card_played)
	  && (dynamic_cast<GameplayActions::CardPlayed const&>(::bug_report_replay->current_action()).player
              == this->no())) {
        this->set_last_heuristic_to_bug_report();
        return HandCard(this->hand(), dynamic_cast<GameplayActions::CardPlayed const&>(::bug_report_replay->current_action()).card);
      }
    } // if (auto execute card play)
  } // bug report replay

  if (::fast_play & FastPlay::player) {
    HandCard const card = this->Ai::card_suggestion();
    if (!card.is_empty()
        && card.isvalid(this->game().tricks().current())) {
      return card;
    }
  }

  this->set_last_heuristic_to_manual();
  auto const card = ::ui->get_card(*this);

  if (::game_status != GameStatus::game_play)
    return HandCard(this->hand(), Card());

  DEBUG_ASSERTION(!card.is_empty(),
                  "Human::card_get():\n"
                  "  result of 'ui->card_get()' is an empty card");

  if (::preferences(Preferences::Type::announce_swines_automatically)) {
    auto const& rule = this->game().rule();
    auto& swines = this->game().swines();
    if (card.possible_swine()
        && !rule(Rule::Type::swines_announcement_begin)
        && swines.swines_announcement_valid(*this)) {
      if (rule(Rule::Type::swine_only_second)) {
        if (this->hand().count_trump_aces() == 1)
          swines.swines_announce(*this);
      } else {
        swines.swines_announce(*this);
      }
    }
    if (card.possible_hyperswine()
        && !rule(Rule::Type::hyperswines_announcement_begin)
        && swines.hyperswines_announcement_valid(*this))
      swines.hyperswines_announce(*this);
  } // if (::preferences(Preferences::Type::announce_swines_automatically))

  return card;
} // HandCard Human::card_get()

/** updates the team information
 **/
void
Human::teaminfo_update()
{
  this->Ai::teaminfo_update();
  if (::preferences(Preferences::Type::show_ai_information_teams)
      && !this->game().isvirtual()) {
    for (auto const& p : this->game().players()) {
      ::ui->teaminfo_changed(p);
    }
  }
} // void Human::teaminfo_update()

/** returns which cards the player shifts
 **
 ** @return   the cards that are to be shifted
 **/
HandCards
Human::poverty_shift()
{
  { // bug report replay
    if (   ::bug_report_replay
        && ::bug_report_replay->auto_action()
        && (::bug_report_replay->current_action().type()
            == GameplayActions::Type::poverty_shift)
        && (dynamic_cast<GameplayActions::PovertyShift const&>(::bug_report_replay->current_action()).player
            == this->no())
       ) {
      HandCards const cards(this->hand(),
                            dynamic_cast<GameplayActions::PovertyShift const&>(::bug_report_replay->current_action()).cards);
      this->hand().remove(cards);
      return cards;
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player)
    return this->Ai::poverty_shift();

  return ::ui->get_poverty_cards_to_shift(*this);
} // void Human::poverty_shift(Player const& player)

/** returns whether 'player' accepts the shifted cards
 **
 ** @param    cardno   the number of shifted cards
 **
 ** @return   whether to accept the cards
 **/
bool
Human::poverty_take_accept(unsigned const cardno)
{
  { // bug report replay
    if (   ::bug_report_replay
        && ::bug_report_replay->auto_action()) {
      if (   (::bug_report_replay->current_action().type()
              == GameplayActions::Type::poverty_accepted)
          && (dynamic_cast<GameplayActions::PovertyAccepted const&>(::bug_report_replay->current_action()).player
              == this->no()) )
        return true;
      if (   (::bug_report_replay->current_action().type()
              == GameplayActions::Type::poverty_denied)
          && (dynamic_cast<GameplayActions::PovertyDenied const&>(::bug_report_replay->current_action()).player
              == this->no()) )
        return false;
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player)
    return this->Ai::poverty_take_accept(cardno);

  return ::ui->get_poverty_take_accept(*this, cardno);
} // void Human::poverty_take_accept(unsigned const cardno)

/** changes the cards from the poverty-player
 **
 ** @param    cards   the cards that are given to the player
 **
 ** @return   the cards that are returned to the poverty-player
 **/
HandCards
Human::poverty_cards_change(HandCards const& cards)
{
  { // bug report replay
    if (   ::bug_report_replay
        && ::bug_report_replay->auto_action()) {
      if (::bug_report_replay->current_action().type()
          == GameplayActions::Type::poverty_returned) {
        this->hand().add(cards);
        HandCards const cards_returned(this->hand(),
                                       dynamic_cast<GameplayActions::PovertyReturned const&>(::bug_report_replay->current_action()).cards);
        this->hand().remove(cards_returned);
#ifdef WORDAROUND
        // the ai has to update the cards
        this->set_hand(this->hand());
#endif
        return cards_returned;
      }
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player)
    return this->Ai::poverty_cards_change(cards);

#ifdef WORKAROUND
  // the ai has to update the cards
  HandCards const cards_returned
    = ::ui->get_poverty_exchanged_cards(*this, cards);
  this->Ai::set_hand(this->hand());

  return cards_returned;
#else
  return ::ui->poverty_cards_change(*this, cards);
#endif
} // HandCards Human::poverty_cards_change(HandCards cards)

/** gets the cards from the partner and add them to the hand
 **
 ** @param    cards   the cards that are given to the player
 **/
void
Human::poverty_cards_get_back(HandCards const& cards)
{
  { // bug report replay
    if (   ::bug_report_replay
        && ::bug_report_replay->auto_action()) {
      this->Ai::poverty_cards_get_back(cards);
      return ;
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player) {
    this->Ai::poverty_cards_get_back(cards);
    return ;
  }

  ::ui->poverty_cards_get_back(*this, cards);
#ifdef WORKAROUND
  // the ai has to update the cards
  this->Ai::set_hand(this->hand());
#endif
} // void Human::poverty_cards_get_back(HandCards cards)

/** 'player' has announce hyperswines
 **
 ** @param    player   player that has announced the hyperswines
 **/
void
Human::swines_announced(Player const& player)
{
  this->Ai::swines_announced(player);

  if (::preferences(Preferences::Type::announce_swines_automatically)) {
    if (this->game().swines().hyperswines_announcement_valid(*this)
        && this->game().rule()(Rule::Type::hyperswines_announcement_begin))
      this->game().swines().hyperswines_announce(*this);

  } // if (::preferences(Preferences::Type::announce_swines_automatically))
} // void Human::swines_announced(Player player)

/** genscher: -> result
 **
 ** @return   pointer to the new teammate,
 **            NULL if the genscher is not to be announced
 **/
Player const*
Human::genscher_partner()
{
  { // bug report replay
    if (   ::bug_report_replay
        && ::bug_report_replay->auto_action()
        && (::bug_report_replay->current_action().type()
            == GameplayActions::Type::genscher)
        && (dynamic_cast<GameplayActions::Genscher const&>(::bug_report_replay->current_action()).player
            == this->no())
       ) {
      unsigned const partner_no
        = dynamic_cast<GameplayActions::Genscher const&>(::bug_report_replay->current_action()).partner;
      if (partner_no == UINT_MAX)
        return {};
      else
        return &this->game().player(partner_no);
    } // if (auto execute)
  } // bug report replay

  if (::fast_play & FastPlay::player)
    return this->Ai::genscher_partner();

  return ::ui->get_genscher_partner();
} // Player const* Human::genscher_partner()