player/ai/ai.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 "ai.h"
#include "team_information.h"
#include "cards_information.h"
#include "heuristic_ai.h"
#include "virtual_games_ai.h"
#include "solo_decision.h"

#include "heuristic.h"
#include "heuristics.h"
#include "weighting.h"
#include "aiDb.h"
#include "../../party/party.h"
#include "../../party/rule.h"
#include "../../card/trick.h"
#include "../../game/gameplay_actions.h"
#ifndef OUTDATED
// for 'nextcard()' errors
#include "../../misc/bug_report.h"
#include "../../os/bug_report.h"
#endif
#include "../../os/bug_report_replay.h"
#ifndef WORKAROUND
// for replaying old bug reports
#include "../../utils/version.h"
#endif
#ifdef CHECK_RUNTIME
#include "../../runtime.h"
#endif

//#define DEBUG_PLAYER ((::party->game().tricks().current_no() == 8) ? 2 : 22)
#define DEBUG_PLAYER 33

// whether to debug the game decision
#ifndef RELEASE
#define DEBUG_RESERVATION_PLAYER 9
#endif
#ifdef DEBUG_RESERVATION_PLAYER
#define DEBUG_RESERVATION(solo, value, max) \
  if (this->no() == DEBUG_RESERVATION_PLAYER) { \
    COUT << solo << ": " << value << (value == max ? " * " : "") << '\n'; \
  } else (void)0
#else
#define DEBUG_RESERVATION(solo, value, max) (void)0
#endif

/** construktor
 **
 ** @param    istr   stream with the infos
 **
 ** @todo      using constructor Aiconfig(istr)
 ** @todo      update to the new format
 **/
Ai::Ai(istream& istr) :
  Player(Player::Type::ai),
  trick_(::party->rule()(Rule::Type::number_of_tricks_in_game)),
  colorjabbed_(::party->rule()(Rule::Type::number_of_card_colors),
                vector<bool>(::party->rule()(Rule::Type::number_of_players_in_game),
                             false)),
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this))
{
  this->db_ = make_unique<AiDb>();

  while (istr.good()) {
    string line;
    getline(istr, line);
    if (istr.fail() || istr.eof())
      break;

    if (*line.rbegin() == '\r')
      line.erase(line.end() - 1);

    if ((line == "")
        || (line[0] == '#')) {
      continue;
    }
    if (   (line == "Aiconfig")
        || (line == "aiconfig") ) {
      // this is the last entry
      this->Aiconfig::read(istr);
      break;
    } else if (line == "Database") {
      this->db_->read(istr);
    } else {
      cerr << "Reading the ai:\n"
        << "found following unknown line:\n"
        << line << '\n'
        << "ignoring it."
        << endl;
#ifndef RELEASE
      exit(EXIT_FAILURE);
#endif
    }
  }; // while (istr.good())
}

/** standard constructor
 **
 ** @result    -
 **/
Ai::Ai() :
  Player(Player::Type::ai),
  trick_(::party->rule()(Rule::Type::number_of_tricks_in_game)),
  colorjabbed_(::party->rule()(Rule::Type::number_of_card_colors),
               vector<bool>(::party->rule()(Rule::Type::number_of_players_in_game),
                            false)),
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this))
{
  this->db_ = make_unique<AiDb>();
  for (auto const game_type : ::game_type_solo_list) {
    this->solo_decisions_.emplace_back(SoloDecision::create(game_type, *this));
  }
}

/** constructor
 **
 ** @param    aiconfig   ai configuration
 **
 ** @result    -
 **/
Ai::Ai(Aiconfig const& aiconfig) :
  Player(Player::Type::ai),
  Aiconfig(aiconfig),
  trick_(::party->rule()(Rule::Type::number_of_tricks_in_game)),
  colorjabbed_(::party->rule()(Rule::Type::number_of_card_colors),
               vector<bool>(::party->rule()(Rule::Type::number_of_players_in_game),
                            false)),
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this))
{
  this->db_ = make_unique<AiDb>();
  for (auto const game_type : ::game_type_solo_list) {
    this->solo_decisions_.emplace_back(SoloDecision::create(game_type, *this));
  }
}

/** copy constructor
 **
 ** @param    player   player to copy
 **/
Ai::Ai(Player const& player) :
  Player(player),
  trick_(::party->rule()(Rule::Type::number_of_tricks_in_game)),
  colorjabbed_(::party->rule()(Rule::Type::number_of_card_colors),
               vector<bool>(::party->rule()(Rule::Type::number_of_players_in_game),
                            false)
              ) ,
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this))
{
  this->set_type(Player::Type::ai);
  this->db_ = make_unique<AiDb>(player.db());
  for (auto const game_type : ::game_type_solo_list) {
    this->solo_decisions_.emplace_back(SoloDecision::create(game_type, *this));
  }
}

/** copy constructor
 **
 ** @param    player   player to copy
 ** @param    aiconfig   configuration to copy
 **/
Ai::Ai(Player const& player, Aiconfig const& aiconfig) :
  Player(player),
  Aiconfig(aiconfig),
  trick_(::party->rule()(Rule::Type::number_of_tricks_in_game)),
  colorjabbed_(::party->rule()(Rule::Type::number_of_card_colors),
               vector<bool>(::party->rule()(Rule::Type::number_of_players_in_game),
                            false)
              ) ,
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this))
{
  this->set_type(Player::Type::ai);

  if (::game_status & GameStatus::game)
    DEBUG_ASSERTION(false,
                    "Ai::Ai(player):\n"
                    "  in game");

  this->db_ = make_unique<AiDb>(player.db());
  for (auto const game_type : ::game_type_solo_list) {
    this->solo_decisions_.emplace_back(SoloDecision::create(game_type, *this));
  }
}

/** copy constructor
 **/
Ai::Ai(Ai const& ai) :
  Player(ai),
  Aiconfig(ai),
team_information_(ai.team_information_
                  ? new TeamInformation(ai.team_information())
                  : nullptr),
cards_information_(ai.cards_information_
                   ? new CardsInformation(ai.cards_information())
                   : nullptr),
  teaminfo_(ai.teaminfo_),
  trick_(ai.trick_),
  trickno_(ai.trickno_),
  colorjabbed_(ai.colorjabbed_),
  low_(ai.low_),
  meatlesscolor_(ai.meatlesscolor_),
  trumpless_( ai.trumpless_ ),
  last_trick_to_calculate_(ai.last_trick_to_calculate_),
  last_heuristic_(ai.last_heuristic_),
  last_heuristic_rationale_(ai.last_heuristic_rationale_),
  vgi_(make_unique<VirtualGamesAi>(*this)),
  hi_(make_unique<HeuristicAi>(*this)),
  silent_marriage_(ai.silent_marriage_)
{
  if (::game_status & GameStatus::game)
    DEBUG_ASSERTION(!this->trumpless_.empty(),
                    "Ai::Ai(ai):\n"
                    "  'trumpless_.size() == 0");

  this->set_type(Player::Type::ai);
  if (this->team_information_)
    this->team_information_->set_player(*this);
  if (this->cards_information_)
    this->cards_information_->set_player(*this);

  if (ai.db())
    this->db_ = make_unique<AiDb>(*ai.db());
  else
    this->db_ = make_unique<AiDb>();
  for (auto const game_type : ::game_type_solo_list) {
    this->solo_decisions_.emplace_back(SoloDecision::create(game_type, *this));
  }

  if (::game_status & GameStatus::game) {
    for (unsigned i = 0; i < this->colorjabbed_.size(); ++i) {
      DEBUG_ASSERTION((ai.colorjabbed_[i].size() == this->game().playerno()),
                      "Ai::Ai(ai)\n"
                      "ai");
      DEBUG_ASSERTION((this->colorjabbed_[i].size() == this->game().playerno()),
                      "Ai::Ai(ai)\n"
                      "this");
    }
  } // if (::game_status & GameStatus::game)
}

/** destructor
 **/
Ai::~Ai() = default;

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

/** cast to 'VirtualGamesInterface'
 **/
Ai::operator VirtualGamesInterface const&() const
{ return *this->vgi_; }

/** cast to 'HeuristicInterface'
 **/
Ai::operator HeuristicInterface const&() const
{ return *this->hi_; }

/** @return   the team information
 **/
TeamInformation const&
Ai::team_information() const
{ return *this->team_information_; }

/** @return   the team information
 **/
TeamInformation&
Ai::team_information()
{ return *this->team_information_; }

/** @return   the cards information
 **/
CardsInformation const&
Ai::cards_information() const
{ return *this->cards_information_; }

/** @return   the cards information
 **/
CardsInformation&
Ai::cards_information()
{ return *this->cards_information_; }

/** @return   the database
 **/
AiDb const*
Ai::db() const
{ return dynamic_cast<AiDb const*>(this->db_.get()); }

/** @return   the database
 **/
AiDb*
Ai::db()
{ return dynamic_cast<AiDb*>(db_.get()); }

/** writes the ai into the stream
 **
 ** @param    ostr   stream the ai is to be written in
 **
 ** @return   the output stream
 **/
ostream&
Ai::write(ostream& ostr) const
{
  // output of the name, type and database
  this->Player::write(ostr);

  // output of the configuration
  ostr << '\n'
    << "Aiconfig\n"
    << "{\n";
  this->Aiconfig::write(ostr);
  ostr << "}\n";

  return ostr;
}

/** read the config of the player
 **
 ** @param    config   configuration to read
 ** @param    istr   input stream
 **
 ** @return   whether the configuration was valid
 **/
bool
Ai::read(Config const& config, istream& istr)
{
  if (   !config.separator
      && (   (config.name == "Aiconfig")
          || (config.name == "aiconfig") ) ) {
    return this->Aiconfig::read(istr);
  }

  return this->Player::read(config, istr);
}

/** compares the '*this' with 'ai'
 **
 ** @param    ai   ai to compare with
 **
 ** @return   whether 'ai' is equal to '*this'
 **
 ** @todo   test 'cards_information', 'team_information'
 **/
bool
Ai::isequal(Ai const& ai) const
{
  // ToDo: test team_information
  // ToDo: test cards_information

  if (this->colorjabbed_.size() != ai.colorjabbed_.size())
    return false;

  for (unsigned i = 0; i < this->colorjabbed_.size(); i++) {
    if (this->colorjabbed_[i].size() != ai.colorjabbed_[i].size())
      return false;

    for (unsigned j = 0; j < this->colorjabbed_[i].size(); j++)
      if (this->colorjabbed_[i][j] != ai.colorjabbed_[i][j])
        return false;
  } // for (i < this->colorjabbed_.size())

  if (this->trumpless_.size() != ai.trumpless_.size())
    return false;

  for (unsigned i = 0; i < this->trumpless_.size(); i++)
    if (this->trumpless_[i] != ai.trumpless_[i])
      return false;

  if (this->trickno_ != ai.trickno_)
    return false;

  if (this->low_ != ai.low_)
    return false;

  if (this->meatlesscolor_ != ai.meatlesscolor_)
    return false;

  if (this->last_trick_to_calculate_ != ai.last_trick_to_calculate_)
    return false;

  if (this->last_heuristic_ != ai.last_heuristic_)
    return false;

  if (this->last_heuristic_rationale_ != ai.last_heuristic_rationale_)
    return false;

#if 0
  vector<Trick> trick_; // last played tricks
#endif

  return true;
}

/** @return   the aitype for the current trick
 **/
AiType
Ai::aitype() const
{
#ifdef RELEASE
  // Workaround
  if( !( (::game_status >= GameStatus::game_play)
        && (::game_status < GameStatus::game_finished) ))
    return this->Aiconfig::aitype(0);
#else
  DEBUG_ASSERTION( (::game_status >= GameStatus::game_play)
                  && (::game_status < GameStatus::game_finished),
                  "Ai::aitype():\n"
                  "  game status not in game: " << ::game_status);
#endif

  return this->Aiconfig::aitype(this->game().tricks().current().no());
}

/** @return   the rating type for the current trick
 **/
Rating::Type
Ai::rating() const
{
#ifdef RELEASE
  // Workaround
  if( !( (::game_status >= GameStatus::game_play)
        && (::game_status < GameStatus::game_finished) ))
    return this->Aiconfig::rating(0);
#else
  DEBUG_ASSERTION( (::game_status >= GameStatus::game_play)
                  && (::game_status < GameStatus::game_finished),
                  "Ai::rating():\n"
                  "  game status not in game: " << ::game_status);
#endif

  return this->Aiconfig::rating(this->game().tricks().current().no());
}

/** sets the cards information
 **
 ** @param    cards_information   new cards information
 **/
void
Ai::set_cards_information(CardsInformation const& cards_information)
{
  if (this->cards_information_.get() == &cards_information)
    return ;

  this->cards_information_ = make_unique<CardsInformation>(cards_information);
  this->cards_information_->set_player(*this);
}

/** @return   the future limit for the current trick
 **/
unsigned
Ai::future_limit() const
{
  DEBUG_ASSERTION( (::game_status >= GameStatus::game_play)
                  && (::game_status < GameStatus::game_finished),
                  "Ai::future_limit():\n"
                  "  game status not in game: " << ::game_status);

  return this->Aiconfig::future_limit(this->game().tricks().current().no());
}

/** sets the game of the ai
 **
 ** @param    game   the new game for the ai
 **/
void
Ai::set_game(Game& game)
{
  //bool const old_isvirtual = this->game().isvirtual();
  this->Player::set_game(game);
}

/** sets the hand of the ai
 **
 ** @param    hand   new hand
 **
 ** @return   the hand
 **/
Hand const&
Ai::set_hand(const Hand& hand)
{
  this->Player::set_hand(hand);
  if (::game_status <= GameStatus::game_init)
    return this->hand();
  this->cards_information().set_hand(*this, hand);
  this->team_information().update_teams();

  // how to start in the heuristic 'play low high'
  this->low_ = (this->hand().count(Card::jack) >= this->hand().count(Card::queen) +2);

  return this->hand();
}

/** the rule has changed
 **
 ** @param    type        rule type to have changed
 ** @param    old_value   old value of the rule
 **/
void
Ai::rule_changed(int const type, void const* const old_value)
{
  this->Aiconfig::rule_changed(type, old_value);
}

/** the game 'game' is opened
 **
 ** @param    game    opened game
 **/
void
Ai::game_open(Game& game)
{
  this->Player::game_open(game);
  this->team_information().reset();
  this->cards_information().reset();
}

/** the game is started
 **/
void
Ai::game_start()
{
  if (::game_status == GameStatus::game_redistribute)
    return ;

  this->Player::game_start();

  { // in a poverty the hand can have changed
    this->cards_information().reset();
    this->cards_information().set_hand(*this, this->hand());
  }

  this->team_information().game_start();
  this->cards_information().game_start();
  this->team_information().update_teams();
}

/** the game is closed
 **
 ** @param    game   game that is closed
 **/
void
Ai::game_close(Game const& game)
{
  this->Player::game_close(game);

  this->team_information_ = {};
  this->cards_information_ = {};
}

/** -> result
 ** - if 'Aiconfig::hands_known' the real hand of the player is returned
 **   (independent on 'Rule::Type::show_all_hands')
 ** - if not 'Aiconfig::hands_known' the hand is calculated,
 **   see 'CardsInformation'
 **
 ** @param    player   player whose hand is returned
 **
 ** @result   hand of 'player'
 **/
Hand const&
Ai::handofplayer(Player const& player) const
{
  if (   !this->game().isvirtual()
      && (player == *this))
    return this->hand();

  if (this->Aiconfig::value(Aiconfig::Type::hands_known))
    return player.hand();

  // If it is the last trick and the player has already played a card,
  // his hand is empty.
  if (   (::game_status == GameStatus::game_play)
      && (this->game().tricks().real_remaining_no() == 1)
      && (this->game().tricks().current().cardno_of_player(player)
          < this->game().tricks().current().actcardno()))
    return player.hand();

#ifndef RELEASE
  Hand const& hand = this->cards_information().estimated_hand(player);
  hand.self_check();
  return hand;
#else
  return this->cards_information().estimated_hand(player);
#endif
}

/** the known team of the player
 **/
Team
Ai::teamofplayer(Player const& player) const
{
  // In the marriage case, as long as the teams are not determined,
  // the player shall think that every other player is against him.
  if (this->game().type() == GameType::marriage)
    return this->teaminfo(player);

  if (this->Aiconfig::value(Aiconfig::Type::teams_known))
    return player.team();

  return this->teaminfo( player );
}

/** set the teams
 **
 ** @param    teams   teams of the players
 **/
void
Ai::set_teams(vector<Team> const& teams)
{
  this->team_information().set_teams(teams);
  this->set_team(teams[this->no()]);
}

/** the trick is opened
 **
 ** @param    trick   opened trick
 **/
void
Ai::trick_open(Trick const& trick)
{
  this->cards_information().trick_open(trick);
  this->team_information().update_teams();
}

/** the trick is full
 **
 ** @param    trick   full trick
 **/
void
Ai::trick_full(Trick const& trick)
{
  DEBUG_ASSERT( trick.isfull() );

  this->team_information().trick_full(trick);
  this->cards_information().trick_full(trick);
  this->team_information().update_teams();

  if( trick.startcard().istrump() ) {
    for ( unsigned i = 0; i < trick.actcardno(); i++) {
      if (!trick.card(i).istrump()) {
        DEBUG_ASSERTION((this->trumpless_.size()
                         > trick.player_of_card(i).no()),
                        "Ai::trick_full(trick):\n"
                        "  'this->trumpless_' is too small: "
                        << this->trumpless_.size() << " <= "
                        << trick.player_of_card(i).no());
        this->trumpless_[ trick.player_of_card(i).no() ] = true;
      }
    }
  }
}

/** @return   card played by the ai
 **/
HandCard
Ai::card_get()
{
  auto const& current_trick = this->game().tricks().current();
  auto const card = this->nextcard(current_trick);
  HandCard const handcard(this->hand(), card);

  auto& swines = this->game().swines();
  if (   handcard.possible_swine()
      && swines.swines_announcement_valid(*this))
    swines.swines_announce(*this);
  if (   handcard.possible_hyperswine()
      && swines.hyperswines_announcement_valid(*this))
    swines.hyperswines_announce(*this);
  { // ToDo: check for last chance to announce
    auto announcement = this->announcement_request();
    while (!!announcement) {
      this->game().announcements().make_announcement(announcement, *this);
      if (this->announcement() != announcement)
        break;
      announcement = this->announcement_request();
    }
  }
  this->check_and_make_first_announcement(handcard);

  return handcard;
}

/** @return   suggested card
 **/
HandCard
Ai::card_suggestion()
{
  if (::bug_report_replay) {
    static bool bug_report_flip = false;
    if (this->last_heuristic_ != Aiconfig::Heuristic::bug_report)
      bug_report_flip = true;
    else
      bug_report_flip ^= true;
    if (bug_report_flip) {
      this->set_last_heuristic_to_bug_report();
      auto const card = ::bug_report_replay->next_card(*this);
      if (   !card.is_empty()
          && this->hand().contains(card)) {
        return HandCard(this->hand(), card);
      }
    }
  }
  auto const& current_trick = this->game().tricks().current();
  auto const card = this->nextcard(current_trick);
#ifndef RELEASE
#ifdef DKNOF
  cout << "card suggestion: " << card << '\n'
    << this->last_heuristic() << '\n'
    << this->last_heuristic_rationale() << '\n';
#endif
#endif
  return HandCard(this->hand(), card);
}

/** 'player' has played the card 'card'
 **
 ** @param    card    played card
 **/
void
Ai::card_played(HandCard const& card)
{
  this->cards_information().card_played(card);
  this->team_information().card_played(card);
  this->team_information().update_teams();

  if( this->no() == DEBUG_PLAYER ) {
    COUT << "card played " << card << endl;
    COUT << "virtual = " << this->game().isvirtual() << endl;
  }

  Player const& player = card.player();
  Card::Color jabbed = Card::nocardcolor;


  Trick t = player.game().tricks().current();

  if (!t.startcard().istrump())
  {
    jabbed = t.startcard().color();
  }


  if (jabbed!=Card::nocardcolor && card.istrump())
  {
    colorjabbed_[jabbed][player.no()] = true;
  }
  if(   jabbed != Card::nocardcolor
     && card.color() != jabbed
     && (this->cards_information().remaining_trumps_others()
         >=  game().tricks().remaining_no() ) )
  {
    colorjabbed_[jabbed][player.no()] = true;
  }


  if (player == *this) {
    switch (this->last_heuristic_) {
    case Aiconfig::Heuristic::low_high:
    case Aiconfig::Heuristic::color_low_high:
      if (! (   this->low_
             && (this->game().tricks().current().winnerplayer() == *this)) )
        this->check_low_high(card);
      break;

    default:
      break;
    }
    if(  this->hand().count(Card::jack) >= this->hand().count(Card::queen) +2 )
      this->low_ = true;
  } // if (player == *this)

  this->teaminfo_update();
}

/** check a swines announcement at the game start
 **/
void
Ai::check_swines_announcement_at_game_start()
{
  if (this->type() == Player::Type::ai) {
    // announce swines
    if (this->game().rule()(Rule::Type::swines_announcement_begin))
      if (this->game().swines().swines_announcement_valid(*this))
        this->game().swines().swines_announce(*this);

    // hyperswines are announced by 'Ai::swines_announced(player)'
  } // if (this->type() == Player::Type::ai)
}

/** 'player' has announce swines
 ** if possible announce hyperswines
 **
 ** @param    player   player that has announced the swines
 **/
void
Ai::swines_announced(Player const& player)
{
  this->cards_information().swines_announced(player);
  this->team_information().update_teams();

  if (this->type() == Player::Type::ai) {
    if (   this->game().swines().hyperswines_announcement_valid(*this)
        && this->game().rule()(Rule::Type::hyperswines_announcement_begin))
      this->game().swines().hyperswines_announce(*this);
  } // if (this->type() == Player::Type::ai)
}

/** 'player' has announce hyperswines
 **
 ** @param    player   player that has announced the hyperswines
 **/
void
Ai::hyperswines_announced(Player const& player)
{
  this->cards_information().hyperswines_announced(player);
  this->team_information().update_teams();
}

/** the marriage partner has found a bride
 ** if the bride is the bridegroom, the bridegroom must play a solo
 **
 ** @param    bridegroom   the player with the marriage
 ** @param    bride   the bride
 **/
void
Ai::marriage(Player const& bridegroom, Player const& bride)
{
  this->team_information().marriage(bridegroom, bride);
  this->teaminfo_update();
}

/** a player has a genscher and selected a new partner
 **
 ** @param    genscher   genscher player
 ** @param    partner   partner of the gensher player
 **/
void
Ai::genscher(Player const& genscher, Player const& partner)
{
  this->team_information().genscher(genscher, partner);
  this->cards_information().genscher(genscher, partner);
  this->team_information().update_teams();
}

/** selects a card to play
 **
 ** @param    trick   current trick
 **
 ** @return   card to play
 **/
Card
Ai::nextcard(Trick const& trick)
{
  if (!this->game().isvirtual())
    db()->increase( Aiconfig::Heuristic::no_heuristic );

#ifdef CHECK_RUNTIME
    auto const ssp = (  !this->game().isvirtual()
                      ? ::runtime["ai heuristics"].start_stop_proxy()
                      : nullptr);
#endif

    // special case: unset marriage and last chance
    if (   (this->game().type() == GameType::marriage)
        && (this->game().players().soloplayer() == *this)
        && (this->game().marriage().selector() != MarriageSelector::silent)
        && (this->game().marriage().selector() != MarriageSelector::team_set)
        && (this->game().tricks().current().isempty())
        && (this->game().tricks().current_no() + 1 == this->game().rule()(Rule::Type::marriage_determination)) ) {
      Card const card = Heuristics::play_to_get_married(trick, *this);
      if (card) {
        this->last_heuristic_ = Aiconfig::Heuristic::play_to_get_married;
        this->last_heuristic_rationale_.clear();
        this->db()->increase(Aiconfig::Heuristic::play_to_get_married);
        return card;
      }
    }

    auto
      heuristics_vector = (  this->silent_marriage_
                           ? (this->heuristic_states(HeuristicsMap::GameTypeGroup::marriage_silent,
                                                     HeuristicsMap::PlayerTypeGroup::re))
                           : this->heuristic_states(HeuristicsMap::Key(*this)));
    heuristics_vector.insert(heuristics_vector.begin(),
                             {Heuristic::only_one_valid_card, true});
    heuristics_vector.insert(heuristics_vector.begin(),
                             {Heuristic::bug_report, true});
    for (auto const& heuristic_state : heuristics_vector) {
      if (!heuristic_state.active)
        continue;
      auto const heuristic = heuristic_state.heuristic;
      if (heuristic == Aiconfig::Heuristic::error) {
        continue;
      }

      auto heuristic_logic = ::Heuristic::create(heuristic, *this);
      DEBUG_ASSERTION(heuristic_logic->heuristic() == heuristic,
                      "Heuristic " << heuristic << " is of the wrong type");
      heuristic_logic->set_player(*this);
      auto const card = heuristic_logic->get_card(trick);
      if (   !this->game().isvirtual()
          && (   ::debug("heuristics")
              || ::debug(to_string(heuristic)))) {
        cout << this->no() << ' ' << this->name() << ": " << card << " (" << heuristic << ")\n";
        cout << heuristic_logic->rationale();
      }

      if (!card)
        continue;
      if (   HEURISTIC_OUTPUT
          && !this->game().isvirtual()) {
        cout <<  setw(2) << this->no() << " "
          << setw(20) << card << " "
          << heuristic
          << endl;
      }

      if (   (heuristic == Aiconfig::Heuristic::try_for_doppelkopf)
          && (this->announcement() == Announcement::noannouncement)
          && !trick.islastcard()
          && (this->teaminfo(trick.player_of_card(this->game().playerno()))
              != ::opposite(this->team()))) {
        // make an announcement so that the player behind can give points
        this->game().announcements().make_announcement(Announcement::no120, *this);
      }

      this->last_heuristic_ = heuristic;
      this->last_heuristic_rationale_ = heuristic_logic->rationale();
      this->db()->increase(heuristic);

      return card;
    } // for (heuristic_state : heuristics_vector)

  { // choosebestcard

    auto const heuristic = Aiconfig::Heuristic::choose_best_card;
    auto const card = Weighting::best_card(this->aitype(), *this);

    if (HEURISTIC_OUTPUT
        && !this->game().isvirtual())
      cout <<  setw(2) << this->no() << " "
        << setw(16) << card << " "
        << setw(39) << heuristic << " (" << this->aitype() << ") "
        << endl;

    this->last_heuristic_ = heuristic;
    this->last_heuristic_rationale_.clear();
    // only increment, if the ai could select a heuristic
    if (static_cast<int>(this->game().tricks().remaining_no()) >
        this->Aiconfig::value(Aiconfig::Type::last_tricks_without_heuristics ) ) {
      this->db()->increase(heuristic);
    }

    if (::game_status != GameStatus::game_play)
      return Card();

    if (this->aitype() != AiType::no_choosebestcard)
      DEBUG_ASSERT(!card.is_empty());

    return card;
  } // choosebestcard
}

/** @return   the last heuristic
 **/
Aiconfig::Heuristic
Ai::last_heuristic() const
{
  return this->last_heuristic_;
}

/** @return   the rationale of the last heuristic
 **/
Rationale const&
Ai::last_heuristic_rationale() const
{
  return this->last_heuristic_rationale_;
}

/** set the last heuristic to manual
 **/
void
Ai::set_last_heuristic_to_manual()
{
  this->last_heuristic_ = Aiconfig::Heuristic::manual;
  this->last_heuristic_rationale_.clear();
}

/** set the last heuristic to bug report
 **/
void
Ai::set_last_heuristic_to_bug_report()
{
  this->last_heuristic_ = Aiconfig::Heuristic::bug_report;
  this->last_heuristic_rationale_.clear();
}

/** @return   whether a player has jabbed the color
 **/
bool
Ai::colorjabbed(Card::Color const color) const
{
  if (color == Card::nocardcolor)
    return false;

  for (unsigned i = 0; i < game().playerno(); ++i) {
    if (colorjabbed_[color][i])
      return true;
  }

  return false;
}

/** @return   whether the color has been jabbed by the own team
 **/
bool
Ai::jabbedbyownteam(Card::Color const color) const
{
  if (color == Card::nocardcolor)
    return false;

  auto const team = this->team();
  auto const& game = this->game();
  for (unsigned i = 0; i < game.playerno(); ++i) {
    if (   (i != this->no())
        && maybe_to_team(this->teaminfo(game.player(i))) == team) {
      if (colorjabbed_[color][i])
        return true;
    }
  }

  return false;
}

/** @return   whether the color was jabbed by the other team
 **/
bool
Ai::jabbedbyotherteam(Card::Color const color) const
{
  if (color == Card::nocardcolor)
    return false;

  auto const team = this->team();
  auto const& game = this->game();
  for (unsigned i = 0; i < game.playerno(); ++i) {
    if (   (i != this->no())
        && (maybe_to_team(teaminfo(game.player(i))) != team)) {
      if (colorjabbed_[color][i])
        return true;
    }
  }

  return false;
}

/** -> result
 **
 ** @param    color   color
 **
 ** @return   how many times the color has run
 **/
unsigned
Ai::color_runs(Card::Color const color) const
{
  return this->cards_information().color_runs(color);
}

/** -> result
 **
 ** @param    trick   current trick
 **
 ** @return   how many times the color of the trick has run
 **/
unsigned
Ai::color_runs(Trick const& trick) const
{
  DEBUG_ASSERTION(!trick.isempty(),
                  "Ai::color_runs(trick)\n"
                  "  trick is empty");
  return this->cards_information().color_runs(trick.startcard().tcolor());
}

/** @return   whether the next card should be a low trump
 **/
bool
Ai::next_low() const
{
  return this->low_;
}

/** sets low_ to true if c>=diamond queen to false if card < diamond queen
 **/
void
Ai::check_low_high(HandCard const& card)
{
  if (   card.istrump()
      && !(card.less(Card::diamond_queen)))
    this->low_ = true;
  else
    this->low_ = false;
}

/** initialize the ai for a new game
 **/
void
Ai::new_game(Game& game)
{
  this->Player::new_game(game);

  this->team_information_ = make_unique<TeamInformation>(*this);
  this->cards_information_ = make_unique<CardsInformation>(*this);

  this->teaminfo_ = vector<Team>(this->game().playerno(), Team::unknown);

  this->meatlesscolor_ = Card::nocardcolor;

  this->low_ = true;

  this->trick_ = vector<Trick>(this->game().rule()(Rule::Type::number_of_tricks_in_game));

  this->trumpless_ = vector<bool>(this->game().playerno(), false );
  this->trickno_ = 0;
  for ( unsigned x = 0;
       x < this->game().rule()(Rule::Type::number_of_card_colors); x++)
  {
    this->colorjabbed_[x] =  vector<bool>(this->game().playerno(), false );
    for(unsigned y = 0; y < this->game().playerno(); y++) {
      this->colorjabbed_[x][y] = false;
    } // for (y < this->game().playerno())
  } // for (x < this->game().playerno())

  this->silent_marriage_ = false;
}

/** @return   tricktype which determines teams for a marraige
 **/
MarriageSelector
Ai::get_Marriage() const
{
  bool const isstartplayer = (this->game().startplayer() == *this);
  // ToDo: Test rules
  if (this->game().rule()(Rule::Type::marriage_first_foreign))
    return MarriageSelector::first_foreign;

  if (hand().count_trumps()<6
      && hand().count_trump_aces()==1
      && (   isstartplayer
          || this->game().rule()(Rule::Type::marriage_determination) >= 4)) {
    return MarriageSelector::first_trump;
  }

  if (Card::heart_ten.istrump(this->game())) {
    if (   hand().count(Card::heart) > 3
        && hand().count(Card::heart_ace) > 0) {
      return MarriageSelector::first_heart;
    }
  } else {
    if (   hand().count(Card::heart) > 4
        || (   hand().count(Card::heart) < 2
            && (  (   hand().count(Card::heart_ten) == 1
                   && isstartplayer)
               )
           )
       ) {
      return MarriageSelector::first_heart;
    }
  }
  if (  hand().count(Card::club) > 4
      || (   hand().count(Card::club) < 2
          && (   (   hand().count(Card::club_ten) == 1
                  && isstartplayer)
             )
         )
     ) {
    return MarriageSelector::first_club;
  }
  if (  hand().count(Card::spade) > 4
      || (   hand().count(Card::spade) < 2
          &&  (   hand().count(Card::spade_ten) == 1
               && isstartplayer)
         )
     ) {
    return MarriageSelector::first_spade;
  }
  if (   hand().count(Card::heart) == 1
      && hand().count(Card::heart_ace) != 1
      && isstartplayer) {
    return MarriageSelector::first_heart;
  }
  if (   hand().count(Card::club) == 1
      && hand().count(Card::club_ace) != 1
      && isstartplayer) {
    return MarriageSelector::first_club;
  }
  if (   hand().count(Card::spade) == 1
      && hand().count(Card::spade_ace) != 1
      && isstartplayer) {
    return MarriageSelector::first_spade;
  }


  if (   hand().count_trumps() >= 8
      && !isstartplayer) {
    return MarriageSelector::first_color;
  }

  return MarriageSelector::first_foreign;
}

/** -> result
 **
 ** @param    isDuty   whether the player must play a duty solo
 **                     (has no effect, yet)
 **
 ** @result    the reservation of the ai
 **/
Reservation const&
Ai::reservation_get( bool const isDuty )
{
  this->team_information().reset();
  this->cards_information().reset();
  auto& reservation = this->reservation();

  { // 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())
       ) {
      return (this->reservation() = dynamic_cast<GameplayActions::Reservation const&>(::bug_report_replay->current_action()).reservation);
    } // if (auto execute)
  } // bug report replay

  reservation = this->reservation_get_default();

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

  // check, whether to announce 'richness'
  if (reservation.game_type == GameType::thrown_richness) {
    if (Heuristics::make_announcement(*this))
      reservation.game_type = GameType::normal;
  }

  { // decide solo game
    SoloDecision::Points max_points = 120;
    if (   this->game().is_duty_solo()
        && *this == this->game().startplayer()) {
      max_points = INT_MIN;
    }
    GameType best_game_type = GameType::normal;
    // first all duty soli
    for (auto& decision : this->solo_decisions_) {
      auto const game_type = decision->game_type();
      if (!rule(game_type))
        continue;
      if (!this->is_remaining_duty_solo(game_type))
        continue;
      decision->set_player(*this);
      auto const points = decision->estimated_points();
      if (points > max_points) {
        best_game_type = game_type;
        max_points = points;
        DEBUG("solo decision rationale") << this->name() << ": " << decision->game_type() << ": " << points << " points\n"
          << decision->rationale() << '\n';
      }
    }
    max_points = 120;
    if (best_game_type == GameType::normal) {
      // lust solo games
      for (auto& decision : this->solo_decisions_) {
        auto const game_type = decision->game_type();
        if (!rule(game_type))
          continue;
        if (this->is_remaining_duty_solo(game_type))
          continue;
        decision->set_player(*this);
        auto const points = decision->estimated_points();
        if (points > max_points) {
          best_game_type = game_type;
          max_points = points;
          DEBUG("solo decision rationale") << this->name() << ": " << decision->game_type() << ": " << points << " points\n"
            << decision->rationale() << '\n';
        }
      }
    }
    if (best_game_type != GameType::normal) {
      reservation.game_type = best_game_type;
      if (is_color_solo(best_game_type)) {
        reservation.swines = true;
        reservation.hyperswines = true;
      }
    }
  }

#ifndef OLD
  if (reservation.game_type == GameType::marriage) {
    reservation.marriage_selector=get_Marriage();
#ifndef POSTPONED
    // ToDo: to be removed
    if (!rule(reservation.marriage_selector))
      reservation.marriage_selector = this->reservation_get_default().marriage_selector;
#endif
  }
#endif

  // special case: with swines announced the player does not have a poverty
  if (   reservation.game_type == GameType::poverty
      && (this->hand().count_poverty_cards()
          > rule(Rule::Type::max_number_of_poverty_trumps)) ) {
    reservation.swines = false;
  }

  return reservation;
}

/** -> result
 **
 ** @param    player whose teaminfo is returned
 **
 ** @return   the team of the given player, as far as this player knows it
 **/
Team
Ai::teaminfo(Player const& player) const
{
  return this->team_information().team(player);
}

/** updates the information of the teams (uses the current trick)
 **
 ** @return   the known teams
 **/
void
Ai::teaminfo_update()
{
  this->team_information().update_teams();
}

/** @return   the partner of the player, nullptr, if not known for sure
 **/
Player const*
Ai::partner(Player const& player) const
{
  if (::game_status < GameStatus::game_play)
    return nullptr;

  if (!this->team_information().all_known())
    return nullptr;

  Player const* partner = nullptr;

  for (unsigned p = 0; p < this->game().playerno(); ++p) {
    if (   (p != player.no())
        && (this->teaminfo(this->game().player(p))
            == this->teaminfo(player))) {
      if (partner != nullptr)
        return nullptr; // more than one partner
      partner = &this->game().player(p);
    }
  } // for (p)

  return partner;
}

/** @return   the points the team has made
 **/
unsigned
Ai::points_of_team() const
{
  unsigned points = this->game().points_of_player(*this);


  if (this->team_information().all_known()) {
    for (unsigned p = 0; p < this->game().playerno(); ++p)
      if (   (p != this->no())
          && (this->team_information().team(p) == this->team()))
        points += this->game().points_of_player(p);
  } else if (this->team_information().guessed_partner() != nullptr) {
    // normal game, partner guessed
    points += this->game().points_of_player(*this->team_information().guessed_partner());
  } else { // if (no partner known)
    // add the lowest points of the players
    unsigned lowest_points = 240;
    for (unsigned p = 0; p < this->game().playerno(); ++p)
      if (   (p != this->no())
          && (this->game().points_of_player(p) < lowest_points))
        lowest_points = this->game().points_of_player(p);
    points += lowest_points;
  } // if (no partner known)

  return points;
}

/** -> result
 ** (uses Heuristics)
 **
 ** @see        Heuristics::make_announcement()
 ** @see        Heuristics::say_no90
 ** @see        Heuristics::say_no60
 ** @see        Heuristics::say_no30
 ** @see        Heuristics::say_no0
 **
 ** @return   announcement of the player
 **/
Announcement
Ai::announcement_request() const
{
  if (   ::bug_report_replay
      && ::bug_report_replay->auto_action()) {
    if (   (::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 (current action = announcement)
    return Announcement::noannouncement;
  } // if (bug report auto execute)


  Announcement res = Announcement::noannouncement;

  for (auto a : real_announcements) {
    // make the announcement as late as possible
    if (!this->game().announcements().last_chance_to_announce(a, *this))
      continue;
    switch(a) {
    case Announcement::noannouncement:
    case Announcement::reply:
    case Announcement::no120_reply:
    case Announcement::no90_reply:
    case Announcement::no60_reply:
    case Announcement::no30_reply:
    case Announcement::no0_reply:
      DEBUG_ASSERTION(false,
                      "Ai::announcement_request():\n"
                      "  wrong announcement in 'switch': "
                      << a);
      break;
    case Announcement::no120:
      if (Heuristics::make_announcement(*this))
        res = a;
      break;
    case Announcement::no90:
      if (Heuristics::say_no90(*this))
        res = a;
      break;
    case Announcement::no60:
      if (Heuristics::say_no60(*this))
        res = a;
      break;
    case Announcement::no30:
      if (Heuristics::say_no30(*this))
        res = a;
      break;
    case Announcement::no0:
      if (Heuristics::say_no0(*this))
        res = a;
      break;
    } // switch(a)
  } // for (a \in announcements)

  if ( ( res == Announcement::noannouncement )
      && this->game().tricks().current().isfull()
      && this->game().announcements().is_valid(Announcement::reply, *this) )
    res = Heuristics::make_reply(*this);

  return res;
}

/** check whether re/contra shall be announced to announce the team
 **
 ** @param   handcard   card that is to be played
 **/
void
Ai::check_and_make_first_announcement(HandCard const& handcard)
{
  if (   ::bug_report_replay
      && ::bug_report_replay->auto_action()) {
    return ;
  }

  if (is_real(this->game().teaminfo().get(*this)))
    return ;

  if (!Heuristics::make_announcement(*this))
    return ;

  auto const& trick = this->game().tricks().current();
  // Make an announcement earlier so that the partner can pfund
  if (!trick.isjabbed(handcard))
    return ;

  if (!handcard.istrump()) {
    if (handcard.value() != Card::ace)
      return ;
    // first color run
    auto const color = handcard.tcolor();
    if (this->cards_information().played(handcard.tcolor())
        > trick.cards().count(color))
      return ;
  } else {
    if (   trick.isempty()
        || trick.startcard().istrump()) {
      if (handcard.less(this->trump_card_limit()))
        return ;
    } else {
      auto const color = trick.startcard().tcolor();
      if (this->cards_information().played(handcard.tcolor())
          > trick.cards().count(color))
        return ;
    }
  }
  this->game().announcements().make_announcement(Announcement::no120, *this);
}

/** the announcement 'announcement' has been made by player 'player'
 **
 ** @param    announcement   the announcement
 ** @param    player   the player, who has made the announcement
 **/
void
Ai::announcement_made(Announcement const announcement,
                      Player const& player)
{
  this->team_information().announcement_made(announcement, player);
  this->cards_information().announcement_made(announcement, player);
  this->team_information().update_teams();

  this->teaminfo_update();
} // void Ai::announcement_made(Announcement announcement, Player player)

/** @return   modificator for the end depth for calculating tricks
 **             in WVirtualGames
 **/
unsigned
Ai::last_trick_to_calculate() const
{
  return this->last_trick_to_calculate_;
}

/** sets the parameter to the last trick to calculate
 **
 ** @param    last_trick_to_calculate   new value
 **
 ** @return   modificator for the end depth for calculating tricks
 **             in WVirtualGames
 **/
void
Ai::set_last_trick_to_calculate(unsigned const last_trick_to_calculate)
{
  this->last_trick_to_calculate_ = last_trick_to_calculate;
}

/** returns which cards the player shifts
 **
 ** @return   the cards that are to be shifted
 **/
HandCards
Ai::poverty_shift()
{
  DEBUG_ASSERTION(this->hand().count_trumps() <= 5,
                  "Ai::poverty_shift()\n"
                  "  more then 5 trumps:\n" << this->hand());

  { // 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

  Hand& hand = this->hand();

  HandCards res;

  // number of remaining cards to shift
  unsigned rem = hand.count_poverty_cards();

  for (auto const card : hand)
    if (card.istrump())
      res.push_back(card);

  hand.remove(res);

  DEBUG_ASSERTION((res.size() <= rem),
                  "Ai::poverty_shift()\n"
                  "  too many trumps: " << res.size() << " > " << rem << '\n'
                  << "  trumps found:\n"
                  << res);
  rem -= res.size();

  if (   !this->game().rule()(Rule::Type::poverty_shift_only_trump)
      && rem > 0) {
    HandCards addon;

    auto color = Card::heart;
    auto size = hand.count(color);

    if (hand.count(Card::spade) < size) {
      color = Card::spade;
      size = hand.count(color);
    }

    if (hand.count(Card::club) < size) {
      color = Card::club;
      size = hand.count(color);
    }

    Hand::Position p = 0;
    while (rem > 0) {
      if (p >= hand.cardsnumber())
        p = 0;
      auto const card = hand.card(p);
      if (size > 0) {
        if (card.color() == color) {
          addon.push_back(card);
          hand.remove(p);
          size--;
          rem--;
        }
      } else {
        addon.push_back(card);
        hand.remove(p);
        rem--;
      }
      p += 1;
    }

    res.insert(res.end(), addon.begin(), addon.end());
  }// !this->game().rule()( Rule::Type::poverty_shift_only_trump ) && rem > 0

  return res;
}

/** returns whether 'player' accepts the shifted cards
 **
 ** @param    cardno  the number of shifted cards
 **
 ** @return   whether to accept the cards
 **/
bool
Ai::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

  unsigned trumpno_possible = cardno;
  if (!this->game().rule()(Rule::Type::poverty_shift_only_trump)) {
    if (!this->game().rule()(Rule::Type::throw_with_one_trump))
      trumpno_possible = 2;
    else
      trumpno_possible = 1;
  }

  int value = Heuristics::CalcHandValue( *this );

  if( this->hand().count_trumps() >= 12 - cardno )
    value += this->hand().count( Card::queen );

  std::multimap<unsigned, Card::Color> color_nums;
  for (auto const c : this->game().rule().card_colors()) {
    color_nums.insert(std::make_pair(this->hand().count(c), c));
  }

  for (auto const& c : color_nums) {
    if (c.first > trumpno_possible)
      break;

    value += 2;
    trumpno_possible -= c.first;
  }
  if( this->hand().count_trumps() >= 12 - cardno - 1 )
    value += (this->hand().count( Card::queen )
              + this->hand().count_trump_aces());


  if ( this->game().rule()(Rule::Type::dullen))
    value -= 4 - 2 * this->hand().count(Card::heart, Card::ten);

  value -= 4 - 2 * this->hand().count_club_queens();
  value -= 2 - this->hand().count(Card::spade, Card::queen);


  //COUT << no() << "\t" << value << "\t" << static_cast<signed>(this->value(Aiconfig::takepoverty)) << std::endl;

  return (value >= 15);
}

/** 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
Ai::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) {
        HandCards const reshifted_cards(this->hand(),
                                        dynamic_cast<GameplayActions::PovertyReturned const&>(::bug_report_replay->current_action()).cards);
        this->hand().add(cards);
        this->hand().remove(reshifted_cards);
        return reshifted_cards;
      }
    } // if (auto execute)
  } // bug report replay

  auto& hand = this->hand();
  hand.add(cards);

  HandCards res;
  unsigned rem = cards.size();

  // create Fehl for Heart
  if (   hand.count(Card::heart) > 0
      && hand.count(Card::heart) <= rem
      && this->game().rule()(Rule::Type::dullen)) {
    HandCards addon;

    for (auto const c : hand) {
      if (   c.color() == Card::heart
          && !c.istrump()) {
        addon.push_back(c);
      }
    }
    hand.remove(addon);
    res.insert(res.end(), addon.begin(), addon.end());
    rem -= addon.size();
  }

  // create Fehl for Club
  if( hand.count( Card::club ) > 0 && hand.count( Card::club ) <= rem )
  {
    bool ace_removed = false;
    if( hand.count( Card::club_ace ) == 2 )
    {
      hand.remove (Card::club_ace); // keep second ace.
      ace_removed = true;
    }

    HandCards addon;
    for( unsigned int i = 0; i < hand.cardsnumber(); i++ )
      if ( ( hand.card( i ).color() == Card::club ) && !hand.card(i).istrump() )
        addon.push_back( hand.card( i ) );
    hand.remove( addon );
    res.insert(res.end(), addon.begin(), addon.end());
    rem-= addon.size();

    if (ace_removed)
      hand.add( Card::club_ace );
  }


  // create Fehl for Spade
  if( hand.count( Card::spade ) > 0 && hand.count( Card::spade ) <= rem )
  {
    bool ace_removed = false;
    if( hand.count( Card::spade_ace ) == 2 )
    {
      hand.remove (Card::spade_ace); // keep second ace.
      ace_removed = true;
    }

    HandCards addon;
    for( unsigned int i = 0; i < hand.cardsnumber(); i++ )
      if( ( hand.card( i ).color() == Card::spade ) && !hand.card(i).istrump() )
        addon.push_back( hand.card( i ) );
    hand.remove( addon );
    res.insert(res.end(), addon.begin(), addon.end());
    rem-= addon.size();

    if (ace_removed)
      hand.add( Card::spade_ace );
  }

  // create Fehl for Heart
  if( hand.count( Card::heart ) > 0 && hand.count( Card::heart ) <= rem )
  {

    bool ace_removed = false;
    if( hand.count( Card::heart_ace ) == 2 )
    {
      hand.remove (Card::heart_ace); // keep second ace.
      ace_removed = true;
    }
    HandCards addon;
    for( unsigned int i = 0; i < hand.cardsnumber(); i++ )
      if( ( hand.card( i ).color() == Card::heart ) && !hand.card(i).istrump() )
        addon.push_back( hand.card( i ) );
    hand.remove( addon );
    res.insert(res.end(), addon.begin(), addon.end());
    rem-= addon.size();

    if (ace_removed)
      hand.add( Card::heart_ace );
  }


  while ( rem > 0 ) {
    //adding highest color card not ace
    if ( hand.count_trumps() < hand.cardsnumber()) {
      HandCard c;
      for( unsigned int i = 0; i < hand.cardsnumber(); i++ )
        if ( !hand.card( i ).istrump() )
          c = hand.card( i );

      if( !c.is_empty() )
      {
        for( unsigned int i = 0; i < hand.cardsnumber(); i++ )
          if ( !hand.card( i ).istrump() && c.less(hand.card( i )) )
            c = hand.card( i );

        hand.remove( c );
        res.push_back( c );
        rem--;
        continue;
      }
    }

    { // adding color card
      if (hand.count_trumps() < hand.cardsnumber()) {
        HandCard c;
        for (unsigned int i = 0; i < hand.cardsnumber(); i++) {
          if (!hand.card(i).istrump()) {
            c = hand.card(i);
          }
        }

        hand.remove(c);
        res.push_back(c);
        rem--;
        continue;
      }
    } // adding color card

    if (rem > 0 ) {
      // add low trump cards
      static vector<Card> const cards_to_check = {
        Card::diamond_nine,
        Card::diamond_king,
        Card::diamond_jack,
        Card::diamond_queen,
        Card::diamond_ten,
        Card::heart_jack,
        Card::spade_jack,
        Card::club_jack,
        Card::diamond_ace,
        Card::heart_queen,
        Card::spade_queen,
        Card::club_queen,
      };

      for (auto card = cards_to_check.begin(); rem > 0; ++card) {
        while ((hand.count(*card) > 0) && (rem > 0)) {
          auto c = HandCard(hand, *card);
          if (c.possible_swine() || c.possible_hyperswine() )
            break;
          hand.remove(c);
          res.push_back(c);
          rem--;
        }
      } // for (card)
    } // add low trump cards

  } // if ( rem > 0 )

  this->cards_information().reset();
  this->set_hand(hand); // to update the cards information

  return res;
}


/** gets the cards from the partner and add them to the hand
 **
 ** @param    cards   the cards that are given to the player
 **/
void
Ai::poverty_cards_get_back(HandCards const& cards)
{
  this->hand().add(cards);
  this->cards_information().reset();
  this->set_hand(this->hand()); // to update the cards information
}


/**  @return   limit card for some heuristic decisions
 **/
Card
Ai::trump_card_limit() const
{
  if (this->silent_marriage_)
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solocolor);

  switch (this->game().type()) {
  case GameType::solo_club:
  case GameType::solo_heart:
  case GameType::solo_spade:
  case GameType::solo_diamond:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solocolor);
  case GameType::solo_jack:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solojack);
  case GameType::solo_queen:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_soloqueen);
  case GameType::solo_king:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_soloking);
  case GameType::solo_queen_jack:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solojackqueen);
  case GameType::solo_king_jack:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solojackking);
  case GameType::solo_king_queen:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_soloqueenking);
  case GameType::solo_koehler:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_solokoehler);
  case GameType::solo_meatless:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_meatless);
  default:
    return this->Aiconfig::value(Aiconfig::Type::trumplimit_normal);
  }
}

/** @return   limit card for some heuristic decisions
 **/
Card
Ai::lowest_trump_card_limit() const
{
  if (this->silent_marriage_)
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solocolor);

  switch (this->game().type()) {
  case GameType::solo_club:
  case GameType::solo_heart:
  case GameType::solo_spade:
  case GameType::solo_diamond:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solocolor);
  case GameType::solo_jack:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solojack);
  case GameType::solo_queen:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_soloqueen);
  case GameType::solo_king:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_soloking);
  case GameType::solo_queen_jack:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solojackqueen);
  case GameType::solo_king_jack:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solojackking);
  case GameType::solo_king_queen:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_soloqueenking);
  case GameType::solo_koehler:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_solokoehler);
  case GameType::solo_meatless:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_meatless);
  default:
    return this->Aiconfig::value(Aiconfig::Type::lowest_trumplimit_normal);
  }
}

/** returns the selected partner for a genscher
 **
 ** @return   pointer to the partner
 **            nullptr if not to use the genscher
 **/
Player const*
Ai::genscher_partner()
{
  Player const* res = nullptr;

  // first find original teammate
  for ( unsigned i = 0; i < this->game().playerno(); i++ ) {
    if( this->teamofplayer( this->game().player(i) ) == this->team()
       && this->game().player(i) != *this)
    {
      res = &(this->game().player(i));
      break;
    }
  }
  /// @todo use teams after genscher...

  // check Specialpoints
  std::vector<int> bonusPoints( this->game().playerno(), 0 );
  for (auto const& t : this->trick_) {
    // DK: if hinzugefuegt
    if (!t.isempty())
      bonusPoints[t.winnerplayer().no()] += t.specialpoints().size() * 30;
  }

  // secure victory
  unsigned int points = 0;
  bool found = false;
  if ( this->game().points_of_team( this->team() ) < 120 )
    for ( unsigned i = 0; i < this->game().playerno(); i++ ) {
      if(   this->game().points_of_player( this->game().player(i) )
         + this->game().points_of_player( *this )
         > 120
         && (this->game().player(i) != *this )
         && this->game().points_of_player( this->game().player(i) )
         + bonusPoints[ i ] > points ) {
        res = &(this->game().player(i));
        points = this->game().points_of_player( this->game().player(i) )
          + bonusPoints[ i ] ;
        found = true;
      }
    }

  if (found)
    return res;

  for ( unsigned i = 0; i < this->game().playerno(); i++ ) {
    if (   (this->game().points_of_player(this->game().player(i))
            + bonusPoints[i]) > points
        && this->game().player(i) != *this) {
      points = (this->game().points_of_player(this->game().player(i))
                + bonusPoints[i]);
      res = &(this->game().player(i));
    }
  }

  Announcement highest_announcement = Announcement::noannouncement;
  // calculate highest announcements of this team
  for (auto const& p : this->game().players()) {
    if (p.team() == this->team()) {
      if (p.announcement() > highest_announcement )
        highest_announcement = p.announcement();
    }
  }

  if (   highest_announcement >= Announcement::no0
      && this->game().tricks().has_trick(opposite(this->team())))
    return res;

  if (   highest_announcement >= Announcement::no30
      && this->game().points_of_team(opposite(this->team())) >= 30)
    return res;

  if (   highest_announcement >= Announcement::no60
      && this->game().points_of_team(opposite(this->team())) >= 60)
    return res;

  if (   highest_announcement >= Announcement::no90
      && this->game().points_of_team(opposite(this->team())) >= 90)
    return res;

  // don't use genscher
  return {};
}