xref: /dports/games/freedoko/FreeDoko_0.7.19/src/ui/gtkmm/icongroup.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"

#ifdef USE_UI_GTKMM

#include "icongroup.h"
#include "table.h"
#include "ui.h"

#include "cards.h"
#include "icons.h"
#include "hand.h"
#include "name.h"

#include "../../game/game.h"
#include "../../party/rule.h"
#include "../../player/player.h"
#include "../../player/human/human.h"
#include "../../misc/preferences.h"

namespace UI_GTKMM_NS {

/** constructor
 **
 ** @param    table   the table
 ** @param    position   the position of the icongroup
 **/
Icongroup::Icongroup(Table& table, Position const position) :
  HTIN(table, position)
{ }

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

/**
 **/
bool
Icongroup::changed() const
{
  if (!this->surface_)
    return true;
  if (::game_status & GameStatus::game)
    return (this->last_status_ != this->current_status());
  return true;
} // bool Icongroup::changed() const

/** draws the icongroup
 **
 ** @param    cr   drawing context
 **/
void
Icongroup::draw(Cairo::RefPtr<::Cairo::Context> cr)
{
  cr->save();
  cr->push_group();
  this->last_status_ = this->current_status();
  this->draw_team(cr);
  this->draw_swines(cr);
  this->draw_announcement(cr);
  cr->pop_group_to_source();
  cr->paint();
  cr->restore();

  return ;
} // void Icongroup::draw(Cairo::RefPtr<::Cairo::Context> cr)

/** draws the team/gametype icon
 **
 ** @param    cr       cairo context
 **
 ** @todo   silent marriage
 **/
void
Icongroup::draw_team(Cairo::RefPtr<::Cairo::Context> cr)
{
  if(!(::game_status & GameStatus::game))
    return ;

  Game const& game = this->game();
  if (   (::game_status < GameStatus::game_reservation)
      && !(   game.players().exists_soloplayer()
           && (this->player() == game.players().soloplayer()) )  )
    return ;
  if (!this->last_status_.team_icon)
    return ;

  auto icon = this->ui->icons->icon(this->last_status_.team_icon);
  if (!icon)
    return;

  if (this->last_status_.team_guessed) {
    Glib::RefPtr<Gdk::Pixbuf> copy = icon->copy();
    icon->saturate_and_pixelate(copy, 5, true);
    icon = copy;
  }

  cr->save();
  cr->push_group();
  auto geometry = this->geometry();
  geometry.transform(cr);
  draw_pixbuf(cr, icon,
              (  geometry.flip_x()
               ? geometry.width() - icon->get_width()
               : 0),
              -icon->get_height());
  cr->pop_group_to_source();
  cr->paint();
  cr->restore();
} // void Icongroup::draw_team(Cairo::RefPtr<::Cairo::Context> cr)

/** draws the announcement icon
 **
 ** @param    cr       cairo context
 **/
void
Icongroup::draw_announcement(Cairo::RefPtr<::Cairo::Context> cr)
{
  if (! (   (::game_status & GameStatus::game)
         && (::game_status > GameStatus::game_reservation)) )
    return ;

  auto const& announcement = this->last_status_.announcement;
  if (announcement == Announcement::noannouncement)
    return ;

  auto icon = this->ui->icons->icon(announcement);
  if (this->last_status_.next_announcement) {
    Glib::RefPtr<Gdk::Pixbuf> copy = icon->copy();
    icon->saturate_and_pixelate(copy, 4, true);
    icon = copy;
  }

  cr->save();
  cr->push_group();
  auto const geometry = this->geometry();
  geometry.transform(cr);
  draw_pixbuf(cr, icon,
               (geometry.width() - icon->get_width()) / 2,
              -icon->get_height());
  cr->pop_group_to_source();
  cr->paint();
  cr->restore();
} // void Icongroup::draw_announcement(Cairo::RefPtr<::Cairo::Context> cr)

/** draws the swines/hyperswines icon
 **
 ** @param    cr       cairo context
 **/
void
Icongroup::draw_swines(Cairo::RefPtr<::Cairo::Context> cr)
{
  if (!(::game_status & GameStatus::game))
    return ;

  Glib::RefPtr<Gdk::Pixbuf> icon;

  auto const& swines = this->last_status_.swines;
  auto const& hyperswines = this->last_status_.hyperswines;
  auto const& trumpcolor = this->last_status_.trumpcolor;
  if (swines && hyperswines) {
    icon = this->ui->icons->swines_hyperswines(trumpcolor);
  } else if (swines) {
    icon = this->ui->icons->swines(trumpcolor);
  } else if (hyperswines) {
    icon = this->ui->icons->hyperswines(trumpcolor);
  } else {
    return ;
  }

  auto const geometry = this->geometry();
  cr->save();
  cr->push_group();
  geometry.transform(cr);
  draw_pixbuf(cr, icon,
              (  geometry.flip_x()
               ? 0
               : geometry.width() - icon->get_width()),
              -icon->get_height());

  cr->pop_group_to_source();
  cr->paint();
  cr->restore();
} // void Icongroup::draw_swines(Cairo::RefPtr<::Cairo::Context> cr)

/** @return   the geometry of the icongroup
 **/
Icongroup::Geometry
Icongroup::geometry() const
{
  Geometry geometry;
  auto const hand_geometry = this->hand().geometry();
    geometry.height = [=](){
      return this->ui->icons->max_height();
    };
  switch (this->position()) {
  case Position::south:
    geometry.rotation = Rotation::up;
    geometry.width = [=](){
      return hand_geometry.width() * 3 / 4;
    };
    geometry.pos_x = [=](){
      return (hand_geometry.pos_x()
              + hand_geometry.width() / 4);
    };
    geometry.pos_y = [=](){
      return (hand_geometry.pos_y()
              - hand_geometry.height()
              - hand_geometry.margin_y());
    };
    break;

  case Position::north:
    geometry.rotation = Rotation::down;
    geometry.flip_x = [](){
      return true;
    };
    geometry.width = [=](){
      return hand_geometry.width() * 3 / 4;
    };
    geometry.pos_x = [=](){
      return hand_geometry.pos_x();
    };
    geometry.pos_y = [=](){
      return (hand_geometry.pos_y()
              + hand_geometry.height()
              + hand_geometry.margin_y());
    };
    break;

  case Position::west:
    geometry.rotation = Rotation::right;
    geometry.pos_x = [=](){
      return (hand_geometry.pos_x()
              + hand_geometry.height()
              + hand_geometry.margin_y());
    };
    geometry.pos_y = [=](){
      return (hand_geometry.pos_y());
    };
    geometry.width = [=](){
      return hand_geometry.width();
    };
    break;

  case Position::east:
    geometry.rotation = Rotation::left;
    geometry.pos_x = [=](){
      return (hand_geometry.pos_x()
              - hand_geometry.height()
              - hand_geometry.margin_y());
    };
    geometry.pos_y = [=](){
      return (hand_geometry.pos_y());
    };
    geometry.width = [=](){
      return hand_geometry.width();
    };
    break;

  case Position::center:
    DEBUG_ASSERTION(false,
                    "Icongroup::geometry()\n"
                    "  wrong position 'center' "
                    << "(" << this->position() << ")");
  } // switch (this->position())

  switch (this->table().layout()) {
  case Table::Layout::standard:
    break;
  case Table::Layout::widescreen:
    switch (this->position()) {
    case Position::north:
      geometry.width = [=](){
        return hand_geometry.width();
      };
      break;
    case Position::east:
      geometry.width = [=](){
        return (hand_geometry.width()
                + hand_geometry.margin_x()
                + this->name().geometry().height());
      };
      break;
    default:
      break;
    } // switch (this->position())
  } // switch (this->table().layout())
  return geometry;
} // Icongroup::Geometry Icongroup::geometry() const

/** @return   the geometry of the icongroup
 **/
Icongroup::Outline
Icongroup::outline() const
{
  return this->geometry().outline();
}

/** @return   whether the mouse is over the next announcement
 **/
bool
Icongroup::mouse_over_next_announcement() const
{
  if (!::preferences(::Preferences::Type::announce_in_table))
    return false;

  if (!::is_real(this->player().team()))
    return false;

  Announcement const announcement
    = this->player().next_announcement();

  if (announcement == Announcement::noannouncement)
    return false;

  int x, y;
  this->table().get_pointer(x, y);

  Glib::RefPtr<Gdk::Pixbuf> icon
    = this->ui->icons->icon(announcement);
  auto const geometry = this->geometry();
  geometry.retransform(x, y);
  return (   (x >= (geometry.width() - icon->get_width()) / 2)
          && (x < (geometry.width() + icon->get_width()) / 2)
          && (y < 0)
          && (y >= -icon->get_height()) );
} // bool Icongroup::mouse_over_next_announcement() const

/** @return   the current status
 **/
Icongroup::Status
Icongroup::current_status() const
{
#ifdef TEST_LAYOUT
  return {Icons::Type::thrown_nines_and_kings, false,
    Announcement::no120, false,
    Card::Color::club, true, true};
#endif
  auto const& game = this->game();
  Team const team = game.teaminfo().get_human_teaminfo(this->player());
  auto const* const soloplayer
    = (game.players().exists_soloplayer()
       ? &game.players().soloplayer()
       : ((game.type() == GameType::normal)
          ? nullptr
          : &game.players().current_player()));

  auto team_icon = Icons::Type::none;
  auto team_guessed = false;
  if (::game_status == GameStatus::game_reservation) {
    if (this->player().type() == Player::Type::human) {
      ::Reservation const& reservation = this->player().reservation();
      switch (reservation.game_type) {
      case GameType::normal:
        team_icon = Icons::type(this->player().hand().contains(Card::club_queen)
                                ? Team::re : Team::contra);
        break;
      case GameType::poverty:
        {
          switch (this->player().hand().count_trumps()) {
          case 0:
            team_icon = Icons::Type::poverty_trumps_0;
            break;
          case 1:
            team_icon = Icons::Type::poverty_trumps_1;
            break;
          case 2:
            team_icon = Icons::Type::poverty_trumps_2;
            break;
          case 3:
          case 4:
          case 5:
            team_icon = Icons::Type::poverty_trumps_3;
            break;
          case UINT_MAX:
            team_icon = Icons::Type::poverty;
            break;
          default:
            DEBUG_ASSERTION(false,
                            "IconGroup::draw_team():\n"
                            "  gametype: poverty\n"
                            "  number of poverty cards for player " << this->player().no() << ' ' << this->player().name() << " invalid: "
                            << this->player().hand().count_trumps() << '\n'
                            << "reservation:\n"
                            << this->player().reservation() << '\n'
                            << "game status: " << ::game_status);
            team_icon = Icons::Type::poverty;
            break;
          } // switch (this->player().hand().count_trumps())
        }
        break;
      case GameType::genscher:
        team_icon = Icons::Type::genscher;
        break;
      case GameType::marriage:
        team_icon = Icons::type(reservation.marriage_selector);
        break;
      case GameType::marriage_solo:
      case GameType::marriage_silent:
      case GameType::thrown_nines:
      case GameType::thrown_kings:
      case GameType::thrown_nines_and_kings:
      case GameType::thrown_richness:
      case GameType::fox_highest_trump:
      case GameType::redistribute:
      case GameType::solo_diamond:
      case GameType::solo_jack:
      case GameType::solo_queen:
      case GameType::solo_king:
      case GameType::solo_queen_jack:
      case GameType::solo_king_jack:
      case GameType::solo_king_queen:
      case GameType::solo_koehler:
      case GameType::solo_club:
      case GameType::solo_heart:
      case GameType::solo_spade:
      case GameType::solo_meatless:
        team_icon = Icons::type(reservation.game_type);
        break;
      } // switch (this->player().reservation().game_type())

    } // if (this->player().type() == Player::Type::human)

  } else if (   game.is_finished()
             || ::preferences(::Preferences::Type::show_soloplayer_in_game)) {
    switch (game.type()) {
    case GameType::normal:
      break;
    case GameType::poverty:
      if (this->player() == *soloplayer) {
        team_icon = Icons::type(game.type());
      } else if (   (::game_status >= GameStatus::game_start)
                 && (this->player().team() == Team::re) ) {
        team_icon = Icons::Type::poverty_partner;
      }
      break;
    case GameType::genscher:
      if (this->player() == *soloplayer)
        team_icon = Icons::Type::genscher;
      else if (this->player().team() == Team::re)
        team_icon = Icons::type(Team::re);
      else
        team_icon = Icons::type(Team::contra);
      break;
    case GameType::marriage:
    case GameType::marriage_solo:
      if (this->player() == *soloplayer) {
        team_icon = Icons::type(game.marriage().selector());
      } else if (game.marriage().selector() == MarriageSelector::team_set) {
        if (team == Team::re) {
          team_icon = Icons::Type::marriage_partner;
        } else {
          team_icon = Icons::type(team);
        }
      } // if !(this->player == soloplayer)
      break;
    case GameType::marriage_silent:
      if (this->player() == *soloplayer) {
        team_icon = Icons::type(game.type());
      } else {
        team_icon = Icons::Type::none;
      }
      break;
    case GameType::thrown_nines:
    case GameType::thrown_kings:
    case GameType::thrown_nines_and_kings:
    case GameType::thrown_richness:
    case GameType::fox_highest_trump:
    case GameType::redistribute:
    case GameType::solo_diamond:
    case GameType::solo_jack:
    case GameType::solo_queen:
    case GameType::solo_king:
    case GameType::solo_queen_jack:
    case GameType::solo_king_jack:
    case GameType::solo_king_queen:
    case GameType::solo_koehler:
    case GameType::solo_club:
    case GameType::solo_heart:
    case GameType::solo_spade:
    case GameType::solo_meatless:
      if (this->player() == *soloplayer)
        team_icon = Icons::type(game.type());
      else
        team_icon = Icons::Type::none;
      break;
    } // switch(game.type())
  } // if (icon shall be shown for soloplayer)

  // special case: silent marriage
  if (   !team_icon
      && (game.players().count_humans() == 1)
      && (this->player().type() == Player::Type::human)
      && (   (   (game.type() == GameType::marriage_silent)
              && (this->player() == game.players().soloplayer()) )
          || (   (game.type() == GameType::normal)
              && (this->player().hand().count_all(Card::club_queen)
                  == game.rule()(Rule::Type::number_of_same_cards)))
         )
     ) {
    team_icon = Icons::type(GameType::marriage_silent);
  }

  if (!team_icon) {
    if (   game.is_finished()
        || ::preferences(::Preferences::Type::show_known_teams_in_game)) {
      team_icon = Icons::type(team);
    } // if (show teams)
  } // if (!team_icon)

  if (   !team_icon
      && ::preferences(::Preferences::Type::show_ai_information_teams)
      && (game.players().count_humans() == 1)
      && (game.players().human().teaminfo(this->player()) != Team::unknown)
      && (game.type() == GameType::normal)
     ) {
    team_icon = Icons::type(::maybe_to_team(game.players().human().teaminfo(this->player())));
    if (!!team_icon
        && !::is_real(game.players().human().teaminfo(this->player()))) {
      team_guessed = true;
    } // if (team is maybe)
  } // if (team_icon)


  bool next_announcement = false;
  auto announcement = this->player().announcement();
  if (   ::preferences(::Preferences::Type::announce_in_table)
      && (this->player().type() == Player::Type::human)
      && (this->mouse_over_next_announcement()
          || (   (this->player().announcement()
                  == Announcement::noannouncement)
              && (this->player().next_announcement()
                  != Announcement::noannouncement)))) {
    announcement = this->player().next_announcement();
    if (   !announcement
        && this->player().game().announcements().is_valid(Announcement::reply, this->player()))
      announcement = Announcement::reply;
    next_announcement = true;
  }

  if (announcement == Announcement::reply)
    announcement = to_reply(this->game().announcements().last(::opposite(this->player().team())));

  if (this->table().in_game_review()) {
    announcement = Announcement::noannouncement;
    for (auto a = this->game().announcements().all(this->player()).rbegin();
         a != this->game().announcements().all(this->player()).rend();
         ++a)
      if (a->trickno < this->table().game_review_trickno()) {
        announcement = a->announcement;
        break;
      }
  } // if (this->table().in_game_review())

  // Swines

  bool swines = this->player().has_swines();
  bool hyperswines = this->player().has_hyperswines();
  if (   (::game_status == GameStatus::game_reservation)
      || (::game_status == GameStatus::game_start) ) {
    swines = swines || (this->player().reservation().swines
                        && this->game().swines().swines_announcement_valid(this->player()));
    hyperswines = hyperswines || (this->player().reservation().hyperswines
                                  && this->game().swines().hyperswines_announcement_valid(this->player()));
  }

  return {team_icon, team_guessed,
    announcement, next_announcement,
    this->game().cards().trumpcolor(), swines, hyperswines};
} // Icongroup::Status Icongroup::current_status() const

/** comparison operator
 **/
bool
operator!=(Icongroup::Status const& lhs, Icongroup::Status const& rhs)
{
  return (   (lhs.team_icon != rhs.team_icon)
          || (lhs.team_guessed != rhs.team_guessed)
          || (lhs.announcement != rhs.announcement)
          || (lhs.next_announcement != rhs.next_announcement)
          || (lhs.trumpcolor != rhs.trumpcolor)
          || (lhs.swines != rhs.swines)
          || (lhs.hyperswines != rhs.hyperswines) );
} // bool operator!=(Icongroup::Status lhs, Icongroup::Status rhs)

/** @return   the geometry of the icongroup
 **/
Icongroup::Outline
Icongroup::Geometry::outline() const
{
  return this->transform({0, -this->height(), this->width(), this->height()});
} // Outline Icongroup::Geometry::outline() const

} // namespace UI_GTKMM_NS

#endif // #ifdef USE_UI_GTKMM