client/plrdlg_common.c

   1 /**********************************************************************
   2  Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   3    This program is free software; you can redistribute it and/or modify
   4    it under the terms of the GNU General Public License as published by
   5    the Free Software Foundation; either version 2, or (at your option)
   6    any later version.
   7
   8    This program is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11    GNU General Public License for more details.
  12 ***********************************************************************/
  13
  14 #ifdef HAVE_CONFIG_H
  15 #include <fc_config.h>
  16 #endif
  17
  18 #include <string.h>
  19
  20 /* utility */
  21 #include "fcintl.h"
  22 #include "log.h"
  23 #include "support.h"
  24
  25 /* common */
  26 #include "connection.h"
  27 #include "game.h"
  28
  29 /* client */
  30 #include "client_main.h"
  31 #include "climisc.h"
  32 #include "options.h"
  33 #include "text.h"
  34
  35 /* client/include */
  36 #include "plrdlg_g.h"
  37
  38 #include "plrdlg_common.h"
  39
  40
  41 /******************************************************************
  42   The player-name (aka nation leader) column of the plrdlg.
  43 *******************************************************************/
  44 static const char *col_name(const struct player *player)
  45 {
  46   return player_name(player);
  47 }
  48
  49 /****************************************************************************
  50   Compares the names of two players in players dialog.
  51 ****************************************************************************/
  52 static int cmp_name(const struct player *pplayer1,
  53                      const struct player *pplayer2)
  54 {
  55   return fc_stricoll(player_name(pplayer1), player_name(pplayer2));
  56 }
  57
  58 /******************************************************************
  59   The username (connection name) column of the plrdlg.
  60 *******************************************************************/
  61 static const char *col_username(const struct player *player)
  62 {
  63   return player->username;
  64 }
  65
  66 /******************************************************************
  67   The name of the player's nation for the plrdlg.
  68 *******************************************************************/
  69 static const char *col_nation(const struct player *player)
  70 {
  71   return nation_adjective_for_player(player);
  72 }
  73
  74 /******************************************************************
  75   The name of the player's team (or empty) for the plrdlg.
  76 *******************************************************************/
  77 static const char *col_team(const struct player *player)
  78 {
  79   return team_name_translation(player->team);
  80 }
  81
  82 /******************************************************************
  83   TRUE if the player is AI-controlled.
  84 *******************************************************************/
  85 static bool col_ai(const struct player *plr)
  86 {
  87   return plr->ai_controlled;
  88 }
  89
  90 /******************************************************************
  91   Returns a translated string giving the embassy status
  92   (none/with us/with them/both).
  93 *******************************************************************/
  94 static const char *col_embassy(const struct player *player)
  95 {
  96   return get_embassy_status(client.conn.playing, player);
  97 }
  98
  99 /******************************************************************
 100   Returns a translated string giving the diplomatic status
 101   ("war" or "ceasefire (5)").
 102 *******************************************************************/
 103 static const char *col_diplstate(const struct player *player)
 104 {
 105   static char buf[100];
 106   const struct player_diplstate *pds;
 107
 108   if (NULL == client.conn.playing || player == client.conn.playing) {
 109     return "-";
 110   } else {
 111     pds = player_diplstate_get(client.conn.playing, player);
 112     if (pds->type == DS_CEASEFIRE || pds->type == DS_ARMISTICE) {
 113       fc_snprintf(buf, sizeof(buf), "%s (%d)",
 114                   diplstate_type_translated_name(pds->type),
 115                   pds->turns_left);
 116       return buf;
 117     } else {
 118       return diplstate_type_translated_name(pds->type);
 119     }
 120   }
 121 }
 122
 123 /******************************************************************
 124  Return a numerical value suitable for ordering players by
 125  their diplomatic status in the players dialog
 126
 127  A lower value stands for more friendly diplomatic status.
 128 *******************************************************************/
 129 static int diplstate_value(const struct player *plr)
 130 {
 131   /* these values are scaled so that adding/subtracting
 132      the number of turns left makes sense */
 133   static const int diplstate_cmp_lookup[DS_LAST] = {
 134     [DS_TEAM] = 1 << 16,
 135     [DS_ALLIANCE] = 2 << 16,
 136     [DS_PEACE] = 3 << 16,
 137     [DS_ARMISTICE] = 4 << 16,
 138     [DS_CEASEFIRE] = 5 << 16,
 139     [DS_WAR] = 6 << 16,
 140     [DS_NO_CONTACT] = 7 << 16
 141   };
 142
 143   const struct player_diplstate *pds;
 144   int ds_value;
 145
 146   if (NULL == client.conn.playing || plr == client.conn.playing) {
 147     /* current global player is as close as players get
 148        -> return value smaller than for DS_TEAM */
 149     return 0;
 150   }
 151
 152   pds = player_diplstate_get(client.conn.playing, plr);
 153   ds_value = diplstate_cmp_lookup[pds->type];
 154
 155   if (pds->type == DS_ARMISTICE || pds->type == DS_CEASEFIRE) {
 156     ds_value += pds->turns_left;
 157   }
 158
 159   return ds_value;
 160 }
 161
 162 /******************************************************************
 163  Compares diplomatic status of two players in players dialog
 164 *******************************************************************/
 165 static int cmp_diplstate(const struct player *player1,
 166                          const struct player *player2)
 167 {
 168   return diplstate_value(player1) - diplstate_value(player2);
 169 }
 170
 171 /******************************************************************
 172   Return a string displaying the AI's love (or not) for you...
 173 *******************************************************************/
 174 static const char *col_love(const struct player *player)
 175 {
 176   if (NULL == client.conn.playing || player == client.conn.playing
 177       || !player->ai_controlled) {
 178     return "-";
 179   } else {
 180     return love_text(player->ai_common.love[player_index(client.conn.playing)]);
 181   }
 182 }
 183
 184 /******************************************************************
 185   Compares ai's attitude toward the player
 186 ******************************************************************/
 187 static int cmp_love(const struct player *player1,
 188                     const struct player *player2)
 189 {
 190   int love1, love2;
 191
 192   if (NULL == client.conn.playing) {
 193     return player_number(player1) - player_number(player2);
 194   }
 195
 196   if (player1 == client.conn.playing || !player1->ai_controlled) {
 197     love1 = MAX_AI_LOVE + 999;
 198   } else {
 199     love1 = player1->ai_common.love[player_index(client.conn.playing)];
 200   }
 201
 202   if (player2 == client.conn.playing || !player2->ai_controlled) {
 203     love2 = MAX_AI_LOVE + 999;
 204   } else {
 205     love2 = player2->ai_common.love[player_index(client.conn.playing)];
 206   }
 207
 208   return love1 - love2;
 209 }
 210
 211 /******************************************************************
 212   Returns a translated string giving our shared-vision status.
 213 *******************************************************************/
 214 static const char *col_vision(const struct player *player)
 215 {
 216   return get_vision_status(client.conn.playing, player);
 217 }
 218
 219 /******************************************************************
 220   Returns a translated string giving the player's "state".
 221
 222   FIXME: These terms aren't very intuitive for new players.
 223 *******************************************************************/
 224 const char *plrdlg_col_state(const struct player *plr)
 225 {
 226   if (!plr->is_alive) {
 227     /* TRANS: Dead -- Rest In Peace -- Reqia In Pace */
 228     return _("R.I.P.");
 229   } else if (!plr->is_connected) {
 230     struct option *opt;
 231     bool consider_tb = FALSE;
 232
 233     if (plr->ai_controlled) {
 234       return "";
 235     }
 236
 237     opt = optset_option_by_name(server_optset, "turnblock");
 238     if (opt != NULL) {
 239       consider_tb = option_bool_get(opt);
 240     }
 241
 242     if (!consider_tb) {
 243       /* TRANS: No connection */
 244       return _("noconn");
 245     }
 246
 247     if (!is_player_phase(plr, game.info.phase)) {
 248       return _("waiting");
 249     } else if (plr->phase_done) {
 250       return _("done");
 251     } else {
 252       /* TRANS: Turnblocking & player not connected */
 253       return _("blocking");
 254     }
 255   } else {
 256     if (!is_player_phase(plr, game.info.phase)) {
 257       return _("waiting");
 258     } else if (plr->phase_done) {
 259       return _("done");
 260     } else {
 261       return _("moving");
 262     }
 263   }
 264 }
 265
 266 /******************************************************************
 267   Returns a string telling the player's client's hostname (the
 268   machine from which he is connecting).
 269 *******************************************************************/
 270 static const char *col_host(const struct player *player)
 271 {
 272   return player_addr_hack(player);
 273 }
 274
 275 /******************************************************************
 276   Returns a string telling how many turns the player has been idle.
 277 *******************************************************************/
 278 static const char *col_idle(const struct player *plr)
 279 {
 280   int idle;
 281   static char buf[100];
 282
 283   if (plr->nturns_idle > 3) {
 284     idle = plr->nturns_idle - 1;
 285   } else {
 286     idle = 0;
 287   }
 288   fc_snprintf(buf, sizeof(buf), "%d", idle);
 289   return buf;
 290 }
 291
 292 /******************************************************************
 293  Compares score of two players in players dialog
 294 *******************************************************************/
 295 static int cmp_score(const struct player* player1,
 296                      const struct player* player2)
 297 {
 298   return player1->score.game - player2->score.game;
 299 }
 300
 301 /******************************************************************
 302  ...
 303 *******************************************************************/
 304 struct player_dlg_column player_dlg_columns[] = {
 305   {TRUE, COL_TEXT, N_("?Player:Name"), col_name, NULL, cmp_name, "name"},
 306   {FALSE, COL_TEXT, N_("Username"), col_username, NULL, NULL, "username"},
 307   {TRUE, COL_FLAG, N_("Flag"), NULL, NULL, NULL,  "flag"},
 308   {TRUE, COL_TEXT, N_("Nation"), col_nation, NULL, NULL,  "nation"},
 309   {TRUE, COL_COLOR, N_("Border"), NULL, NULL, NULL,  "border"},
 310   {TRUE, COL_RIGHT_TEXT, N_("Score"), get_score_text, NULL, cmp_score, "score"},
 311   {TRUE, COL_TEXT, N_("Team"), col_team, NULL, NULL,  "team"},
 312   {TRUE, COL_BOOLEAN, N_("AI"), NULL, col_ai, NULL,  "ai"},
 313   {TRUE, COL_TEXT, N_("Attitude"), col_love, NULL, cmp_love,  "attitude"},
 314   {TRUE, COL_TEXT, N_("Embassy"), col_embassy, NULL, NULL,  "embassy"},
 315   {TRUE, COL_TEXT, N_("Dipl.State"), col_diplstate, NULL, cmp_diplstate,
 316     "diplstate"},
 317   {TRUE, COL_TEXT, N_("Vision"), col_vision, NULL, NULL,  "vision"},
 318   {TRUE, COL_TEXT, N_("State"), plrdlg_col_state, NULL, NULL,  "state"},
 319   {FALSE, COL_TEXT, N_("?Player_dlg:Host"), col_host, NULL, NULL,  "host"},
 320   {FALSE, COL_RIGHT_TEXT, N_("?Player_dlg:Idle"), col_idle, NULL, NULL,  "idle"},
 321   {FALSE, COL_RIGHT_TEXT, N_("Ping"), get_ping_time_text, NULL, NULL,  "ping"}
 322 };
 323
 324 const int num_player_dlg_columns = ARRAY_SIZE(player_dlg_columns);
 325
 326 /******************************************************************
 327   Return default player dlg sorting column.
 328 *******************************************************************/
 329 int player_dlg_default_sort_column(void)
 330 {
 331   return 3;
 332 }
 333
 334 /****************************************************************************
 335   Translate all titles
 336 ****************************************************************************/
 337 void init_player_dlg_common()
 338 {
 339   int i;
 340
 341   for (i = 0; i < num_player_dlg_columns; i++) {
 342     player_dlg_columns[i].title = Q_(player_dlg_columns[i].title);
 343   }
 344 }
 345
 346 /**************************************************************************
 347   The only place where this is used is the player dialog.
 348   Eventually this should go the way of the dodo with everything here
 349   moved into col_host above, but some of the older clients (+win32) still
 350   use this function directly.
 351
 352   This code in this function is only really needed so that the host is
 353   kept as a blank address if no one is controlling a player, but there are
 354   observers.
 355 **************************************************************************/
 356 const char *player_addr_hack(const struct player *pplayer)
 357 {
 358   conn_list_iterate(pplayer->connections, pconn) {
 359     if (!pconn->observer) {
 360       return pconn->addr;
 361     }
 362   } conn_list_iterate_end;
 363
 364   return blank_addr_str;
 365 }