plrdlg_common.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   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, 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.
***********************************************************************/
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
#include <string.h>
 
/* utility */
#include "fcintl.h"
#include "log.h"
#include "support.h"
 
/* common */
#include "connection.h"
#include "game.h"
#include "government.h"
#include "nation.h"
#include "research.h"
 
/* client */
#include "client_main.h"
#include "climisc.h"
#include "options.h"
#include "text.h"
 
/* client/include */
#include "plrdlg_g.h"
 
#include "plrdlg_common.h"
 
 
/************************************************************************/
static const char *col_name(const struct player *player)
{
  return player_name(player);
}
 
/************************************************************************/
static int cmp_name(const struct player *pplayer1,
                     const struct player *pplayer2)
{
  return fc_stricoll(player_name(pplayer1), player_name(pplayer2));
}
 
/************************************************************************/
static const char *col_username(const struct player *player)
{
  return player->username;
}
 
/************************************************************************/
static const char *col_nation(const struct player *player)
{
  return nation_adjective_for_player(player);
}
 
/************************************************************************/
static const char *col_team(const struct player *player)
{
  return team_name_translation(player->team);
}
 
/************************************************************************/
static bool col_ai(const struct player *plr)
{
  /* TODO: Currently is_ai() is a macro so we can't have it
   *       directly as this callback, but once it's a function,
   *       do that. */
  return is_ai(plr);
}
 
/************************************************************************/
static const char *col_embassy(const struct player *player)
{
  return get_embassy_status(client.conn.playing, player);
}
 
/************************************************************************/
static const char *col_diplstate(const struct player *player)
{
  static char buf[100];
  const struct player_diplstate *pds;
 
  if (client.conn.playing == nullptr || player == client.conn.playing) {
    return "-";
  } else {
    pds = player_diplstate_get(client.conn.playing, player);
    if (pds->type == DS_CEASEFIRE || pds->type == DS_ARMISTICE) {
      fc_snprintf(buf, sizeof(buf), "%s (%d)",
                  diplstate_type_translated_name(pds->type),
                  pds->turns_left);
      return buf;
    } else {
      return diplstate_type_translated_name(pds->type);
    }
  }
}
 
/************************************************************************/
static int diplstate_value(const struct player *plr)
{
  /* These values are scaled so that adding/subtracting
     the number of turns left makes sense */
  static const int diplstate_cmp_lookup[DS_LAST] = {
    [DS_TEAM] = 1 << 16,
    [DS_ALLIANCE] = 2 << 16,
    [DS_PEACE] = 3 << 16,
    [DS_ARMISTICE] = 4 << 16,
    [DS_CEASEFIRE] = 5 << 16,
    [DS_WAR] = 6 << 16,
    [DS_NO_CONTACT] = 7 << 16
  };
 
  const struct player_diplstate *pds;
  int ds_value;
 
  if (client.conn.playing == nullptr || plr == client.conn.playing) {
    /* Current global player is as close as players get
       -> return value smaller than for DS_TEAM */
    return 0;
  }
 
  pds = player_diplstate_get(client.conn.playing, plr);
  ds_value = diplstate_cmp_lookup[pds->type];
 
  if (pds->type == DS_ARMISTICE || pds->type == DS_CEASEFIRE) {
    ds_value += pds->turns_left;
  }
 
  return ds_value;
}
 
/************************************************************************/
static int cmp_diplstate(const struct player *player1,
                         const struct player *player2)
{
  return diplstate_value(player1) - diplstate_value(player2);
}
 
/************************************************************************/
static const char *col_love(const struct player *player)
{
  if (client.conn.playing == nullptr || player == client.conn.playing
      || is_human(player)) {
    return "-";
  } else {
    return love_text(player->ai_common.love[player_index(client.conn.playing)]);
  }
}
 
/************************************************************************/
static int cmp_love(const struct player *player1,
                    const struct player *player2)
{
  int love1, love2;
 
  if (client.conn.playing == nullptr) {
    return player_number(player1) - player_number(player2);
  }
 
  if (player1 == client.conn.playing || is_human(player1)) {
    love1 = MAX_AI_LOVE + 999;
  } else {
    love1 = player1->ai_common.love[player_index(client.conn.playing)];
  }
 
  if (player2 == client.conn.playing || is_human(player2)) {
    love2 = MAX_AI_LOVE + 999;
  } else {
    love2 = player2->ai_common.love[player_index(client.conn.playing)];
  }
 
  return love1 - love2;
}
 
/************************************************************************/
static const char *col_vision(const struct player *player)
{
  return get_vision_status(client.conn.playing, player);
}
 
/************************************************************************/
const char *plrdlg_col_state(const struct player *plr)
{
  if (!plr->is_alive) {
    /* TRANS: Dead -- Rest In Peace -- Reqia In Pace */
    return _("R.I.P.");
  } else if (!plr->is_connected) {
    struct option *opt;
    bool consider_tb = FALSE;
 
    if (is_ai(plr)) {
      return "";
    }
 
    opt = optset_option_by_name(server_optset, "turnblock");
    if (opt != nullptr) {
      consider_tb = option_bool_get(opt);
    }
 
    if (!consider_tb) {
      /* TRANS: No connection */
      return _("noconn");
    }
 
    if (!is_player_phase(plr, game.info.phase)) {
      return _("waiting");
    } else if (plr->phase_done) {
      return _("done");
    } else {
      /* TRANS: Turnblocking & player not connected */
      return _("blocking");
    }
  } else {
    if (!is_player_phase(plr, game.info.phase)) {
      return _("waiting");
    } else if (plr->phase_done) {
      return _("done");
    } else {
      return _("moving");
    }
  }
}
 
/************************************************************************/
static const char *col_host(const struct player *pplayer)
{
  conn_list_iterate(pplayer->connections, pconn) {
    if (!pconn->observer) {
      return pconn->addr;
    }
  } conn_list_iterate_end;
 
  return blank_addr_str;
}
 
/************************************************************************/
static const char *col_idle(const struct player *plr)
{
  int idle;
  static char buf[100];
 
  if (plr->nturns_idle > 3) {
    idle = plr->nturns_idle - 1;
  } else {
    idle = 0;
  }
  fc_snprintf(buf, sizeof(buf), "%d", idle);
  return buf;
}
 
/************************************************************************/
static int cmp_score(const struct player *player1,
                     const struct player *player2)
{
  return player1->score.game - player2->score.game;
}
 
/************************************************************************/
static const char *col_government(const struct player *them)
{
  static char buf[100];
 
  /* This gives sensible result even when the government is not known */
  fc_snprintf(buf, sizeof(buf), "%s", government_name_for_player(them));
 
  return buf;
}
 
/************************************************************************/
static int cmp_culture(const struct player *player1,
                       const struct player *player2)
{
  return player1->client.culture - player2->client.culture;
}
 
/************************************************************************/
static const char *get_culture_info(const struct player *them)
{
  static char buf[10];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)))) {
    fc_snprintf(buf, sizeof(buf), "%d", them->client.culture);
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_culture(const struct player *pplayer)
{
  return get_culture_info(pplayer);
}
 
/************************************************************************/
static int cmp_gold(const struct player* player1,
                    const struct player* player2)
{
  return player1->economic.gold - player2->economic.gold;
}
 
/************************************************************************/
static const char *get_gold_info(const struct player *them)
{
  static char buf[10];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)
                     || player_diplstate_get(me, them)->contact_turns_left > 0))) {
    fc_snprintf(buf, sizeof(buf), "%d", them->economic.gold);
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_gold(const struct player *pplayer)
{
  return get_gold_info(pplayer);
}
 
/************************************************************************/
static int cmp_tax(const struct player* player1,
                   const struct player* player2)
{
  return player1->economic.tax - player2->economic.tax;
}
 
/************************************************************************/
static const char *get_tax_info(const struct player *them)
{
  static char buf[10];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)))) {
    fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.tax);
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_tax(const struct player *pplayer)
{
  return get_tax_info(pplayer);
}
 
/************************************************************************/
static int cmp_science(const struct player* player1,
                       const struct player* player2)
{
  return player1->economic.science - player2->economic.science;
}
 
/************************************************************************/
static const char *get_science_info(const struct player *them)
{
  static char buf[10];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)))) {
    fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.science);
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_science(const struct player *pplayer)
{
  return get_science_info(pplayer);
}
 
/************************************************************************/
static int cmp_luxury(const struct player* player1,
                      const struct player* player2)
{
  return player1->economic.luxury - player2->economic.luxury;
}
 
/************************************************************************/
static const char *get_luxury_info(const struct player *them)
{
  static char buf[10];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)))) {
    fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.luxury);
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_luxury(const struct player *pplayer)
{
  return get_luxury_info(pplayer);
}
 
/************************************************************************/
static const char *get_researching_info(const struct player *them)
{
  static char buf[100];
  const struct player *me = client_player();
  bool gobs = client_is_global_observer();
 
  if (them == nullptr || !them->is_alive) {
    fc_snprintf(buf, sizeof(buf), "-");
  } else if (gobs
             || (me != nullptr
                 && (me == them || team_has_embassy(me->team, them)))) {
    struct research *research = research_get(them);
 
    fc_snprintf(buf, sizeof(buf), "%s",
                research_advance_name_translation(research, research->researching));
  } else {
    fc_snprintf(buf, sizeof(buf), "?");
  }
 
  return buf;
}
 
/************************************************************************/
static const char *col_research(const struct player *pplayer)
{
  return get_researching_info(pplayer);
}
 
/****************************************************************************
  ...
****************************************************************************/
struct player_dlg_column player_dlg_columns[] = {
  {TRUE, COL_TEXT, N_("?Player:Name"), col_name, nullptr, cmp_name, "name"},
  {FALSE, COL_TEXT, N_("Username"), col_username, nullptr, nullptr, "username"},
  {TRUE, COL_FLAG, N_("Flag"), nullptr, nullptr, nullptr, "flag"},
  {TRUE, COL_TEXT, N_("Nation"), col_nation, nullptr, nullptr, "nation"},
  {TRUE, COL_COLOR, N_("Border"), nullptr, nullptr, nullptr, "border"},
  {TRUE, COL_RIGHT_TEXT, N_("Score"), get_score_text, nullptr, cmp_score, "score"},
  {TRUE, COL_TEXT, N_("Team"), col_team, nullptr, nullptr, "team"},
  {TRUE, COL_BOOLEAN, N_("AI"), nullptr, col_ai, nullptr, "ai"},
  {TRUE, COL_TEXT, N_("Attitude"), col_love, nullptr, cmp_love, "attitude"},
  {TRUE, COL_TEXT, N_("Embassy"), col_embassy, nullptr, nullptr, "embassy"},
  {TRUE, COL_TEXT, N_("Dipl.State"), col_diplstate, nullptr, cmp_diplstate,
    "diplstate"},
  {TRUE, COL_TEXT, N_("Vision"), col_vision, nullptr, nullptr, "vision"},
  {TRUE, COL_TEXT, N_("State"), plrdlg_col_state, nullptr, nullptr, "state"},
  {FALSE, COL_TEXT, N_("?Player_dlg:Host"), col_host, nullptr, nullptr, "host"},
  {FALSE, COL_RIGHT_TEXT, N_("?Player_dlg:Idle"), col_idle, nullptr, nullptr, "idle"},
  {FALSE, COL_RIGHT_TEXT, N_("Ping"), get_ping_time_text, nullptr, nullptr, "ping"},
  {TRUE, COL_TEXT, N_("Government"), col_government, nullptr, nullptr, "government"},
  {TRUE, COL_RIGHT_TEXT, N_("Culture"), col_culture, nullptr, cmp_culture, "culture"},
  {TRUE, COL_RIGHT_TEXT, N_("Gold"), col_gold, nullptr, cmp_gold, "gold"},
  {TRUE, COL_RIGHT_TEXT, N_("Tax"), col_tax, nullptr, cmp_tax, "tax"},
  {TRUE, COL_RIGHT_TEXT, N_("Science"), col_science, nullptr, cmp_science, "science"},
  {TRUE, COL_RIGHT_TEXT, N_("Luxury"), col_luxury, nullptr, cmp_luxury, "luxury"},
  {TRUE, COL_TEXT, N_("Research"), col_research, nullptr, nullptr, "research"}
};
 
const int num_player_dlg_columns = ARRAY_SIZE(player_dlg_columns);
 
/************************************************************************/
int player_dlg_default_sort_column(void)
{
  return 3;
}
 
/************************************************************************/
void init_player_dlg_common(void)
{
  int i;
 
  for (i = 0; i < num_player_dlg_columns; i++) {
    player_dlg_columns[i].title = Q_(player_dlg_columns[i].title);
  }
}