xref: /dports/games/freedoko/FreeDoko_0.7.19/src/game/announcements.cpp

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

#include "constants.h"
#include "game.h"
#include "gameplay.h"
#include "gameplay_actions/announcement.h"
#include "../party/rule.h"
#include "../ui/ui.h"

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

/** constructor
 **
 ** @param    announcements   announcements to copy
 ** @param    game   corresponding game
 **/
Announcements::Announcements(Announcements const& announcements,
                             Game& game) :
  game_(&game),
  announcements_(announcements.announcements_)
{ }

/** -> result
 **
 ** @param    team   the team
 **
 ** @return   the announcement of the team 'team'
 **/
AnnouncementWithTrickno
Announcements::last(Team const team) const
{
  auto const& game = *this->game_;
  DEBUG_ASSERTION(   (team == Team::re)
                  || (team == Team::contra)
                  || game.marriage().is_undetermined(),
                  "Announcements::last(team)\n"
                  "  invalid team = " << team);

  // In an undetermined marriage the contra team cannot have announced.
  // This case is treated here, because in this case there does not
  // exists a player of the team 'contra' so the assertion later on would fail.
  if (   game.marriage().is_undetermined()
      && (team != Team::re) )
    return {};

  // the player of the team, that has made the highest announcement
  Player const* player = nullptr;
  auto const& rule = game.rule();

  // take the highest announcement
  for (auto const& p : game.players()) {
    if (   rule(Rule::Type::knocking)
        && !is_real(game.teaminfo().get(p)))
      continue;

    if (p.team() == team)
      if (!player
          || (this->last(p).announcement
              > this->last(*player).announcement))
        player = &p;
  } // for (p : this->players())

  if (   rule(Rule::Type::knocking)
      && !player)
    return {};

  if (!player) {
    DEBUG_ASSERTION(game.isvirtual(),
                    "Announcements::last(team):\n"
                    "  no player of team '" << team << "' found!");
    return {};
  }

  return this->last(*player);
} // AnnouncementWithTrickno Announcements::last(Team team) const

/** -> result
 **
 ** @param    player   the player
 **
 ** @return   the highest announcement of player 'player'
 **/
AnnouncementWithTrickno
Announcements::last(Player const& player) const
{
  auto const& announcements = this->announcements_[player.no()];
  if (announcements.empty())
    return {};
  return announcements.back();
}

/** -> result
 **
 ** @param    player   the player
 **
 ** @return   all announcements of player 'player'
 **/
vector<AnnouncementWithTrickno> const&
Announcements::all(Player const& player) const
{
  return this->announcements_[player.no()];
}

/** initializion for a new game
 **/
void
Announcements::init()
{
  auto const& game = *this->game_;
  auto const& rule = game.rule();
  auto const number_of_players = rule(Rule::Type::number_of_players_in_game);
  this->announcements_
    = vector<vector<AnnouncementWithTrickno>>(number_of_players);
}

/** remove all announcements but re and contra
 **/
void
Announcements::remove_all_but_re_contra()
{
  auto const& game = *this->game_;
  for (unsigned p = 0; p < game.players().size(); p++) {
    auto const& player = game.players().player(p);
    auto& announcements = this->announcements_[p];
    if (announcements.size() <= 1)
      continue;
    if (is_reply(announcements.front().announcement)) {
      announcements.erase(announcements.begin() + 1,
                          announcements.end());
      continue;
    }
    // the player has made an announcement
    announcements.erase(announcements.begin() + 2,
                        announcements.end());
    announcements[1].announcement = Announcement::no120;
    if (!game.isvirtual()) {
      ::ui->announcement_made(Announcement::no120, player);
      this->signal_announcement_made_(Announcement::no120, player);
    }
  } // for (p < this->playerno())
}

/** request announcements from the players
 **/
void
Announcements::request_from_players()
{
  auto& game = *this->game_;
  bool ask_again = true;

  while (ask_again) {
    ask_again = false;

    // ask for announcements
    for (auto& p : game.players()) {
      if (this->valid_announcement(p) != Announcement::noannouncement) {
        auto const announcement = p.announcement_request();
        if (this->is_valid(announcement, p)) {
          this->make_announcement(announcement, p);
          if (this->last(p) == announcement)
            ask_again = true;
        } // if (this->announcement_valid(announcement, p))
      } // if (this->valid_announcement(p))
    } // for (p < this->playerno())
  } // while (again)
} // void Announcements::request_from_players()

/** evaluate the trick for announcements
 **/
void
Announcements::evaluate_trick(Trick const& trick)
{
  auto& game = *this->game_;
  auto const& rule = game.rule();
  auto const& winnerplayer = trick.winnerplayer();

  // test whether the player has to make an announcement
  if (   (game.type() == GameType::normal)
      && (game.tricks().current_no() == 1)
      && (rule(Rule::Type::announcement_first_trick_thirty_points))
      && (trick.points() >= 30)
      && (this->last(winnerplayer.team())
          != Announcement::no0)
      && (    !rule(Rule::Type::announcement_first_trick_thirty_points_only_first)
          || (   (this->last(Team::re) == Announcement::noannouncement)
              && (this->last(Team::contra) == Announcement::noannouncement) )
         )
      && (   !rule(Rule::Type::announcement_first_trick_thirty_points_only_re_contra)
          || (this->last(winnerplayer.team())
              == Announcement::noannouncement) )
      && (   !is_marriage(game.type())
          || rule(Rule::Type::announcement_first_trick_thirty_points_in_marriage))
     ) {
    this->make_announcement(next(this->last(winnerplayer.team())), winnerplayer);
  } // if (player must make an announcement)
}

/** -> result
 **
 ** @param    player   player to check
 **
 ** @result    valid announcement for 'player'
 **            noannouncement, if 'player' cannot announce anymore
 **/
Announcement
Announcements::valid_announcement(Player const& player) const
{
  if (!is_real(player.team()))
    return Announcement::noannouncement;

  auto const opposite_announcement = this->last(opposite(player.team()));
  if (   is_real(opposite_announcement)
      && this->is_valid(to_reply(opposite_announcement), player))
    return to_reply(opposite_announcement);

  if (this->is_valid(player.next_announcement(), player))
    return player.next_announcement();

  return Announcement::noannouncement;
}


/** 'player' announces 'announcement'
 **
 ** @param    announcement   announcement made
 ** @param    player   player who announces
 **
 ** @result   -
 **/
void
Announcements::make_announcement(Announcement announcement,
                                 Player const& player)
{
  if (!is_valid(announcement, player))
    return ;
#ifdef TODO
  // when necessary, a 're' is changed to a 'reply'
#endif

  auto& game = *this->game_;
  if (announcement == Announcement::reply) {
    auto const opposite_announcement = this->last(opposite(player.team()));
    announcement = to_reply(opposite_announcement);
  }

  // set the announcement
  this->announcements_[player.no()].push_back(AnnouncementWithTrickno(announcement, game.tricks().current_no()));
  // update the team info
  if (!game.rule()(Rule::Type::knocking))
    game.teaminfo().set(player, player.team());

  // tell all players, that the announcement is made
  for (auto& p : game.players())
    p.announcement_made(announcement, player);

  game.gameplay_->gameplay_action(GameplayActions::Announcement(player.no(),
                                                                announcement));
  if (!game.isvirtual()) {
    ::ui->announcement_made(announcement, player);
    this->signal_announcement_made_(announcement, player);
    ::ui->gameplay_action(GameplayActions::Announcement(player.no(),
                                                        announcement));
    game.signal_gameplay_action_(GameplayActions::Announcement(player.no(),
                                                               announcement));
  }
} // void Announcements::make_announcement(Announcement announcement, Player player)

/** -> result
 **
 ** @param    announcement   the announcement
 ** @param    player   the player, who asks to make the announcement
 **
 ** @return   the announcement, if it is valid (but 'reply' for 're', if it is only allowed as reply)
 **/
bool
Announcements::is_valid(Announcement announcement,
                        Player const& player) const
{
  auto const& game = *this->game_;
  auto const& tricks = game.tricks();
  auto const& rule = game.rule();
  // test, whether status is in a game
  if ( !::in_running_game())
    return false;
  if (tricks.empty())
    return false;

  // no announcement after the 'Rule::Type::announcement_last' trick
  if (tricks.remaining_no()
      < (rule(Rule::Type::announcement_last)
         + (tricks.current().isfull() ? 1 : 0))) {
    return false;
  }

  // as long as the marriage is not determined, no announcement is valid
  if (   (game.marriage().selector() != MarriageSelector::team_set)
      && (game.marriage().selector() != MarriageSelector::silent))
    return false;

  Announcement const& last_announcement
    = ( (   rule(Rule::Type::knocking)
         && is_with_unknown_teams(game.type()))
       ? this->last(player).announcement
       : this->last(player.team()).announcement);

  if (is_reply(last_announcement)) {
    return false;
  }

  // change the announcement
  if (announcement == Announcement::reply) {
    if (!this->last(opposite(player.team())).announcement)
      return false;

    if (   (rule(Rule::Type::announcement_strict_limit))
        && is_real(this->last(opposite(player.team())).announcement) ) {
      announcement = to_reply(this->last(opposite(player.team())
                                        ).announcement);
    } else {
      announcement = Announcement::no120;
      //return false;
    }
  } // if (announcement == Announcement::reply)

  // the announcement must be a better one
  if (last_announcement >= announcement) {
    return false;
  }

  unsigned const marriage_deferral
    = (  (   (game.type() == GameType::marriage)
          || (game.type() == GameType::marriage_solo))
       ? (game.marriage().determination_trickno()
          - 1)
       : 0);
  // whether a normal announcement is valid
  bool valid = (((rule(Rule::Type::announcement_till_full_trick)
                  ? tricks.real_remaining_no()
                  : player.hand().cardsnumber())
                 + marriage_deferral)
                >= rule.remaining_cards(announcement));

  // change a 're' to a 'reply', if no futher announcement can be made
  if (!valid && !is_reply(announcement)) {
    if (   (announcement == Announcement::no120)
        && !rule(Rule::Type::announcement_strict_limit))
      announcement = Announcement::reply;
    else
      return false;
  }

  if (is_reply(announcement)) {
    if (!rule(Rule::Type::announcement_reply)) {
      return false;
    }

    if (last_announcement != Announcement::noannouncement) {
      return false;
    }

    Announcement const opposite_announcement
      = this->last(opposite(player.team()));

    if (   (announcement != Announcement::reply)
        && (from_reply(announcement) != opposite_announcement) ) {
      return false;
    }

    // till one trick after the last possible moment
    // - I can make my announcement
    // Remark: 'this->tricks().current_no()' can be different from
    //         'this->trick_.size()'
    if (((rule(Rule::Type::announcement_till_full_trick)
          ? tricks.real_remaining_no()
          : player.hand().cardsnumber())
         + marriage_deferral)
        + 1
        >= rule.remaining_cards(opposite_announcement)) {
      return true;
    }

    return false;
  } // if (announcement == Announcement::reply)

  // verify that all announcements before are valid
  if (   !rule(Rule::Type::announcement_limit_only_for_current)
      && (announcement > Announcement::no120)
      && (last_announcement
          != previous(announcement) ) ) {
    return this->is_valid(previous(announcement), player);
  }

  return valid;
} // bool Announcements::is_valid(Announcement announcement, Player player)

/** -> result
 **
 ** @param    announcement   the announcement
 ** @param    player   the player, who asks to make the announcement
 **
 ** @return   whether this is the last possibility to announce 'announcement'
 **/
bool
Announcements::last_chance_to_announce(Announcement const announcement,
                                       Player const& player) const
{
  auto const& game = *this->game_;
  auto const& tricks = game.tricks();
  auto const& rule = game.rule();
  if (!this->is_valid(announcement, player))
    return false;

  auto const marriage_deferral = (  (game.type() == GameType::marriage)
                                  ? (game.marriage().determination_trickno()
                                     - 1)
                                  : 0);

  // re as a reply
  if (   (announcement == Announcement::no120
          && !rule(Rule::Type::announcement_strict_limit)) ) {
    Announcement const& opposite_announcement
      = this->last(::opposite(player.team()));
    if (opposite_announcement != Announcement::noannouncement)
      return (((rule(Rule::Type::announcement_till_full_trick)
                ? tricks.real_remaining_no()
                : player.hand().cardsnumber())
               + marriage_deferral) + 1
              == rule.remaining_cards(opposite_announcement));
  } // if (re as reply)


  if (rule(Rule::Type::announcement_till_full_trick)) {
    if (!tricks.current().isfull())
      return false;
    return (tricks.real_remaining_no()
            + marriage_deferral
            == rule.remaining_cards(announcement));
  } else {
    if (game.players().current_player() != player)
      return false;
    if (tricks.current().has_played(player))
      return false;
    return ( player.hand().cardsnumber()
            + marriage_deferral
            == rule.remaining_cards(announcement));
  }
} // bool Announcements::last_chance_to_announce(Announcement announcement, Player player) const

/** @return   signal, when an announcement is made
 **/
Signal<void(Announcement, Player const&)>&
Announcements::signal_announcement_made()
{ return this->signal_announcement_made_; }