Freeciv-3.2: /fast/freeciv/nightly/S3_2/client/plrdlg_common.c Source File

Freeciv-3.2

Loading...
Searching...
No Matches
plrdlg_common.c
Go to the documentation of this file.
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#include "government.h"
29#include "nation.h"
30#include "research.h"
31
32/* client */
33#include "client_main.h"
34#include "climisc.h"
35#include "options.h"
36#include "text.h"
37
38/* client/include */
39#include "plrdlg_g.h"
40
41#include "plrdlg_common.h"
42
43
44/************************************************************************/
47 static const char *col_name(const struct player *player)
48{
49 return player_name(player);
50}
51
52/************************************************************************/
55 static int cmp_name(const struct player *pplayer1,
56 const struct player *pplayer2)
57{
58 return fc_stricoll(player_name(pplayer1), player_name(pplayer2));
59}
60
61/************************************************************************/
64 static const char *col_username(const struct player *player)
65{
66 return player->username;
67}
68
69/************************************************************************/
72 static const char *col_nation(const struct player *player)
73{
74 return nation_adjective_for_player(player);
75}
76
77/************************************************************************/
80 static const char *col_team(const struct player *player)
81{
82 return team_name_translation(player->team);
83}
84
85/************************************************************************/
88 static bool col_ai(const struct player *plr)
89{
90 /* TODO: Currently is_ai() is a macro so we can't have it
91 * directly as this callback, but once it's a function,
92 * do that. */
93 return is_ai(plr);
94}
95
96/************************************************************************/
100 static const char *col_embassy(const struct player *player)
101{
102 return get_embassy_status(client.conn.playing, player);
103}
104
105/************************************************************************/
109 static const char *col_diplstate(const struct player *player)
110{
111 static char buf[100];
112 const struct player_diplstate *pds;
113
114 if (NULL == client.conn.playing || player == client.conn.playing) {
115 return "-";
116 } else {
117 pds = player_diplstate_get(client.conn.playing, player);
118 if (pds->type == DS_CEASEFIRE || pds->type == DS_ARMISTICE) {
119 fc_snprintf(buf, sizeof(buf), "%s (%d)",
120 diplstate_type_translated_name(pds->type),
121 pds->turns_left);
122 return buf;
123 } else {
124 return diplstate_type_translated_name(pds->type);
125 }
126 }
127}
128
129/************************************************************************/
135 static int diplstate_value(const struct player *plr)
136{
137 /* these values are scaled so that adding/subtracting
138 the number of turns left makes sense */
139 static const int diplstate_cmp_lookup[DS_LAST] = {
140 [DS_TEAM] = 1 << 16,
141 [DS_ALLIANCE] = 2 << 16,
142 [DS_PEACE] = 3 << 16,
143 [DS_ARMISTICE] = 4 << 16,
144 [DS_CEASEFIRE] = 5 << 16,
145 [DS_WAR] = 6 << 16,
146 [DS_NO_CONTACT] = 7 << 16
147 };
148
149 const struct player_diplstate *pds;
150 int ds_value;
151
152 if (NULL == client.conn.playing || plr == client.conn.playing) {
153 /* current global player is as close as players get
154 -> return value smaller than for DS_TEAM */
155 return 0;
156 }
157
158 pds = player_diplstate_get(client.conn.playing, plr);
159 ds_value = diplstate_cmp_lookup[pds->type];
160
161 if (pds->type == DS_ARMISTICE || pds->type == DS_CEASEFIRE) {
162 ds_value += pds->turns_left;
163 }
164
165 return ds_value;
166}
167
168/************************************************************************/
171 static int cmp_diplstate(const struct player *player1,
172 const struct player *player2)
173{
174 return diplstate_value(player1) - diplstate_value(player2);
175}
176
177/************************************************************************/
180 static const char *col_love(const struct player *player)
181{
182 if (NULL == client.conn.playing || player == client.conn.playing
183 || is_human(player)) {
184 return "-";
185 } else {
186 return love_text(player->ai_common.love[player_index(client.conn.playing)]);
187 }
188}
189
190/************************************************************************/
193 static int cmp_love(const struct player *player1,
194 const struct player *player2)
195{
196 int love1, love2;
197
198 if (NULL == client.conn.playing) {
199 return player_number(player1) - player_number(player2);
200 }
201
202 if (player1 == client.conn.playing || is_human(player1)) {
203 love1 = MAX_AI_LOVE + 999;
204 } else {
205 love1 = player1->ai_common.love[player_index(client.conn.playing)];
206 }
207
208 if (player2 == client.conn.playing || is_human(player2)) {
209 love2 = MAX_AI_LOVE + 999;
210 } else {
211 love2 = player2->ai_common.love[player_index(client.conn.playing)];
212 }
213
214 return love1 - love2;
215}
216
217/************************************************************************/
220 static const char *col_vision(const struct player *player)
221{
222 return get_vision_status(client.conn.playing, player);
223}
224
225/************************************************************************/
230 const char *plrdlg_col_state(const struct player *plr)
231{
232 if (!plr->is_alive) {
233 /* TRANS: Dead -- Rest In Peace -- Reqia In Pace */
234 return _("R.I.P.");
235 } else if (!plr->is_connected) {
236 struct option *opt;
237 bool consider_tb = FALSE;
238
239 if (is_ai(plr)) {
240 return "";
241 }
242
243 opt = optset_option_by_name(server_optset, "turnblock");
244 if (opt != NULL) {
245 consider_tb = option_bool_get(opt);
246 }
247
248 if (!consider_tb) {
249 /* TRANS: No connection */
250 return _("noconn");
251 }
252
253 if (!is_player_phase(plr, game.info.phase)) {
254 return _("waiting");
255 } else if (plr->phase_done) {
256 return _("done");
257 } else {
258 /* TRANS: Turnblocking & player not connected */
259 return _("blocking");
260 }
261 } else {
262 if (!is_player_phase(plr, game.info.phase)) {
263 return _("waiting");
264 } else if (plr->phase_done) {
265 return _("done");
266 } else {
267 return _("moving");
268 }
269 }
270}
271
272/************************************************************************/
279 static const char *col_host(const struct player *pplayer)
280{
281 conn_list_iterate(pplayer->connections, pconn) {
282 if (!pconn->observer) {
283 return pconn->addr;
284 }
285 } conn_list_iterate_end;
286
287 return blank_addr_str;
288}
289
290/************************************************************************/
293 static const char *col_idle(const struct player *plr)
294{
295 int idle;
296 static char buf[100];
297
298 if (plr->nturns_idle > 3) {
299 idle = plr->nturns_idle - 1;
300 } else {
301 idle = 0;
302 }
303 fc_snprintf(buf, sizeof(buf), "%d", idle);
304 return buf;
305}
306
307/************************************************************************/
310 static int cmp_score(const struct player *player1,
311 const struct player *player2)
312{
313 return player1->score.game - player2->score.game;
314}
315
316/************************************************************************/
319 static const char *col_government(const struct player *them)
320{
321 static char buf[100];
322 const struct player *me = client_player();
323
324 /* 'contact' gives the knowledge of other's government */
325 if (me == them
326 || client_is_global_observer()
327 || team_has_embassy(me->team, them)
328 || player_diplstate_get(me, them)->contact_turns_left > 0 ) {
329 fc_snprintf(buf, sizeof(buf),"%s", government_name_for_player(them));
330 } else {
331 fc_snprintf(buf, sizeof(buf),"?");
332 }
333
334 return buf;
335}
336
337/************************************************************************/
341 static int cmp_culture(const struct player *player1,
342 const struct player *player2)
343{
344 return player1->client.culture - player2->client.culture;
345}
346
347/************************************************************************/
350 static const char *get_culture_info(const struct player *them)
351{
352 static char buf[10];
353 const struct player *me = client_player();
354 bool gobs = client_is_global_observer();
355
356 if (them == NULL || !them->is_alive) {
357 fc_snprintf(buf, sizeof(buf), "-");
358 } else if (gobs
359 || (me != NULL
360 && (me == them || team_has_embassy(me->team, them)))) {
361 fc_snprintf(buf, sizeof(buf), "%d", them->client.culture);
362 } else {
363 fc_snprintf(buf, sizeof(buf), "?");
364 }
365
366 return buf;
367}
368
369/************************************************************************/
372 static const char *col_culture(const struct player *pplayer)
373{
374 return get_culture_info(pplayer);
375}
376
377/************************************************************************/
381 static int cmp_gold(const struct player* player1,
382 const struct player* player2)
383{
384 return player1->economic.gold - player2->economic.gold;
385}
386
387/************************************************************************/
390 static const char *get_gold_info(const struct player *them)
391{
392 static char buf[10];
393 const struct player *me = client_player();
394 bool gobs = client_is_global_observer();
395
396 if (them == NULL || !them->is_alive) {
397 fc_snprintf(buf, sizeof(buf), "-");
398 } else if (gobs
399 || (me != NULL
400 && (me == them || team_has_embassy(me->team, them)
401 || player_diplstate_get(me, them)->contact_turns_left > 0))) {
402 fc_snprintf(buf, sizeof(buf), "%d", them->economic.gold);
403 } else {
404 fc_snprintf(buf, sizeof(buf), "?");
405 }
406
407 return buf;
408}
409
410/************************************************************************/
413 static const char *col_gold(const struct player *pplayer)
414{
415 return get_gold_info(pplayer);
416}
417
418/************************************************************************/
422 static int cmp_tax(const struct player* player1,
423 const struct player* player2)
424{
425 return player1->economic.tax - player2->economic.tax;
426}
427
428/************************************************************************/
431 static const char *get_tax_info(const struct player *them)
432{
433 static char buf[10];
434 const struct player *me = client_player();
435 bool gobs = client_is_global_observer();
436
437 if (them == NULL || !them->is_alive) {
438 fc_snprintf(buf, sizeof(buf), "-");
439 } else if (gobs
440 || (me != NULL
441 && (me == them || team_has_embassy(me->team, them)))) {
442 fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.tax);
443 } else {
444 fc_snprintf(buf, sizeof(buf), "?");
445 }
446
447 return buf;
448}
449
450/************************************************************************/
453 static const char *col_tax(const struct player *pplayer)
454{
455 return get_tax_info(pplayer);
456}
457
458/************************************************************************/
462 static int cmp_science(const struct player* player1,
463 const struct player* player2)
464{
465 return player1->economic.science - player2->economic.science;
466}
467
468/************************************************************************/
471 static const char *get_science_info(const struct player *them)
472{
473 static char buf[10];
474 const struct player *me = client_player();
475 bool gobs = client_is_global_observer();
476
477 if (them == NULL || !them->is_alive) {
478 fc_snprintf(buf, sizeof(buf), "-");
479 } else if (gobs
480 || (me != NULL
481 && (me == them || team_has_embassy(me->team, them)))) {
482 fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.science);
483 } else {
484 fc_snprintf(buf, sizeof(buf), "?");
485 }
486
487 return buf;
488}
489
490/************************************************************************/
493 static const char *col_science(const struct player *pplayer)
494{
495 return get_science_info(pplayer);
496}
497
498/************************************************************************/
502 static int cmp_luxury(const struct player* player1,
503 const struct player* player2)
504{
505 return player1->economic.luxury - player2->economic.luxury;
506}
507
508/************************************************************************/
511 static const char *get_luxury_info(const struct player *them)
512{
513 static char buf[10];
514 const struct player *me = client_player();
515 bool gobs = client_is_global_observer();
516
517 if (them == NULL || !them->is_alive) {
518 fc_snprintf(buf, sizeof(buf), "-");
519 } else if (gobs
520 || (me != NULL
521 && (me == them || team_has_embassy(me->team, them)))) {
522 fc_snprintf(buf, sizeof(buf), "%d %%", them->economic.luxury);
523 } else {
524 fc_snprintf(buf, sizeof(buf), "?");
525 }
526
527 return buf;
528}
529
530/************************************************************************/
533 static const char *col_luxury(const struct player *pplayer)
534{
535 return get_luxury_info(pplayer);
536}
537
538/************************************************************************/
541 static const char *get_researching_info(const struct player *them)
542{
543 static char buf[100];
544 const struct player *me = client_player();
545 bool gobs = client_is_global_observer();
546
547 if (them == NULL || !them->is_alive) {
548 fc_snprintf(buf, sizeof(buf), "-");
549 } else if (gobs
550 || (me != NULL
551 && (me == them || team_has_embassy(me->team, them)))) {
552 struct research *research = research_get(them);
553
554 fc_snprintf(buf, sizeof(buf), "%s",
555 research_advance_name_translation(research, research->researching));
556 } else {
557 fc_snprintf(buf, sizeof(buf), "?");
558 }
559
560 return buf;
561}
562
563/************************************************************************/
566 static const char *col_research(const struct player *pplayer)
567{
568 return get_researching_info(pplayer);
569}
570
571/****************************************************************************
572 ...
573****************************************************************************/
574 struct player_dlg_column player_dlg_columns[] = {
575 {TRUE, COL_TEXT, N_("?Player:Name"), col_name, NULL, cmp_name, "name"},
576 {FALSE, COL_TEXT, N_("Username"), col_username, NULL, NULL, "username"},
577 {TRUE, COL_FLAG, N_("Flag"), NULL, NULL, NULL, "flag"},
578 {TRUE, COL_TEXT, N_("Nation"), col_nation, NULL, NULL, "nation"},
579 {TRUE, COL_COLOR, N_("Border"), NULL, NULL, NULL, "border"},
580 {TRUE, COL_RIGHT_TEXT, N_("Score"), get_score_text, NULL, cmp_score, "score"},
581 {TRUE, COL_TEXT, N_("Team"), col_team, NULL, NULL, "team"},
582 {TRUE, COL_BOOLEAN, N_("AI"), NULL, col_ai, NULL, "ai"},
583 {TRUE, COL_TEXT, N_("Attitude"), col_love, NULL, cmp_love, "attitude"},
584 {TRUE, COL_TEXT, N_("Embassy"), col_embassy, NULL, NULL, "embassy"},
585 {TRUE, COL_TEXT, N_("Dipl.State"), col_diplstate, NULL, cmp_diplstate,
586 "diplstate"},
587 {TRUE, COL_TEXT, N_("Vision"), col_vision, NULL, NULL, "vision"},
588 {TRUE, COL_TEXT, N_("State"), plrdlg_col_state, NULL, NULL, "state"},
589 {FALSE, COL_TEXT, N_("?Player_dlg:Host"), col_host, NULL, NULL, "host"},
590 {FALSE, COL_RIGHT_TEXT, N_("?Player_dlg:Idle"), col_idle, NULL, NULL, "idle"},
591 {FALSE, COL_RIGHT_TEXT, N_("Ping"), get_ping_time_text, NULL, NULL, "ping"},
592 {TRUE, COL_TEXT, N_("Government"), col_government, NULL, NULL, "government"},
593 {TRUE, COL_RIGHT_TEXT, N_("Culture"), col_culture, NULL, cmp_culture, "culture"},
594 {TRUE, COL_RIGHT_TEXT, N_("Gold"), col_gold, NULL, cmp_gold, "gold"},
595 {TRUE, COL_RIGHT_TEXT, N_("Tax"), col_tax, NULL, cmp_tax, "tax"},
596 {TRUE, COL_RIGHT_TEXT, N_("Science"), col_science, NULL, cmp_science, "science"},
597 {TRUE, COL_RIGHT_TEXT, N_("Luxury"), col_luxury, NULL, cmp_luxury, "luxury"},
598 {TRUE, COL_TEXT, N_("Research"), col_research, NULL, NULL, "research"}
599};
600
601 const int num_player_dlg_columns = ARRAY_SIZE(player_dlg_columns);
602
603/************************************************************************/
606 int player_dlg_default_sort_column(void)
607{
608 return 3;
609}
610
611/************************************************************************/
614 void init_player_dlg_common(void)
615{
616 int i;
617
618 for (i = 0; i < num_player_dlg_columns; i++) {
619 player_dlg_columns[i].title = Q_(player_dlg_columns[i].title);
620 }
621}
client_is_global_observer
bool client_is_global_observer(void)
Definition client_main.c:1345
client
struct civclient client
Definition client_main.c:150
client_main.h
client_player
#define client_player()
Definition client_main.h:106
get_embassy_status
const char * get_embassy_status(const struct player *me, const struct player *them)
Definition climisc.c:194
get_vision_status
const char * get_vision_status(const struct player *me, const struct player *them)
Definition climisc.c:222
climisc.h
incite_cost
char * incite_cost
Definition comments.c:74
blank_addr_str
const char blank_addr_str[]
Definition connection.c:55
connection.h
conn_list_iterate
#define conn_list_iterate(connlist, pconn)
Definition connection.h:108
conn_list_iterate_end
#define conn_list_iterate_end
Definition connection.h:110
fcintl.h
Q_
#define Q_(String)
Definition fcintl.h:70
_
#define _(String)
Definition fcintl.h:67
N_
#define N_(String)
Definition fcintl.h:69
game
struct civ_game game
Definition game.c:62
is_player_phase
bool is_player_phase(const struct player *pplayer, int phase)
Definition game.c:705
game.h
government_name_for_player
const char * government_name_for_player(const struct player *pplayer)
Definition government.c:154
government.h
title
const char * title
Definition repodlgs.c:1314
COL_TEXT
@ COL_TEXT
Definition unitselect.c:50
log.h
nation_adjective_for_player
const char * nation_adjective_for_player(const struct player *pplayer)
Definition nation.c:169
nation.h
server_optset
const struct option_set * server_optset
Definition options.c:4019
option_bool_get
bool option_bool_get(const struct option *poption)
Definition options.c:796
optset_option_by_name
struct option * optset_option_by_name(const struct option_set *poptset, const char *name)
Definition options.c:430
options.h
player_number
int player_number(const struct player *pplayer)
Definition player.c:837
player_name
const char * player_name(const struct player *pplayer)
Definition player.c:895
team_has_embassy
bool team_has_embassy(const struct team *pteam, const struct player *tgt_player)
Definition player.c:220
player_index
int player_index(const struct player *pplayer)
Definition player.c:829
player_diplstate_get
struct player_diplstate * player_diplstate_get(const struct player *plr1, const struct player *plr2)
Definition player.c:324
love_text
const char * love_text(const int love)
Definition player.c:1354
MAX_AI_LOVE
#define MAX_AI_LOVE
Definition player.h:561
is_ai
#define is_ai(plr)
Definition player.h:230
is_human
#define is_human(plr)
Definition player.h:229
col_username
static const char * col_username(const struct player *player)
Definition plrdlg_common.c:64
cmp_name
static int cmp_name(const struct player *pplayer1, const struct player *pplayer2)
Definition plrdlg_common.c:55
col_gold
static const char * col_gold(const struct player *pplayer)
Definition plrdlg_common.c:413
player_dlg_default_sort_column
int player_dlg_default_sort_column(void)
Definition plrdlg_common.c:606
get_culture_info
static const char * get_culture_info(const struct player *them)
Definition plrdlg_common.c:350
col_ai
static bool col_ai(const struct player *plr)
Definition plrdlg_common.c:88
cmp_culture
static int cmp_culture(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:341
cmp_diplstate
static int cmp_diplstate(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:171
col_nation
static const char * col_nation(const struct player *player)
Definition plrdlg_common.c:72
get_science_info
static const char * get_science_info(const struct player *them)
Definition plrdlg_common.c:471
cmp_score
static int cmp_score(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:310
cmp_tax
static int cmp_tax(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:422
col_host
static const char * col_host(const struct player *pplayer)
Definition plrdlg_common.c:279
col_vision
static const char * col_vision(const struct player *player)
Definition plrdlg_common.c:220
col_embassy
static const char * col_embassy(const struct player *player)
Definition plrdlg_common.c:100
init_player_dlg_common
void init_player_dlg_common(void)
Definition plrdlg_common.c:614
plrdlg_col_state
const char * plrdlg_col_state(const struct player *plr)
Definition plrdlg_common.c:230
diplstate_value
static int diplstate_value(const struct player *plr)
Definition plrdlg_common.c:135
col_name
static const char * col_name(const struct player *player)
Definition plrdlg_common.c:47
col_team
static const char * col_team(const struct player *player)
Definition plrdlg_common.c:80
col_love
static const char * col_love(const struct player *player)
Definition plrdlg_common.c:180
cmp_luxury
static int cmp_luxury(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:502
get_luxury_info
static const char * get_luxury_info(const struct player *them)
Definition plrdlg_common.c:511
player_dlg_columns
struct player_dlg_column player_dlg_columns[]
Definition plrdlg_common.c:574
col_science
static const char * col_science(const struct player *pplayer)
Definition plrdlg_common.c:493
col_government
static const char * col_government(const struct player *them)
Definition plrdlg_common.c:319
col_idle
static const char * col_idle(const struct player *plr)
Definition plrdlg_common.c:293
cmp_gold
static int cmp_gold(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:381
col_diplstate
static const char * col_diplstate(const struct player *player)
Definition plrdlg_common.c:109
cmp_science
static int cmp_science(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:462
get_researching_info
static const char * get_researching_info(const struct player *them)
Definition plrdlg_common.c:541
get_gold_info
static const char * get_gold_info(const struct player *them)
Definition plrdlg_common.c:390
col_luxury
static const char * col_luxury(const struct player *pplayer)
Definition plrdlg_common.c:533
get_tax_info
static const char * get_tax_info(const struct player *them)
Definition plrdlg_common.c:431
col_research
static const char * col_research(const struct player *pplayer)
Definition plrdlg_common.c:566
cmp_love
static int cmp_love(const struct player *player1, const struct player *player2)
Definition plrdlg_common.c:193
col_tax
static const char * col_tax(const struct player *pplayer)
Definition plrdlg_common.c:453
num_player_dlg_columns
const int num_player_dlg_columns
Definition plrdlg_common.c:601
col_culture
static const char * col_culture(const struct player *pplayer)
Definition plrdlg_common.c:372
plrdlg_common.h
COL_BOOLEAN
@ COL_BOOLEAN
Definition plrdlg_common.h:31
COL_FLAG
@ COL_FLAG
Definition plrdlg_common.h:29
COL_RIGHT_TEXT
@ COL_RIGHT_TEXT
Definition plrdlg_common.h:33
COL_COLOR
@ COL_COLOR
Definition plrdlg_common.h:30
plrdlg_g.h
research_advance_name_translation
const char * research_advance_name_translation(const struct research *presearch, Tech_type_id tech)
Definition research.c:273
research_get
struct research * research_get(const struct player *pplayer)
Definition research.c:128
research.h
ARRAY_SIZE
#define ARRAY_SIZE(x)
Definition shared.h:85
civ_game::info
struct packet_game_info info
Definition game.h:89
civclient::conn
struct connection conn
Definition client_main.h:96
connection::playing
struct player * playing
Definition connection.h:151
option
Definition options.c:478
packet_game_info::phase
int phase
Definition packets_gen.h:206
player_ai::love
int love[MAX_NUM_PLAYER_SLOTS]
Definition player.h:122
player_diplstate
Definition player.h:196
player_dlg_column
Definition plrdlg_common.h:39
player_dlg_column::title
const char * title
Definition plrdlg_common.h:42
player
Definition player.h:247
player::ai_common
struct player_ai ai_common
Definition player.h:286
player::username
char username[MAX_LEN_NAME]
Definition player.h:250
player::is_connected
bool is_connected
Definition player.h:294
player::nturns_idle
int nturns_idle
Definition player.h:263
player::team
struct team * team
Definition player.h:259
player::connections
struct conn_list * connections
Definition player.h:296
player::is_alive
bool is_alive
Definition player.h:266
player::phase_done
bool phase_done
Definition player.h:261
research
Definition research.h:39
research::researching
Tech_type_id researching
Definition research.h:52
fc_snprintf
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:974
fc_stricoll
int fc_stricoll(const char *str0, const char *str1)
Definition support.c:487
support.h
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
team_name_translation
const char * team_name_translation(const struct team *pteam)
Definition team.c:420
get_ping_time_text
const char * get_ping_time_text(const struct player *pplayer)
Definition text.c:1621
get_score_text
const char * get_score_text(const struct player *pplayer)
Definition text.c:1650
text.h