xref: /dports/games/freedoko/FreeDoko_0.7.19/src/player/aiconfig.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 "aiconfig.h"

#include "../party/party.h"
#include "../party/rule.h"
#include "../misc/preferences.h"
#include "../ui/ui.h"


/** -> result
 **
 ** @param    difficulty   difficulty of the returned ai
 **
 ** @return   the preset aiconfig of the given difficulty
 **/
Aiconfig const&
Aiconfig::preset(Difficulty const difficulty)
{
  DEBUG_ASSERTION( (difficulty != Difficulty::custom),
                  "Aiconfig::preset(Type::difficulty)\n"
                  "  difficulty is 'custom'");

  // just to get a warning when a new difficulty has been added
  switch (difficulty) {
  case Difficulty::custom:
  case Difficulty::standard:
  case Difficulty::careful:
  case Difficulty::offensive:
  case Difficulty::unfair:
    break;
  } // switch (difficulty)

  static map<Difficulty, unique_ptr<Aiconfig>> aiconfigs_with_nines;
  static map<Difficulty, unique_ptr<Aiconfig>> aiconfigs_without_nines;
  if (aiconfigs_with_nines.empty()) {
    { // standard
      aiconfigs_with_nines[Difficulty::standard] = make_unique<Aiconfig>();
    } // standard
    { // careful
      aiconfigs_with_nines[Difficulty::careful] = make_unique<Aiconfig>();
      auto& aiconfig = *aiconfigs_with_nines[Difficulty::careful];
      aiconfig.bool_[Type::trusting] = false;
      aiconfig.int_[Type::limitqueen] = 9;
      aiconfig.int_[Type::limitdulle] = 12;
      aiconfig.int_[Type::lastfehlcreation] = 4;
      aiconfig.int_[Type::first_trick_for_trump_points_optimization] = 5;
      aiconfig.int_[Type::announcelimit] = 11;
      aiconfig.int_[Type::announcelimitreply] = 10;
    } // careful
    { // offensive
      aiconfigs_with_nines[Difficulty::offensive] = make_unique<Aiconfig>();
      auto& aiconfig = *aiconfigs_with_nines[Difficulty::offensive];
      aiconfig.bool_[Type::trusting] = true;
      aiconfig.bool_[Type::aggressive] = true;
      aiconfig.int_[Type::limitqueen] = 7;
      aiconfig.int_[Type::limitdulle] = 10;
      aiconfig.int_[Type::lastfehlcreation] = 5;
      aiconfig.int_[Type::first_trick_for_trump_points_optimization] = 5;
      aiconfig.int_[Type::announcelimit] = 10;
      aiconfig.int_[Type::announcelimitreply] = 9;

      for (auto& states : aiconfig.heuristic_states_) {
        for (auto& state : states.second) {
          if (state.heuristic == Heuristic::grab_trick) {
            state.active = true;
          }
        }
      }
    } // offensive
    { // unfair
      aiconfigs_with_nines[Difficulty::unfair] = make_unique<Aiconfig>();
      auto& aiconfig = *aiconfigs_with_nines[Difficulty::unfair];
      aiconfig.bool_[Type::hands_known] = true;
    } // unfair
    // create configs without nines
    for (auto const difficulty : aiconfig_difficulty_list) {
      if (difficulty == Difficulty::custom)
        continue;
      aiconfigs_without_nines[difficulty]
        = make_unique<Aiconfig>(*aiconfigs_with_nines[difficulty]);
      auto& aiconfig = *aiconfigs_without_nines[difficulty];
      for (unsigned i = aiconfig.aitype_.size() / 2 + 1;
           i < aiconfig.aitype_.size(); ++i) {
        aiconfig.aitype_[i - 2] = aiconfig.aitype_[i];
      }
      for (unsigned i = aiconfig.rating_.size() / 2 + 1;
           i < aiconfig.rating_.size(); ++i) {
        aiconfig.rating_[i - 2] = aiconfig.rating_[i];
      }
      for (unsigned i = aiconfig.future_limit_.size() / 2 + 1;
           i < aiconfig.future_limit_.size(); ++i) {
        aiconfig.future_limit_[i - 2] = aiconfig.future_limit_[i];
      }
    }
  } // if (aiconfigs.empty())

  if (::party->rule()(Rule::Type::with_nines))
    return *aiconfigs_with_nines[difficulty];
  else
    return *aiconfigs_without_nines[difficulty];
}

/** @return   the (interesting) keys for the heuristic configuration
 **/
vector<HeuristicsMap::Key> const&
Aiconfig::keys()
{
  static vector<HeuristicsMap::Key> const keys = {
    {HeuristicsMap::GameTypeGroup::normal, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::normal, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::marriage_undetermined, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::marriage_undetermined, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::marriage_silent, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::marriage_silent, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::poverty, HeuristicsMap::PlayerTypeGroup::special},
    {HeuristicsMap::GameTypeGroup::poverty, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::poverty, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::soli_color, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::soli_color, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::soli_single_picture, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::soli_single_picture, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::soli_double_picture, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::soli_double_picture, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::solo_koehler, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::solo_koehler, HeuristicsMap::PlayerTypeGroup::contra},
    {HeuristicsMap::GameTypeGroup::solo_meatless, HeuristicsMap::PlayerTypeGroup::re},
    {HeuristicsMap::GameTypeGroup::solo_meatless, HeuristicsMap::PlayerTypeGroup::contra},
  };

  return keys;
}

/** -> result
 **
 ** @param    type   aitype
 **
 ** @return   whether the aitype has support for the rating
 **/
bool
supports_rating(AiType const type)
{
  switch(type) {
  case AiType::no_choosebestcard:
  case AiType::random:
  case AiType::virtual_games:
    return false;
  case AiType::gametree:
  case AiType::gametree_with_heuristics:
  case AiType::gametree_for_team:
  case AiType::monte_carlo:
  case AiType::monte_carlo_jab_or_serve:
    return true;
  }; // switch (type)

  DEBUG_ASSERTION(false,
                  "::support_rating(type)\n"
                  "  unsupported type '" << type << "'");
  return false;
}

/** constructor
 **/
Aiconfig::Aiconfig() :
  aitype_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  rating_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  future_limit_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  heuristic_states_(),
  update_level_(0)
{
  this->reset_to_hardcoded();
}

/** constructor
 **
 ** @param    difficulty   difficulty to set
 **/
Aiconfig::Aiconfig(Difficulty const difficulty) :
  aitype_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  rating_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  future_limit_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  heuristic_states_(),
  update_level_(0)
{
  this->reset_to_hardcoded();
  this->set_to_difficulty(difficulty);
}

/** constructor
 **
 ** @param    istr   stream with the infos
 **/
Aiconfig::Aiconfig(istream& istr) :
  aitype_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  rating_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  future_limit_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  heuristic_states_(),
  update_level_(0)
{
  (void)this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                   HeuristicsMap::PlayerTypeGroup::re)];
#ifdef WORKAROUND
  this->init_heuristic_states();
#endif
  this->read(istr);
}

/** constructor
 **
 ** @param    istr         stream with the infos
 ** @param    difficulty   difficulty to set
 **/
Aiconfig::Aiconfig(istream& istr, Difficulty const difficulty) :
  difficulty_(difficulty),
  aitype_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  rating_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  future_limit_(::party->rule()(Rule::Type::max_number_of_tricks_in_game)),
  heuristic_states_(),
  update_level_(1)
{
  (void)this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                   HeuristicsMap::PlayerTypeGroup::re)];
#ifdef WORKAROUND
  this->init_heuristic_states();
#endif
  this->read(istr);
  DEBUG_ASSERTION(this->update_level_ == 1,
                  "Aiconfig::Aiconfig(istr, difficulty)\n"
                  "  this->update_level_ = " << this->update_level_ << " is not 1");
  this->update_level_ = 0;

  this->difficulty_ = difficulty;
}

/** copy constructor
 **
 ** @param    aiconfig   aiconfig to copy
 **/
Aiconfig::Aiconfig(Aiconfig const& aiconfig) :
  difficulty_(aiconfig.difficulty_),
  aitype_(aiconfig.aitype_),
  rating_(aiconfig.rating_),
  future_limit_(aiconfig.future_limit_),
  heuristic_states_(aiconfig.heuristic_states_),
  bool_(aiconfig.bool_),
  int_(aiconfig.int_),
  card_(aiconfig.card_),
  update_level_(0)
{ }

/** copy operator
 **
 ** @param    aiconfig   aiconfig to copy
 **
 ** @return   aiconfig
 **/
Aiconfig&
Aiconfig::operator=(Aiconfig const& aiconfig)
{
  if (this == &aiconfig)
    return *this;

  this->enter_update();
  this->difficulty_ = aiconfig.difficulty_;
  for (unsigned t = 0; t < ::party->rule()(Rule::Type::max_number_of_tricks_in_game);
       ++t) {
    this->set_aitype(t, aiconfig.aitype(t));
    this->set_rating(t, aiconfig.rating(t));
    this->set_future_limit(t, aiconfig.future_limit(t));
  }
  this->heuristic_states_ = aiconfig.heuristic_states_;
  for (auto const type : Aiconfig::Type::bool_list)
    this->set(type, aiconfig.value(type));
  for (auto const type : Aiconfig::Type::int_list)
    this->set(type, aiconfig.value(type));
  for (auto const type : Aiconfig::Type::card_list)
    this->set(type, aiconfig.value(type));
  this->difficulty_ = aiconfig.difficulty();

  this->leave_update(this->difficulty());

  return *this;
}

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

  /**
   ** resets the aiconfig to the default values
   **
   ** @param    no   number of the player
   **                  default: 'UINT_MAX'
   **/
void
Aiconfig::reset_to_hardcoded(unsigned const no)
{

  switch (no) {
  case UINT_MAX:
    break;
  default:
    this->set_to_difficulty(Difficulty::standard);
    return ;
  } // switch (no)

  this->enter_update();

  this->set(Type::trusting,                               false);
  this->set(Type::aggressive,                             false);
  this->set(Type::hands_known,                            false);
  this->set(Type::teams_known,                            false);
  this->set(Type::estimate_hands, true);
  this->set(Type::fehlcreationonfirstcard,                false);

  this->set(Type::remembertricks,                           12);

  this->set(Type::limit_throw_fehl,                          8);
  this->set(Type::limitqueen,                                9);
  this->set(Type::limitdulle,                               12);

  this->set(Type::lastfehlcreation,                          3);
  this->set(Type::last_tricks_without_heuristics,            3);
  this->set(Type::first_trick_for_trump_points_optimization, 4);

  this->set(Type::announcelimit,                            11);
  this->set(Type::announcelimitdec,                          1);
  this->set(Type::announceconfig,                            1);
  this->set(Type::announcelimitreply,                       10);
  this->set(Type::announceconfigreply,                       1);

  this->set(Type::limitthrowing,                   Card::diamond_queen);

  this->set(Type::trumplimit_solocolor,            Card::diamond_queen);
  this->set(Type::trumplimit_solojack,             Card::diamond_jack);
  this->set(Type::trumplimit_soloqueen,            Card::diamond_queen);
  this->set(Type::trumplimit_soloking,             Card::diamond_king);
  this->set(Type::trumplimit_solojackking,         Card::club_jack);
  this->set(Type::trumplimit_solojackqueen,        Card::club_jack);
  this->set(Type::trumplimit_soloqueenking,        Card::club_queen);
  this->set(Type::trumplimit_solokoehler,          Card::club_queen);
  this->set(Type::trumplimit_meatless,             Card::diamond_ten);
  this->set(Type::trumplimit_normal,               Card::heart_queen);

  this->set(Type::lowest_trumplimit_solocolor,     Card::heart_jack);
  this->set(Type::lowest_trumplimit_solojack,      Card::heart_jack);
  this->set(Type::lowest_trumplimit_soloqueen,     Card::heart_queen);
  this->set(Type::lowest_trumplimit_soloking,      Card::heart_king);
  this->set(Type::lowest_trumplimit_solojackking,  Card::spade_jack);
  this->set(Type::lowest_trumplimit_solojackqueen, Card::spade_jack);
  this->set(Type::lowest_trumplimit_soloqueenking, Card::spade_queen);
  this->set(Type::lowest_trumplimit_solokoehler,   Card::spade_queen);
  this->set(Type::lowest_trumplimit_meatless,      Card::diamond_queen);
  this->set(Type::lowest_trumplimit_normal,        Card::diamond_jack);

  this->set(Type::limithigh,                       Card::heart_queen);

  this->aitype_[ 0] = AiType::monte_carlo_jab_or_serve;
  this->aitype_[ 1] = AiType::monte_carlo_jab_or_serve;
  this->aitype_[ 2] = AiType::virtual_games;
  this->aitype_[ 3] = AiType::virtual_games;
  this->aitype_[ 4] = AiType::virtual_games;
  this->aitype_[ 5] = AiType::virtual_games;
  this->aitype_[ 6] = AiType::virtual_games;
  this->aitype_[ 7] = AiType::virtual_games;
  this->aitype_[ 8] = AiType::gametree_for_team;
  this->aitype_[ 9] = AiType::gametree_for_team;
  this->aitype_[10] = AiType::gametree_for_team;
  this->aitype_[11] = AiType::gametree_for_team;
  this->rating_[ 0] = Rating::Type::linear;
  this->rating_[ 1] = Rating::Type::linear;
  this->rating_[ 2] = Rating::Type::linear;
  this->rating_[ 3] = Rating::Type::linear;
  this->rating_[ 4] = Rating::Type::linear;
  this->rating_[ 5] = Rating::Type::linear;
  this->rating_[ 6] = Rating::Type::linear;
  this->rating_[ 7] = Rating::Type::linear;
  this->rating_[ 8] = Rating::Type::linear;
  this->rating_[ 9] = Rating::Type::linear;
  this->rating_[10] = Rating::Type::linear;
  this->rating_[11] = Rating::Type::linear;
  this->future_limit_[ 0] = 2000;
  this->future_limit_[ 1] = 2000;
  this->future_limit_[ 2] = 10000;
  this->future_limit_[ 3] = 10000;
  this->future_limit_[ 4] = 10000;
  this->future_limit_[ 5] = 10000;
  this->future_limit_[ 6] = 10000;
  this->future_limit_[ 7] = 10000;
  this->future_limit_[ 8] = 10000;
  this->future_limit_[ 9] = 10000;
  this->future_limit_[10] = 10000;
  this->future_limit_[11] = 10000;

  this->init_heuristic_states();

  this->difficulty_ = Difficulty::standard;
  this->leave_update(Difficulty::standard);
} // void Aiconfig::reset_to_hardcoded(unsigned no = UINT_MAX)

/** sets the aiconfig to the preset difficulty
 **
 ** @param    difficulty   difficulty to set to
 **/
void
Aiconfig::set_to_difficulty(Difficulty const difficulty)
{
  if (difficulty == Difficulty::custom)
    return ;

  *this = Aiconfig::preset(difficulty);
  if (::ui != nullptr)
    ::ui->aiconfig_changed(*this);
}

/** the rule has changed
 **
 ** @param    type        rule type to have changed
 ** @param    old_value   old value of the rule
 **/
void
Aiconfig::rule_changed(int const type, void const* const old_value)
{
  if (type == Rule::Type::with_nines) {
    if (this->difficulty() != Difficulty::custom) {
      auto const difficulty = this->difficulty();
      this->difficulty_ = Difficulty::custom;
      this->set_to_difficulty(difficulty);
    }
  } // if (type == Rule::Type::with_nines)
}

/** @return    the difficulty
 **/
Aiconfig::Difficulty
Aiconfig::difficulty() const
{ return this->difficulty_; }

/** updates the difficulty
 **/
void
Aiconfig::update_difficulty()
{
  if (this->in_update())
    return ;

  auto difficulty = Difficulty::custom;
  for (auto const d : aiconfig_difficulty_list) {
    if (   (d != Difficulty::custom)
        && this->equal(Aiconfig::preset(d))) {
      difficulty = d;
      break;
    }
  }

  if (difficulty == this->difficulty())
    return ;

  this->difficulty_ = difficulty;
  if (::ui)
    ::ui->aiconfig_changed(*this);
}

/** @return   whether the aiconfig is in an update
 **/
bool
Aiconfig::in_update() const
{
  return (this->update_level_ > 0);
}

/** begin a (nested) update
 **/
void
Aiconfig::enter_update()
{
  this->update_level_ += 1;
}

/** end a (nested) update
 ** if the last update level is ended, update the difficulty
 **/
void
Aiconfig::leave_update()
{
  DEBUG_ASSERTION((this->update_level_ > 0) && (this->update_level_ < 9999),
                  "Aiconfig::leave_update()\n"
                  "  update_level is not > 0 / < 9999: " << this->update_level_);
  this->update_level_ -= 1;
  if (this->update_level_ == 0)
    this->update_difficulty();
}

/** end a (nested) update
 ** if the last update level is ended, set the difficulty manual
 **
 ** @param    difficulty   difficulty to set to
 **/
void
Aiconfig::leave_update(Difficulty const difficulty)
{
  DEBUG_ASSERTION(this->update_level_ > 0,
                  "Aiconfig::leave_update()\n"
                  "  update_level is not > 0: " << this->update_level_);
  this->update_level_ -= 1;
  if (this->update_level_ == 0)
    this->difficulty_ = difficulty;
}

/** comparison with the aiconfig
 **
 ** @param    aiconfig   aiconfig to compare with
 **
 ** @return   whether aiconfig has the same values as the argument
 **/
bool
Aiconfig::equal(Aiconfig const& aiconfig) const
{
  return (   (this->aitype_          == aiconfig.aitype_)
          && (this->future_limit_    == aiconfig.future_limit_)
          && (this->rating_          == aiconfig.rating_)
          && (this->heuristic_states_ == aiconfig.heuristic_states_)
          && (this->bool_             == aiconfig.bool_)
          && (this->int_              == aiconfig.int_)
          && (this->card_             == aiconfig.card_) );
}

/** -> result
 **
 ** @param    trickno   trick number
 **
 ** @return   the aitype for trick 'trickno'
 **/
AiType
Aiconfig::aitype(unsigned const trickno) const
{
#if 0
  if (::game_status == GameStatus::game_play
      && trickno == 7
      && this->aitype_[trickno] != AiType::gametree_for_team)
    SEGFAULT;
#endif
  return this->aitype_[trickno];
  return this->aitype_[trickno];
} // AiType const& Aiconfig::aitye(unsigned const trickno) const;

/** sets the aitype for trick 'trickno'
 **
 ** @param    trickno   trick number
 ** @param    aitype   new aitype
 **/
void
Aiconfig::set_aitype(unsigned const trickno, AiType const aitype)
{
#ifdef WORKAROUND
  if (trickno >= this->future_limit_.size()) {
    return ;
  }
#endif
  this->enter_update();
  this->aitype_[trickno] = aitype;
  this->leave_update();
}

/** sets the aitype for all tricks
 **
 ** @param    aitype   new aitype
 **/
void
Aiconfig::set_aitype_for_all_tricks(AiType const aitype)
{
  this->enter_update();
  for (unsigned i = 0; i < this->aitype_.size(); ++i)
    this->set_aitype(i, aitype);
  this->leave_update();
}

/** -> result
 **
 ** @param    trickno   trick number
 **
 ** @return   the future limit for trick 'trickno'
 **/
unsigned
Aiconfig::future_limit(unsigned const trickno) const
{
  return this->future_limit_[trickno];
}

/** sets the future limit for trick 'trickno'
 **
 ** @param    trickno   trick number
 ** @param    future_limit   new future limit
 **/
void
Aiconfig::set_future_limit(unsigned const trickno, unsigned const future_limit)
{
#ifdef WORKAROUND
  if (trickno >= this->future_limit_.size()) {
    return ;
  }
#endif
  this->enter_update();
  this->future_limit_[trickno] = future_limit;
  this->leave_update();
}

/** sets the future limit for all tricks
 **
 ** @param    future_limit   new future limit
 **/
void
Aiconfig::set_future_limit_for_all_tricks(unsigned const future_limit)
{
  this->enter_update();
  for (unsigned i = 0; i < this->future_limit_.size(); ++i)
    this->set_future_limit(i, future_limit);
  this->leave_update();
}

/** -> result
 **
 ** @param    trickno   trick number
 **
 ** @return   the rating for trick 'trickno'
 **/
Rating::Type
Aiconfig::rating(unsigned const trickno) const
{
  return this->rating_[trickno];
}

/** sets the rating for trick 'trickno'
 **
 ** @param    trickno   trick number
 ** @param    rating    new rating
 **/
void
Aiconfig::set_rating(unsigned const trickno, Rating::Type const rating)
{
#ifdef WORKAROUND
  if (trickno >= this->rating_.size()) {
    return ;
  }
#endif

  this->enter_update();
  this->rating_[trickno] = rating;
  this->leave_update();
}

/** sets the rating for all tricks
 **
 ** @param    rating   new rating for all tricks
 **/
void
Aiconfig::set_rating_for_all_tricks(Rating::Type const rating)
{
  this->enter_update();
  for (unsigned i = 0; i < this->rating_.size(); ++i)
    this->set_rating(i, rating);
  this->leave_update();
}

/** -> result
 **
 ** @param    key     the key
 **
 ** @return   the heuristic states for the given key
 **/
vector<Aiconfig::HeuristicState> const&
Aiconfig::heuristic_states(HeuristicsMap::Key const key) const
{
  auto states = this->heuristic_states_.find(key);

  // if there is no special take a default one
  if (   (states == this->heuristic_states_.end())
      || states->second.empty()) {
    if (   (key.gametype_group == HeuristicsMap::GameTypeGroup::solo_meatless)
        && (key.playertype_group == HeuristicsMap::PlayerTypeGroup::contra) )
      return this->heuristic_states(HeuristicsMap::GameTypeGroup::solo_meatless,
                                    HeuristicsMap::PlayerTypeGroup::re);

    if (key.gametype_group == HeuristicsMap::GameTypeGroup::normal)
      return this->heuristic_states(HeuristicsMap::GameTypeGroup::normal, HeuristicsMap::PlayerTypeGroup::re);

    return this->heuristic_states(HeuristicsMap::GameTypeGroup::normal, key.playertype_group);
  } // if (states.empty())

  return states->second;
}

/** -> result
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 **
 ** @return   the heuristic states for the given groups
 **/
vector<Aiconfig::HeuristicState> const&
Aiconfig::heuristic_states(HeuristicsMap::GameTypeGroup const gametype_group,
                           HeuristicsMap::PlayerTypeGroup const playertype_group
                          ) const
{
  return this->heuristic_states(HeuristicsMap::Key(gametype_group,
                                                   playertype_group));
}

/** -> result
 **
 ** @param    key     the key
 **
 ** @return   the heuristic states for the given key
 **/
vector<Aiconfig::HeuristicState>&
Aiconfig::heuristic_states(HeuristicsMap::Key const key)
{
  auto states = this->heuristic_states_.find(key);

  // if there is no special take a default one
  if (states == this->heuristic_states_.end()) {
    if (   (key.gametype_group == HeuristicsMap::GameTypeGroup::solo_meatless)
        && (key.playertype_group == HeuristicsMap::PlayerTypeGroup::contra) )
      return this->heuristic_states(HeuristicsMap::GameTypeGroup::solo_meatless,
                                    HeuristicsMap::PlayerTypeGroup::re);

    if (key.gametype_group == HeuristicsMap::GameTypeGroup::normal)
      return this->heuristic_states(HeuristicsMap::GameTypeGroup::normal, HeuristicsMap::PlayerTypeGroup::re);

    return this->heuristic_states(HeuristicsMap::GameTypeGroup::normal, key.playertype_group);
  } // if (states.empty())

  return states->second;
}

/** -> result
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 **
 ** @return   the heuristic states for the given groups
 **/
vector<Aiconfig::HeuristicState>&
Aiconfig::heuristic_states(HeuristicsMap::GameTypeGroup const gametype_group,
                           HeuristicsMap::PlayerTypeGroup const playertype_group
                          )
{
  return this->heuristic_states(HeuristicsMap::Key(gametype_group,
                                                   playertype_group));
}

/** -> result
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 **
 ** @return   the heuristics for the given groups
 **/
vector<Aiconfig::Heuristic>
Aiconfig::heuristics(HeuristicsMap::GameTypeGroup const gametype_group,
                     HeuristicsMap::PlayerTypeGroup const playertype_group
                    ) const
{
  auto const& states
    = this->heuristic_states(gametype_group, playertype_group);

  vector<Heuristic> heuristics;
  heuristics.push_back(Heuristic::only_one_valid_card);
  for (auto const state : states)
    if (state.active)
      heuristics.push_back(state.heuristic);

  heuristics.push_back(Heuristic::choose_best_card);
  return heuristics;
}

/** -> result
 **
 ** @param    player   player
 **
 ** @return   the heuristics for the player
 **/
vector<Aiconfig::Heuristic>
Aiconfig::heuristics(Player const& player) const
{
  return this->heuristics(HeuristicsMap::group(player.game()),
                          HeuristicsMap::group(player));
}

/** initializes the heuristic states
 **/
void
Aiconfig::init_heuristic_states()
{
  this->enter_update();
  this->heuristic_states_.clear();
  (void)this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                   HeuristicsMap::PlayerTypeGroup::re)];


  { // normal
    vector<HeuristicState>& states
      = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                   HeuristicsMap::PlayerTypeGroup::re)];
    states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
    states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
    states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
    states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
    states.push_back(HeuristicState(Heuristic::play_color_for_partner_ace, true));
    states.push_back(HeuristicState(Heuristic::choose_ten, true));
    states.push_back(HeuristicState(Heuristic::jab_for_doppelkopf, true));
    states.push_back(HeuristicState(Heuristic::try_for_doppelkopf, true));
    states.push_back(HeuristicState(Heuristic::pfund_in_first_color_run, true));
    states.push_back(HeuristicState(Heuristic::choose_for_color_trick, true));
    states.push_back(HeuristicState(Heuristic::pfund_in_first_color_run, true));
    states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
    states.push_back(HeuristicState(Heuristic::jab_fox, true));
    states.push_back(HeuristicState(Heuristic::choose_pfund, true));
    states.push_back(HeuristicState(Heuristic::choose_pfund_before_partner, true));
    states.push_back(HeuristicState(Heuristic::jab_for_ace, true));
    states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
    states.push_back(HeuristicState(Heuristic::play_for_team, true));
    states.push_back(HeuristicState(Heuristic::play_color_for_partner, true));
    states.push_back(HeuristicState(Heuristic::try_color_for_partner, true));
    states.push_back(HeuristicState(Heuristic::start_with_color,               false));
    states.push_back(HeuristicState(Heuristic::retry_color, true));
    states.push_back(HeuristicState(Heuristic::jab_color_trick_with_dulle, true));
    states.push_back(HeuristicState(Heuristic::save_dulle, true));
    states.push_back(HeuristicState(Heuristic::partner_backhand_draw_trump, true));
    states.push_back(HeuristicState(Heuristic::create_fehl, true));
    states.push_back(HeuristicState(Heuristic::jab_to_win, true));
    states.push_back(HeuristicState(Heuristic::last_player_pass_small_trick, true));
    states.push_back(HeuristicState(Heuristic::cannot_jab, true));
    states.push_back(HeuristicState(Heuristic::best_winning, true));
    states.push_back(HeuristicState(Heuristic::draw_trump, true));
    states.push_back(HeuristicState(Heuristic::play_to_jab_later, true));
    states.push_back(HeuristicState(Heuristic::start_with_low_color,           false));
    states.push_back(HeuristicState(Heuristic::start_with_low_trump, true));
    states.push_back(HeuristicState(Heuristic::low_high, true));
    states.push_back(HeuristicState(Heuristic::play_for_partner_worries, true));
    states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
    states.push_back(HeuristicState(Heuristic::play_trump, true));
    states.push_back(HeuristicState(Heuristic::play_bad_color, true));
    states.push_back(HeuristicState(Heuristic::jab_color_over_fox, true));

    { // contra
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                     HeuristicsMap::PlayerTypeGroup::contra)]
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                     HeuristicsMap::PlayerTypeGroup::re)];
      for (auto & state : states) {
        switch (state.heuristic) {
        case Heuristic::start_with_color:
          state.active = true;
          break;
        case Heuristic::start_with_low_color:
          state.active = true;
          break;
        case Heuristic::start_with_low_trump:
          state.active = false;
          break;
        default:
          break;
        } // switch (s->heuristic)
      } // for (s)
    } // contra
  } // normal
  { // poverty
    { // soloplayer
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::poverty,
                                                     HeuristicsMap::PlayerTypeGroup::special)];
      states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
      states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
      states.push_back(HeuristicState(Heuristic::play_color_for_partner_ace, true));
      states.push_back(HeuristicState(Heuristic::choose_ten, true));
      states.push_back(HeuristicState(Heuristic::play_color_for_partner, true));
      states.push_back(HeuristicState(Heuristic::try_color_for_partner, true));
      states.push_back(HeuristicState(Heuristic::choose_pfund_poverty, true));
      states.push_back(HeuristicState(Heuristic::poverty_special_play_pfund, true));
      states.push_back(HeuristicState(Heuristic::poverty_special_give_no_points, true));
      states.push_back(HeuristicState(Heuristic::poverty_special_offer_pfund, true));
      states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
      states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
      states.push_back(HeuristicState(Heuristic::play_bad_color, true));
    } // soloplayer
    { // re
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::poverty,
                                                     HeuristicsMap::PlayerTypeGroup::re)];
      states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
      states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
      states.push_back(HeuristicState(Heuristic::choose_ten, true));
      states.push_back(HeuristicState(Heuristic::create_fehl, true));
      states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
      states.push_back(HeuristicState(Heuristic::pfund_in_first_color_run, true));
      states.push_back(HeuristicState(Heuristic::choose_for_color_trick, true));
      states.push_back(HeuristicState(Heuristic::poverty_re_trump_color_trick_high, true));
      states.push_back(HeuristicState(Heuristic::jab_to_win, true));
      states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
      states.push_back(HeuristicState(Heuristic::draw_trump, true));
      states.push_back(HeuristicState(Heuristic::play_to_jab_later, true));
      states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
      states.push_back(HeuristicState(Heuristic::poverty_re_play_trump, true));
      states.push_back(HeuristicState(Heuristic::poverty_best_winning_card, true));
      states.push_back(HeuristicState(Heuristic::play_trump, true));
      states.push_back(HeuristicState(Heuristic::jab_color_over_fox, true));
    } // re

    { // contra
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::poverty,
                                                     HeuristicsMap::PlayerTypeGroup::contra)];
      states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
      states.push_back(HeuristicState(Heuristic::play_color_for_partner, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
      states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
      states.push_back(HeuristicState(Heuristic::choose_ten, true));
      states.push_back(HeuristicState(Heuristic::poverty_contra_play_color, true));
      states.push_back(HeuristicState(Heuristic::poverty_contra_trump_color_trick_high, true));
      states.push_back(HeuristicState(Heuristic::choose_pfund, true));
      states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
      states.push_back(HeuristicState(Heuristic::pfund_in_first_color_run, true));
      states.push_back(HeuristicState(Heuristic::choose_for_color_trick, true));
      states.push_back(HeuristicState(Heuristic::poverty_leave_to_partner, true));
      states.push_back(HeuristicState(Heuristic::poverty_overjab_re, true));
      states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
      states.push_back(HeuristicState(Heuristic::partner_backhand_draw_trump, true));
      states.push_back(HeuristicState(Heuristic::jab_fox, true));
      states.push_back(HeuristicState(Heuristic::play_for_partner_worries, true));
      states.push_back(HeuristicState(Heuristic::choose_pfund_before_partner, true));
      states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
      states.push_back(HeuristicState(Heuristic::best_winning, true));
      states.push_back(HeuristicState(Heuristic::jab_color_over_fox, true));
    } // contra
  } // poverty

  { // solo
    { // color
      { // soloplayer
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_color,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
        states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
        states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
        states.push_back(HeuristicState(Heuristic::choose_ten, true));
        states.push_back(HeuristicState(Heuristic::color_jab_for_ace, true));
        states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
        states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
        states.push_back(HeuristicState(Heuristic::best_winning, true));
        states.push_back(HeuristicState(Heuristic::color_low_high, true));
        states.push_back(HeuristicState(Heuristic::draw_trump, true));
        states.push_back(HeuristicState(Heuristic::play_to_jab_later, true));
        states.push_back(HeuristicState(Heuristic::jab_to_win, true));
        states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
      } // soloplayer
      { // contra
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_color,
                                                       HeuristicsMap::PlayerTypeGroup::contra)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
        for (auto & state : states) {
          switch (state.heuristic) {
          case Heuristic::start_with_low_color:
            state.active = true;
            break;
          case Heuristic::jab_for_ace:
            state.heuristic = Heuristic::color_jab_for_ace;
            break;
          case Heuristic::low_high:
            state.heuristic = Heuristic::color_low_high;
            break;
          case Heuristic::start_with_color:
            state.heuristic = Heuristic::play_color_in_solo;
            state.active = true;
            break;
          case Heuristic::partner_backhand_draw_trump:
            state.active = false;
            break;
          default:
            break;
          } // switch (s->heuristic)
        } // for (s \in states)

        // ToDo: add partner_backhand_draw_trump
      } // contra
    } // color
    { // single picture
      { // soloplayer
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
        states.push_back(HeuristicState(Heuristic::picture_pull_down_color, true));
        states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
        states.push_back(HeuristicState(Heuristic::picture_get_last_trumps, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_solo_ace, true));
        states.push_back(HeuristicState(Heuristic::picture_draw_trumps, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
        states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
        states.push_back(HeuristicState(Heuristic::picture_start_with_highest_color, true));
        states.push_back(HeuristicState(Heuristic::picture_play_last_trumps, true));
        states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
        states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
        states.push_back(HeuristicState(Heuristic::picture_jab_color_trick_for_sure, true));
        states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
        states.push_back(HeuristicState(Heuristic::choose_ten, true));
        states.push_back(HeuristicState(Heuristic::color_jab_for_ace, true));
        states.push_back(HeuristicState(Heuristic::best_winning, true));
        states.push_back(HeuristicState(Heuristic::color_low_high, true));
        states.push_back(HeuristicState(Heuristic::jab_to_win, true));
        states.push_back(HeuristicState(Heuristic::play_trump, true));
        states.push_back(HeuristicState(Heuristic::create_fehl, true));
      } // soloplayer
      { // contra
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::contra)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
        for (auto & state : states) {
          switch (state.heuristic) {
          case Heuristic::choose_ten:
            state.heuristic = Heuristic::play_color_for_partner_ace;
            break;
          case Heuristic::play_color_for_partner_ace:
            state.heuristic = Heuristic::choose_ten;
            break;
          case Heuristic::start_with_low_color:
            state.active = true;
            break;
          case Heuristic::start_with_color:
            state.heuristic = Heuristic::play_color_in_solo;
            state.active = true;
            break;
          case Heuristic::partner_backhand_draw_trump:
            state.active = false;
            break;
          case Heuristic::pfund_in_first_color_run:
            state.active = false;
            break;
          default:
            break;
          } // switch (s->heuristic)
        } // for (s \in states)
      } // contra
    } // single picture
    { // double picture
      { // soloplayer
          this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_double_picture,
                                                     HeuristicsMap::PlayerTypeGroup::re)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
      } // soloplayer
      { // contra
        this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_double_picture,
                                                   HeuristicsMap::PlayerTypeGroup::contra)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::contra)];
      } // contra
    } // double picture
    { // koehler
      { // soloplayer
        this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::solo_koehler,
                                                   HeuristicsMap::PlayerTypeGroup::re)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
      } // soloplayer
      { // contra
        this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::solo_koehler,
                                                   HeuristicsMap::PlayerTypeGroup::contra)]
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_single_picture,
                                                       HeuristicsMap::PlayerTypeGroup::contra)];
      } // contra
    } // koehler
    { // meatless
      { // soloplayer
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::solo_meatless,
                                                       HeuristicsMap::PlayerTypeGroup::re)];
        states.push_back(HeuristicState(Heuristic::picture_pull_down_color, true));
        states.push_back(HeuristicState(Heuristic::meatless_retry_last_color, true));
        states.push_back(HeuristicState(Heuristic::meatless_start_with_best_color, true));
        states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
        states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
      } // soloplayer
      { // contra
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::solo_meatless,
                                                       HeuristicsMap::PlayerTypeGroup::contra)];
        states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
        states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
        states.push_back(HeuristicState(Heuristic::choose_pfund, true));
        states.push_back(HeuristicState(Heuristic::create_fehl, true));
      } // contra
    } // meatless
  } // solo
  { // marriage
    { // undetermined marriage
      this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::marriage_undetermined,
                                                 HeuristicsMap::PlayerTypeGroup::re)]
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::normal,
                                                     HeuristicsMap::PlayerTypeGroup::re)];

      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::marriage_undetermined,
                                                     HeuristicsMap::PlayerTypeGroup::re)];

      states.insert(states.begin(),
                    HeuristicState(Heuristic::play_to_get_married, true));
      states.insert(states.begin(),
                    HeuristicState(Heuristic::start_with_color_solo_ace, true));

      {
        vector<HeuristicState>& states
          = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::marriage_undetermined,
                                                       HeuristicsMap::PlayerTypeGroup::contra)];
        states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));

        states.push_back(HeuristicState(Heuristic::play_to_marry, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
        states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
        states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
        states.push_back(HeuristicState(Heuristic::play_color_for_partner_ace, true));
        states.push_back(HeuristicState(Heuristic::choose_ten, true));
        states.push_back(HeuristicState(Heuristic::jab_for_doppelkopf, true));
        states.push_back(HeuristicState(Heuristic::try_for_doppelkopf, true));
        states.push_back(HeuristicState(Heuristic::pfund_in_first_color_run, true));
        states.push_back(HeuristicState(Heuristic::choose_for_color_trick, true));
        states.push_back(HeuristicState(Heuristic::serve_color_trick, true));
        states.push_back(HeuristicState(Heuristic::jab_fox, true));
        states.push_back(HeuristicState(Heuristic::choose_pfund, true));
        states.push_back(HeuristicState(Heuristic::choose_pfund_before_partner, true));
        states.push_back(HeuristicState(Heuristic::jab_for_ace, true));
        states.push_back(HeuristicState(Heuristic::play_for_team, true));
        states.push_back(HeuristicState(Heuristic::play_color_for_partner, true));
        states.push_back(HeuristicState(Heuristic::try_color_for_partner, true));
        states.push_back(HeuristicState(Heuristic::retry_color, true));
        states.push_back(HeuristicState(Heuristic::jab_color_trick_with_dulle, true));
        states.push_back(HeuristicState(Heuristic::save_dulle, true));
        states.push_back(HeuristicState(Heuristic::partner_backhand_draw_trump, true));
        states.push_back(HeuristicState(Heuristic::create_fehl, true));
        states.push_back(HeuristicState(Heuristic::best_winning, true));
        states.push_back(HeuristicState(Heuristic::draw_trump, true));
        states.push_back(HeuristicState(Heuristic::play_to_jab_later, true));
        states.push_back(HeuristicState(Heuristic::low_high, true));
        states.push_back(HeuristicState(Heuristic::jab_to_win, true));
        states.push_back(HeuristicState(Heuristic::serve_trump_trick, true));
        states.push_back(HeuristicState(Heuristic::play_for_partner_worries, true));
        states.push_back(HeuristicState(Heuristic::play_bad_color, true));
        states.push_back(HeuristicState(Heuristic::jab_color_over_fox, true));
      }
    } // undetermined marriage
    { // silent marriage
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::marriage_silent,
                                                     HeuristicsMap::PlayerTypeGroup::re)];
      states.push_back(HeuristicState(Heuristic::choose_best_card_in_last_tricks, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_single_ace, true));
      states.push_back(HeuristicState(Heuristic::start_with_color_double_ace, true));
      states.push_back(HeuristicState(Heuristic::jab_with_color_ace, true));
      states.push_back(HeuristicState(Heuristic::choose_ten, true));
      states.push_back(HeuristicState(Heuristic::color_jab_for_ace, true));
      states.push_back(HeuristicState(Heuristic::best_winning, true));
      states.push_back(HeuristicState(Heuristic::color_low_high, true));
      states.push_back(HeuristicState(Heuristic::draw_trump, true));
      states.push_back(HeuristicState(Heuristic::play_to_jab_later, true));
      states.push_back(HeuristicState(Heuristic::play_highest_color_card_in_game, true));
      states.push_back(HeuristicState(Heuristic::jab_to_win, true));

      this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::marriage_silent,
                                                 HeuristicsMap::PlayerTypeGroup::contra)]
        = this->heuristic_states_[HeuristicsMap::Key(HeuristicsMap::GameTypeGroup::soli_color,
                                                     HeuristicsMap::PlayerTypeGroup::contra)];
    } // silent marriage
  } // marriage

  this->fill_up_heuristic_states();
  this->leave_update();
}

/** fills up the heuristic states so that all real heuristics are included
 **/
void
Aiconfig::fill_up_heuristic_states()
{
  this->enter_update();
  for (auto& heuristic_state : this->heuristic_states_) {
    vector<HeuristicState>& states = heuristic_state.second;

    std::set<Heuristic> heuristics;
    for (auto const heuristic : aiconfig_heuristic_list) {
      if (is_real(heuristic))
        heuristics.insert(heuristic);
    }

    for (auto const& s : states)
      heuristics.erase(s.heuristic);

    for (auto const heuristic : heuristics)
      states.push_back(HeuristicState(heuristic, false));

  }

  this->leave_update();
}

/** -> result
 **
 ** @param    key         the group key
 ** @param    heuristic   the heuristic type
 **
 ** @return   the value of the heuristic in the given context
 **/
bool
Aiconfig::value(HeuristicsMap::Key const key,
                Heuristic const heuristic) const
{
  vector<HeuristicState> const&
    states = this->heuristic_states(key);

  for (auto state : states)
    if (state.heuristic == heuristic)
      return state.active;

  return false;
}

/** -> result
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 ** @param    heuristic          the heuristic type
 **
 ** @return   the value of the heuristic 'type in the given context
 **/
bool
Aiconfig::value(HeuristicsMap::GameTypeGroup const gametype_group,
                HeuristicsMap::PlayerTypeGroup const playertype_group,
                Heuristic const heuristic) const
{
  return this->value(HeuristicsMap::Key(gametype_group, playertype_group),
                     heuristic);
}

/** -> result
 **
 ** @param    type   the bool type
 **
 ** @return   the value of the aiconfig 'type'
 **/
bool
Aiconfig::value(Type::Bool const type) const
{
  return this->bool_[type];
}

/** -> result
 **
 ** @param    type   the unsigned type
 **
 ** @return   the value of the aiconfig 'type'
 **/
int
Aiconfig::value(Type::Int const type) const
{
  return this->int_[type];
}

/** -> result
 **
 ** @param    type   the card type
 **
 ** @return   the value of the aiconfig 'type'
 **/
Card
Aiconfig::value(Type::Card const type) const
{
  return this->card_[type];
}

/** -> result
 **
 ** @param    type   config type
 **
 ** @return   minimal value for the type
 **/
int
Aiconfig::min(Type::Int const type) const
{
  switch(type) {
  case Type::remembertricks:
  case Type::lastfehlcreation:
  case Type::last_tricks_without_heuristics:
  case Type::first_trick_for_trump_points_optimization:
    return 0;

  case Type::limit_throw_fehl:
  case Type::limitqueen:
  case Type::limitdulle:
    return 0;

  case Type::announcelimit:
  case Type::announcelimitdec:
  case Type::announceconfig:
  case Type::announcelimitreply:
  case Type::announceconfigreply:
    return 0;
  } // switch(type)

  return UINT_MAX;
}

/** -> result
 **
 ** @param    type   config type
 **
 ** @return   maximum value for the type
 **/
int
Aiconfig::max(Type::Int const type) const
{
  switch(type) {
  case Type::remembertricks:
  case Type::lastfehlcreation:
  case Type::last_tricks_without_heuristics:
  case Type::first_trick_for_trump_points_optimization:
    // when changing 'with nines' -> 'without nines' -> 'with nines'
    // it should keep '12'
    //return ::party->rule()(Rule::Type::number_of_tricks_in_game);
    return static_cast<int>(::party->rule()(Rule::Type::max_number_of_tricks_in_game));

  case Type::limit_throw_fehl:
  case Type::limitqueen:
  case Type::limitdulle:
    return 33;

  case Type::announcelimit:
  case Type::announcelimitdec:
  case Type::announceconfig:
  case Type::announcelimitreply:
  case Type::announceconfigreply:
    return 1000;
  } // switch(type)

  return UINT_MAX;
}


/** -> result
 **
 ** @param    type   config type
 **
 ** @return   the valid cards
 **/
vector<Card> const&
Aiconfig::valid_cards(Type::Card const type) const
{
  switch(type) {
  case Type::limitthrowing:
  case Type::limithigh:

  case Type::trumplimit_normal:
  case Type::lowest_trumplimit_normal:
  case Type::trumplimit_solocolor:
  case Type::lowest_trumplimit_solocolor:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_queen);
        valid_cards.push_back(Card::spade_queen);
        valid_cards.push_back(Card::heart_queen);
        valid_cards.push_back(Card::diamond_queen);
        valid_cards.push_back(Card::club_jack);
        valid_cards.push_back(Card::spade_jack);
        valid_cards.push_back(Card::heart_jack);
        valid_cards.push_back(Card::diamond_jack);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_solojack:
  case Type::lowest_trumplimit_solojack:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_jack);
        valid_cards.push_back(Card::spade_jack);
        valid_cards.push_back(Card::heart_jack);
        valid_cards.push_back(Card::diamond_jack);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_soloqueen:
  case Type::lowest_trumplimit_soloqueen:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_queen);
        valid_cards.push_back(Card::spade_queen);
        valid_cards.push_back(Card::heart_queen);
        valid_cards.push_back(Card::diamond_queen);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_soloking:
  case Type::lowest_trumplimit_soloking:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_king);
        valid_cards.push_back(Card::spade_king);
        valid_cards.push_back(Card::heart_king);
        valid_cards.push_back(Card::diamond_king);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_solojackking:
  case Type::lowest_trumplimit_solojackking:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_king);
        valid_cards.push_back(Card::spade_king);
        valid_cards.push_back(Card::heart_king);
        valid_cards.push_back(Card::diamond_king);
        valid_cards.push_back(Card::club_jack);
        valid_cards.push_back(Card::spade_jack);
        valid_cards.push_back(Card::heart_jack);
        valid_cards.push_back(Card::diamond_jack);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_solojackqueen:
  case Type::lowest_trumplimit_solojackqueen:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_queen);
        valid_cards.push_back(Card::spade_queen);
        valid_cards.push_back(Card::heart_queen);
        valid_cards.push_back(Card::diamond_queen);
        valid_cards.push_back(Card::club_jack);
        valid_cards.push_back(Card::spade_jack);
        valid_cards.push_back(Card::heart_jack);
        valid_cards.push_back(Card::diamond_jack);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_soloqueenking:
  case Type::lowest_trumplimit_soloqueenking:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_king);
        valid_cards.push_back(Card::spade_king);
        valid_cards.push_back(Card::heart_king);
        valid_cards.push_back(Card::diamond_king);
        valid_cards.push_back(Card::club_queen);
        valid_cards.push_back(Card::spade_queen);
        valid_cards.push_back(Card::heart_queen);
        valid_cards.push_back(Card::diamond_queen);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_solokoehler:
  case Type::lowest_trumplimit_solokoehler:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::club_king);
        valid_cards.push_back(Card::spade_king);
        valid_cards.push_back(Card::heart_king);
        valid_cards.push_back(Card::diamond_king);
        valid_cards.push_back(Card::club_queen);
        valid_cards.push_back(Card::spade_queen);
        valid_cards.push_back(Card::heart_queen);
        valid_cards.push_back(Card::diamond_queen);
        valid_cards.push_back(Card::club_jack);
        valid_cards.push_back(Card::spade_jack);
        valid_cards.push_back(Card::heart_jack);
        valid_cards.push_back(Card::diamond_jack);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  case Type::trumplimit_meatless:
  case Type::lowest_trumplimit_meatless:
    {
      static vector<Card> valid_cards;
      if (valid_cards.empty()) {
        valid_cards.push_back(Card::diamond_ace);
        valid_cards.push_back(Card::diamond_ten);
        valid_cards.push_back(Card::diamond_king);
        valid_cards.push_back(Card::diamond_queen);
        valid_cards.push_back(Card::diamond_jack);
        valid_cards.push_back(Card::diamond_nine);
      } // if (valid.cards.empty())

      return valid_cards;
    }
  } // switch(type)

  {
    static vector<Card> valid_cards;
    return valid_cards;
  }
}

/** sets 'type' to 'value'
 **
 ** @param    type   Aiconfigtype
 ** @param    value   new value
 **
 ** @return   'true', if the type is valid, otherwise 'false'
 **/
bool
Aiconfig::set(string const type, string const value)
{
#ifdef DEPRECATED
  // 0.7.6 replacing
  if (type == "fairplay hands") {
    this->set(Type::teams_known, !(   (value == "true")
                                   || (value == "yes")
                                   || (value == "1") ) );
    return true;
  }
  if (type == "fairplay teams") {
    this->set(Type::hands_known, !(   (value == "true")
                                   || (value == "yes")
                                   || (value == "1")) );
    return true;
  }
#endif
  for (auto const t : Aiconfig::Type::bool_list) {
    if (type == to_string(t)) {
      this->set(t, value);
      return true;
    }
  }
  for (auto const t : Aiconfig::Type::int_list) {
    if (type == to_string(t)) {
      this->set(t, value);
      return true;
    }
  }
  for (auto const t : Aiconfig::Type::card_list) {
    if (type == to_string(t)) {
      this->set(t, value);
      return true;
    }
  }

  return false;
}

/** activates/deactivates the heuristic in the given context
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 ** @param    heuristic          the heuristic type
 ** @param    value              new value
 **/
void
Aiconfig::set(HeuristicsMap::GameTypeGroup const gametype_group,
              HeuristicsMap::PlayerTypeGroup const playertype_group,
              Heuristic const heuristic,
              string const value)
{
  if (   (value != "true")
      && (value != "false")
      && (value != "yes")
      && (value != "no")
      && (value != "0")
      && (value != "1")) {
    cerr << "Aiconfig::set(GameTypeGroup, PlayerTypeGroup, Heuristic, value)\n"
      << "  illegal value '" << value << "' for '" << heuristic << "', "
      << "must be a boolean ('true' or 'false' or 'yes' or 'no' or '1' or '0')."
      << '\n'
      << "  Taking 'false'."
      << endl;
  }
  this->set(gametype_group, playertype_group, heuristic,
            (   (value == "true")
             || (value == "yes")
             || (value == "1")) );
}

/** sets 'type' to 'value'
 **
 ** @param    type   Aiconfigtype
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Bool const type, string const value)
{
  if (   (value != "true")
      && (value != "false")
      && (value != "yes")
      && (value != "no")
      && (value != "0")
      && (value != "1")) {
    cerr << "Aiconfig::set(Bool, value)\n"
      << "  illegal value '" << value << "' for '" << type << "', "
      << "must be a boolean ('true' or 'false' or 'yes' or 'no' or '1' or '0')."
      << '\n'
      << "  Taking 'false'."
      << endl;
  }
  this->set(type, (  (   (value == "false")
                      || (value == "no")
                      || (value == "0") )
                   ? false
                   : true) );
}

/** sets 'type' to 'value'
 **
 ** @param    type   Aiconfigtype
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Int const type, string const value)
{
  char* end_ptr;
  unsigned number = strtoul(value.c_str(), &end_ptr, 0);
  if (*end_ptr != '\0') {
    cerr << "Aiconfig::set(Int, value)\n"
      << "illegal value '" << value << "' for '" << type << "', "
      << "must be a digit.\n"
      << "  Taking " << number << "."
      << endl;
  }

  this->set(type, number);
}

/** sets 'type' to 'value'
 **
 ** @param    type   Aiconfigtype
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Card const type, string const value)
{
  this->set(type, Card(value));
}


/** activates/deactivates the heuristic in the given context
 **
 ** @param    key         the context key
 ** @param    heuristic   the heuristic type
 ** @param    value       new value
 **/
void
Aiconfig::set(HeuristicsMap::Key const key,
              Heuristic const heuristic,
              bool const value)
{
  this->set(key.gametype_group, key.playertype_group, heuristic, value);
}

/** activates/deactivates the heuristic in the given context
 **
 ** @param    gametype_group     the game type group
 ** @param    playertype_group   the player type group
 ** @param    heuristic          the heuristic type
 ** @param    value              new value
 **/
void
Aiconfig::set(HeuristicsMap::GameTypeGroup const gametype_group,
              HeuristicsMap::PlayerTypeGroup const playertype_group,
              Heuristic const heuristic,
              bool const value)
{
  this->enter_update();
  vector<HeuristicState>&
    states = this->heuristic_states(gametype_group, playertype_group);

  for (auto & state : states)
    if (state.heuristic == heuristic) {
      state.active = value;
      return;
    }
  states.push_back(HeuristicState(heuristic, value));

  this->leave_update();
}

/** sets the heuristics map to the default one
 **
 ** @param    key     the context key
 **/
void
Aiconfig::set_to_default(HeuristicsMap::Key const key)
{
  this->enter_update();
  this->heuristic_states(key)
    = this->heuristic_states(HeuristicsMap::Key());
  this->leave_update();
}

/** moves the heuristic to the given position
 ** all heuristics below are moved one position further
 **
 ** @param    key         the key of the heuristic group
 ** @param    heuristic   the heuristic type
 ** @param    pos         new position
 **/
void
Aiconfig::move(HeuristicsMap::Key const key,
               Heuristic const heuristic,
               unsigned const pos)
{
  vector<HeuristicState>&
    states = this->heuristic_states(key);

  if (states[pos].heuristic == heuristic)
    return ;

  if (pos > states.size())
    return ;

  this->enter_update();

  vector<HeuristicState>::iterator s;
  for (s = states.begin();
       s != states.end();
       ++s)
    if (s->heuristic == heuristic)
      break;

  if (s == states.end()) {
    states.insert(states.begin() + pos, HeuristicState(heuristic, false));
  } else { // if !(s == states.end())
    HeuristicState const state = *s;
    states.erase(s);
    states.insert(states.begin() + pos, state);
  } // if !(s == states.end())

  this->leave_update();
}

/** sets the aiconfig 'type' to the value 'value'
 **
 ** @param    type   heuristic type
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Bool const type, bool const value)
{
  this->enter_update();
  this->bool_[type] = value;
  this->leave_update();
}

/** sets the aiconfig 'type' to the value 'value'
 **
 ** @param    type   heuristic type
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Int const type, int const value)
{
  this->enter_update();
  this->int_[type] = value;
  this->leave_update();
}

/** sets the aiconfig 'type' to the value 'value'
 **
 ** @param    type   heuristic type
 ** @param    value   new value
 **/
void
Aiconfig::set(Type::Card const type, Card const value)
{
  this->enter_update();
  this->card_[type] = value;
  this->leave_update();
}

/** @param    ostr	output stream
 **
 ** write only different values into the output stream
 **/
void
Aiconfig::write(ostream& ostr) const
{
  if (this->difficulty() != Difficulty::custom) {
    ostr << "difficulty = " << to_string(this->difficulty()) << '\n';
    return ;
  } // if (this->difficulty() != custom)

  auto const difficulty = this->difficulty_with_min_differences();
  ostr << "difficulty = " << to_string(difficulty) << '\n';
  this->write_differences(ostr, difficulty);
}

/** @return   difficulty with the minimum differcences
 **/
Aiconfig::Difficulty
Aiconfig::difficulty_with_min_differences() const
{
  Difficulty difficulty_min = Difficulty::custom;
  unsigned differences_min = UINT_MAX;
  for (auto const difficulty : aiconfig_difficulty_list) {
    if (difficulty == Difficulty::custom)
      continue;
    auto const differences = this->count_differences(difficulty);
    if (differences < differences_min) {
      difficulty_min = difficulty;
      differences_min = differences;
    }
  }
  return difficulty_min;
}

/** @return   number of differences to 'difficulty'
 **/
unsigned
Aiconfig::count_differences(Difficulty difficulty) const
{
  Aiconfig const& preset_aiconfig = Aiconfig::preset(difficulty);
  // the number of differences
  unsigned differences = 0;

  { // check the values
    for (auto const type : Aiconfig::Type::bool_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        differences += 1;
      }
    }
    for (auto const type : Aiconfig::Type::int_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        differences += 1;
      }
    }
    for (auto const type : Aiconfig::Type::card_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        differences += 1;
      }
    }
  } // check the values
  { // check the ai types
    for (unsigned t = 0;
         t < ::party->rule()(Rule::Type::max_number_of_tricks_in_game);
         t++) {
      if (this->aitype(t) != preset_aiconfig.aitype(t)) {
        differences += 1;
      }
      if (this->rating(t) != preset_aiconfig.rating(t)) {
        differences += 1;
      }
      if (this->future_limit(t) != preset_aiconfig.future_limit(t)) {
        differences += 1;
      }
    }
  } // check the ai types
  { // check the heuristics
    for (auto const key : Aiconfig::keys()) {
      if (this->heuristic_states(key)
          != preset_aiconfig.heuristic_states(key)) {
        differences += 5;
      }
    }
  } // check the heuristics
  return differences;
}

/** write only differcences values into the output stream
 **
 ** @param    ostr         output stream
 ** @param    difficulty   difficulty to compare with
 **/
void
Aiconfig::write_differences(ostream& ostr,
                            Aiconfig::Difficulty const difficulty) const
{
  std::ios_base::fmtflags const flags = ostr.flags();
  ostr << std::boolalpha;

  Aiconfig const& preset_aiconfig = Aiconfig::preset(difficulty);

  { // check the values
    for (auto const type : Aiconfig::Type::bool_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        ostr << "  "
          << type << " = "
          << (this->value(type) ? "true" : "false")
          << '\n';
      }
    }
    for (auto const type : Aiconfig::Type::int_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        ostr << "  "
          << type << " = "
          << this->value(type)
          << '\n';
      }
    }
    for (auto const type : Aiconfig::Type::card_list) {
      if (this->value(type) != preset_aiconfig.value(type)) {
        ostr << "  "
          << type << " = "
          << this->value(type)
          << '\n';
      }
    }
  } // check the values
  { // check the ai types
    for (unsigned t = 0;
         t < ::party->rule()(Rule::Type::max_number_of_tricks_in_game);
         t++) {
      if (this->aitype(t) != preset_aiconfig.aitype(t)) {
        ostr << "  "
          << "type         = " << setw(2) << t << ": "
          << this->aitype(t) << '\n';
      }
    }
    for (unsigned t = 0;
         t < ::party->rule()(Rule::Type::max_number_of_tricks_in_game);
         t++) {
      if (this->rating(t) != preset_aiconfig.rating(t)) {
        ostr << "  "
          << "rating       = " << setw(2) << t << ": "
          << this->rating(t) << '\n';
      }
    }
    for (unsigned t = 0;
         t < ::party->rule()(Rule::Type::max_number_of_tricks_in_game);
         t++) {
      if (this->future_limit(t) != preset_aiconfig.future_limit(t)) {
        ostr
          << "  "
          << "future limit = " << setw(2) << t << ": "
          << this->future_limit(t) << '\n';
      } // if (value differs)
    } // for (t \in number of tricks)
  } // check the ai types
  { // check the heuristics
    auto const& keys = Aiconfig::keys();
    bool first_difference = true;

    for (auto const key : keys) {
      if (this->heuristic_states(key)
          != preset_aiconfig.heuristic_states(key)) {
        { // write the differences
          if (first_difference) {
            ostr << "heuristics" << '\n'
              << "{\n";
            first_difference = false;
          } // if (first_difference)

          ostr << "  "
            << key.gametype_group << " - "
            << key.playertype_group << '\n'
            << "  {\n";
          for (auto const h : this->heuristic_states(key)) {
            ostr
              << "    "
              << h.heuristic << " = "
              << (h.active ? "true" : "false") << '\n';
          }
          ostr << "  }\n";
        } // write the differences
      } // if (heuristic states differ)
    } // for (key : keys)

    if (!first_difference) {
      // there was a difference
      ostr << "}\n";
    } // if (!first_difference)

  } // check the heuristics

  ostr.flags(flags);
}

/** write all values into the output streams
 **
 ** @param    ostr   output stream
 **/
void
Aiconfig::write_full(ostream& ostr) const
{
  ostr << "# difficulty = " << to_string(this->difficulty()) << '\n';
  std::ios_base::fmtflags const flags = ostr.flags();
  ostr << std::boolalpha;

  for (unsigned i = 0; i < this->aitype_.size(); ++i)
    ostr << "type         = " << setw(2) << i << ": "
      << this->aitype(i) << '\n';
  for (unsigned i = 0; i < this->aitype_.size(); ++i)
    ostr << "future limit = " << setw(2) << i << ": "
      << this->future_limit(i) << '\n';
  for (unsigned i = 0; i < this->aitype_.size(); ++i)
    ostr << "rating       = " << setw(2) << i << ": "
      << this->rating(i) << '\n';
  ostr << '\n';
  ostr << '\n';

  ostr << "# bool\n";
  for (auto const type : Aiconfig::Type::bool_list) {
    ostr << type << " = " << (this->value(type) ? "true" : "false") << '\n';
  }
  ostr << '\n';

  ostr << "# unsigned\n";
  for (auto const type : Aiconfig::Type::int_list) {
    ostr << type << " = " << this->value(type) << '\n';
  }
  ostr << '\n';

  ostr << "# card\n";
  for (auto const type : Aiconfig::Type::card_list) {
    ostr << type << " = " << this->value(type) << '\n';
  }

  ostr << '\n';
  ostr << "#heuristics" << '\n';
  ostr << "heuristics" << '\n'
    << "{\n";
  for (const auto & heuristic_state : this->heuristic_states_) {
    ostr << "  "
      << heuristic_state.first.gametype_group << " - " << heuristic_state.first.playertype_group << '\n'
      << "  {\n";
    for (auto const& h : heuristic_state.second)
      ostr << "    " << h.heuristic << " = " << (h.active ? "true" : "false") << '\n';
    ostr << "  }\n";
  } // for (s \in this->heuristic_states_)
  ostr << "}\n";

  ostr.flags(flags);
}

/** loads the infos from the file
 **
 ** @param    filename   file to load the aiconfig from
 **
 ** @return   whether the loading was successful
 **/
bool
Aiconfig::load(string const filename)
{
  {
    ifstream istr(filename.c_str());
    if (istr.good()) {
      return this->read(istr);
    }
  }
  {
    ifstream istr((::preferences(Preferences::Type::private_data_directory)
                   + "/" + ::preferences(Preferences::Type::ai_directory)
                   + "/" + filename).c_str());
    if (istr.good()) {
      return this->read(istr);
    }
  }
  {
    ifstream istr((::preferences(Preferences::Type::public_data_directory)
                   + "/" + ::preferences(Preferences::Type::ai_directory)
                   + "/" + filename).c_str());
    if (istr.good()) {
      return this->read(istr);
    }
  }

  return false;
}

/** reads the infos from the stream
 **
 ** @param    istr   stream with the infos
 **
 ** @return   whether the reading was successful
 **/
bool
Aiconfig::read(istream& istr)
{
  this->enter_update();

  unsigned depth = 0;

  this->reset_to_hardcoded();

  // read the configuration
  while (istr.good()) {
    Config config;
    istr >> config;
    if (!istr.good())
      break;

    // finished with the config file
    if ((config.name == "") && (config.value == ""))
      break;

    if (config.separator) {
      // a setting
      if (config.name == "difficulty") {
        try {
          this->set_to_difficulty(aiconfig_difficulty_from_string(config.value));
        } catch (std::ios_base::failure const& error) {
          cerr << "Aiconfig::read()\n"
            << error.what()
            << endl;
        }
      } else if (config.name == "type") {
        try {
          stringstream istr(config.value);

          // tricknumber
          unsigned trickno;
          istr >> trickno;
          if (!istr.good()) {
            throw config.value;
          }

          // separator
          if (istr.peek() != ':')
            throw config.value;
          istr.get();

          while (std::isspace(istr.peek())
                 && istr.good())
            istr.get();

          if (!istr.good())
            throw config.value;

          // aitype
          string aitype;
          std::getline(istr, aitype);
          this->set_aitype(trickno, aitype_from_string(aitype));
        } catch (string const& value) {
          cerr << "aiconfig: "
            << "unknown aitype '" << value << "'."
            << endl;
        } // try
      } else if (config.name == "future limit") {
        try {
          stringstream istr(config.value);

          // tricknumber
          unsigned trickno;
          istr >> trickno;
          if (!istr.good()) {
            throw config.value;
          }

          // separator
          if (istr.peek() != ':') {
            throw config.value;
          }
          istr.get();

          while (std::isspace(istr.peek())
                 && istr.good())
            istr.get();

          if (!istr.good()) {
            throw config.value;
          }

          // future limit
          unsigned future_limit;
          istr >> future_limit;
          if (istr.fail()) {
            throw config.value;
          }

          this->set_future_limit(trickno, future_limit);
        } // try
        catch (string const& value) {
          cerr << "aiconfig: "
            << "illegal future limit '" << value << "'."
            << endl;
        }
      } else if (config.name == "rating") {
        try {
          stringstream istr(config.value);

          // tricknumber
          unsigned trickno;
          istr >> trickno;
          if (!istr.good()) {
            throw config.value;
          }

          // separator
          if (istr.peek() != ':') {
            throw config.value;
          }
          istr.get();

          while (std::isspace(istr.peek())
                 && istr.good())
            istr.get();

          if (!istr.good()) {
            throw config.value;
          }

          // rating
          string rating;
          std::getline(istr, rating);

          {
            auto const r = Rating::type_from_string(rating);
            this->set_rating(trickno, r);
          }

        } catch (string const& value) {
          cerr << "rating type: "
            << "unknown rating type '" << value << "'."
            << endl;
        }
      } else {
        if (!this->set(config.name, config.value)) {
          cerr << "aiconfig: "
            << "unknown config '" << config.name << "'."
            << endl;
        }
      } // if (config.name == "type")
    } else { // if (config.separator)
      // a setting
      // if the value is in parentencies, remove both
      if(config.name == "!end") {
        // ignore the rest of the file
        break;
      } else if(config.name == "!stdout") {
        // output of the data to 'stdout'
        cout << config.value << endl;
      } else if(config.name == "!stderr") {
        // output of the data to 'stderr'
        cerr << config.value << endl;
      } else if(config.name == "{") {
        depth += 1;
      } else if(config.name == "}") {
        if (depth == 0) {
          cerr << "Aiconfig: found a '}' without a '{' before.\n"
            << "Finish reading the the file."
            << endl;
          break;
        } // if (depth == 0)
        depth -= 1;
        if (depth == 0)
          break;
      } else if(config.name == "heuristics") {
        this->read_heuristics(istr);
      } else if(config.name == "") {
        cerr << "Aiconfig: "
          << "Ignoring line \'" << config.value << "\'.\n";
      } else {
        cerr << "Aiconfig: "
          << "type '" << config.name << "' unknown.\n"
          << "Ignoring it.\n";
      } // if (config.name == .)
    } // config.separator
  } // while (istr.good())

  this->leave_update();
  return istr.good();
}

/** reads the heuristics
 **
 ** @param    istr   input stream
 **
 ** @return   whether the reading was successful
 **/
bool
Aiconfig::read_heuristics(istream& istr)
{
  this->enter_update();
  unsigned depth = 0;
  string line;
  while (istr.good()) {
    std::getline(istr, line);
    if (!istr.good())
      break;

    while (   !line.empty()
           && isspace(*line.begin()))
      line.erase(line.begin());

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

    if (line.empty())          { // empty line
    } else if (line[0] == '#') { // comment
    } else if (line == "{")    { // block open
      depth += 1;
    } else if (line == "}")    { // block close
      if (depth == 0) {
        cerr << "Aiconfig: found a '}' without a '{' before.\n"
          << "Finish reading the the file."
          << endl;
        break;
      } // if (depth == 0)
      depth -= 1;
      if (depth == 0)
        break;
    } else                     { // gametype group - playertype group
      string::size_type const pos = line.find('-');
      if (pos == string::npos) {
        cerr << "unknown line '" << line << "'\n"
          << "ignoring it" << endl;
        continue;
      } // if (pos == string::npos)

      string gametype_group_string(line, 0, pos);
      while (   !gametype_group_string.empty()
             && isspace(*gametype_group_string.rbegin()))
        gametype_group_string.erase(gametype_group_string.size() - 1);
      string playertype_group_string(line, pos + 1, string::npos);
      while (   !playertype_group_string.empty()
             && isspace(*playertype_group_string.begin()))
        playertype_group_string.erase(playertype_group_string.begin());

      HeuristicsMap::GameTypeGroup const gametype_group
        = HeuristicsMap::GameTypeGroup_from_name(gametype_group_string);
      HeuristicsMap::PlayerTypeGroup const playertype_group
        = HeuristicsMap::PlayerTypeGroup_from_name(playertype_group_string);

      unsigned depth2 = 0;
      vector<HeuristicState>& states
        = this->heuristic_states_[HeuristicsMap::Key(gametype_group,
                                                     playertype_group)];
      states.clear();
      while (istr.good()) {
        Config config;
        istr >> config;
        if (!istr.good())
          break;

        if (config.separator) {
          Heuristic const heuristic = Heuristic_from_name(config.name);
          if (is_real(heuristic)) {
            bool const active = (   (config.value == "true")
                                 || (config.value == "yes")
                                 || (config.value == "1"));
            states.push_back(HeuristicState(heuristic, active));
          } // if (is_real(heuristic))
        } else { // if (config.separator)
          if(config.name == "{") {
            depth2 += 1;
          } else if(config.name == "}") {
            if (depth2 == 0) {
              cerr << "Aiconfig: found a '}' without a '{' before.\n"
                << "Finish reading the the file."
                << endl;
              break;
            } // if (depth2 == 0)
            depth2 -= 1;
            if (depth2 == 0)
              break;
          } else if(config.name == "") {
            cerr << "Aiconfig: "
              << "Ignoring line \'" << config.value << "\'.\n";
          } else {
            cerr << "Aiconfig: "
              << "type '" << config.name << "' unknown.\n"
              << "Ignoring it.\n";
          } // if (config.name == .)
        } // config.separator
      } // while (istr.good())
    } // if (line == ...)
  } // while (istr.good())

  this->fill_up_heuristic_states();

  this->leave_update();
  return istr.good();
}

/** save the infos in the file
 **
 ** @param    filename   file to save the aiconfig
 **
 ** @return   whether the saving was successful
 **/
bool
Aiconfig::save(string const filename) const
{
  string filename_tmp = filename + ".tmp";
  ofstream ostr(filename_tmp.c_str());
  if (!ostr.good()) {
    ::ui->information(_("Error::Aiconfig::save: Error opening temporary file %s. Aborting saving.", filename_tmp), InformationType::problem);
    return false;
  }

  ostr << "# FreeDoko ai configuration (" << *::version << ")\n"
    << '\n';
  this->write(ostr);

  if (!ostr.good()) {
    ::ui->information(_("Error::Aiconfig::save: Error saving in temporary file %s. Keeping temporary file (for bug tracking).", filename_tmp), InformationType::problem);
    return false;
  }
  ostr.close();

#ifdef WINDOWS
  unlink(filename.c_str());
#endif
  if (rename(filename_tmp.c_str(), filename.c_str())) {
    ::ui->information(_("Error::Aiconfig::save: Could not rename temporary file %s to requested file %s. Keeping temporary file.", filename_tmp, filename), InformationType::problem);
    return false;
  }

  return true;
}

/** comparison of two aiconfigs
 **
 ** @param    lhs   first aiconfig
 ** @param    rhs   second aiconfig
 **
 ** @return   whether the two aiconfigs are equal
 **/
bool
operator==(Aiconfig const& lhs, Aiconfig const& rhs)
{
  return lhs.equal(rhs);
}

/** comparison of two aiconfigs
 **
 ** @param    lhs   first aiconfig
 ** @param    rhs   second aiconfig
 **
 ** @return   whether the two aiconfigs are different
 **/
bool
operator!=(Aiconfig const& lhs, Aiconfig const& rhs)
{
  return !(lhs == rhs);
}

/** comparison of two heuristic states
 **
 ** @param    heuristic_state_a   first heuristic state
 ** @param    heuristic_state_b   second heuristic state
 **
 ** @return   whether the two heuristic states are equal
 **/
bool
operator==(Aiconfig::HeuristicState const lhs,
           Aiconfig::HeuristicState const rhs)
{
  return (   (lhs.heuristic == rhs.heuristic)
          && (lhs.active == rhs.active) );
}

/** writes the aiconfig into the output stream
 **
 ** @param    ostr       stream to write in
 ** @param    aiconfig   aiconfig to write
 **
 ** @return   output stream
 **/
ostream&
operator<<(ostream& ostr, Aiconfig const& aiconfig)
{
  aiconfig.write(ostr);

  return ostr;
}