Freeciv-3.2
Loading...
Searching...
No Matches
climisc.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/***********************************************************************
15 This module contains various general - mostly highlevel - functions
16 used throughout the client.
17***********************************************************************/
18
19#ifdef HAVE_CONFIG_H
20#include <fc_config.h>
21#endif
22
23#include <stdarg.h>
24#include <stdio.h>
25#include <stdlib.h>
26#include <string.h>
27
28/* utility */
29#include "bitvector.h"
30#include "fcintl.h"
31#include "log.h"
32#include "support.h"
33
34/* common */
35#include "city.h"
36#include "diptreaty.h"
37#include "featured_text.h"
38#include "game.h"
39#include "government.h"
40#include "map.h"
41#include "mapimg.h"
42#include "packets.h"
43#include "research.h"
44#include "spaceship.h"
45#include "unitlist.h"
46
47/* client/include */
48#include "chatline_g.h"
49#include "citydlg_g.h"
50#include "cityrep_g.h"
51#include "dialogs_g.h"
52#include "gui_main_g.h"
53#include "mapview_g.h"
54
55/* client */
56#include "client_main.h"
57#include "climap.h"
58#include "climisc.h"
59#include "control.h"
60#include "mapctrl_common.h"
61#include "mapview_common.h"
62#include "messagewin_common.h"
63#include "options.h"
64#include "packhand.h"
65#include "repodlgs_common.h"
66#include "tilespec.h"
67
68
69/**********************************************************************/
73{
74 struct city *pcity;
75 struct tile *ptile = unit_tile(punit);
76 int hc = punit->homecity;
77 struct unit old_unit = *punit;
78 int old = get_num_units_in_focus();
79 bool update;
80
81 log_debug("removing unit %d, %s %s (%d %d) hcity %d",
84
86
87 /* Check transport status. */
91 /* The server should take care that the unit is on the right terrain. */
94 }
95
98 punit = NULL;
99 if (old > 0 && get_num_units_in_focus() == 0) {
101 } else if (update) {
104 }
105
106 pcity = tile_city(ptile);
107 if (NULL != pcity) {
109 pcity->client.occupied = (0 < unit_list_size(pcity->tile->units));
110 refresh_city_dialog(pcity);
111 }
112
113 log_debug("map city %s, %s, (%d %d)",
115 TILE_XY(city_tile(pcity)));
116 }
117
119 pcity = game_city_by_number(hc);
120 if (NULL != pcity) {
121 refresh_city_dialog(pcity);
122 log_debug("home city %s, %s, (%d %d)",
124 TILE_XY(city_tile(pcity)));
125 }
126 }
127
129}
130
131/**********************************************************************/
134void client_remove_city(struct city *pcity)
135{
136 bool effect_update;
137 struct tile *ptile = city_tile(pcity);
138 struct city old_city = *pcity;
139
140 log_debug("client_remove_city() %d, %s", pcity->id, city_name_get(pcity));
141
142 /* Explicitly remove all improvements, to properly remove any global effects
143 and to handle the preservation of "destroyed" effects. */
145
146 city_built_iterate(pcity, pimprove) {
148 city_remove_improvement(pcity, pimprove);
150
151 if (effect_update) {
152 /* nothing yet */
153 }
154
155 popdown_city_dialog(pcity);
156 game_remove_city(&wld, pcity);
159}
160
161/**********************************************************************/
165void client_change_all(struct universal *from, struct universal *to)
166{
168 return;
169 }
170
172 _("Changing production of every %s into %s."),
173 VUT_UTYPE == from->kind
176 VUT_UTYPE == to->kind
179
182 if (are_universals_equal(&pcity->production, from)
183 && can_city_build_now(pcity, to)) {
184 city_change_production(pcity, to);
185 }
187
189}
190
191/**********************************************************************/
194const char *get_embassy_status(const struct player *me,
195 const struct player *them)
196{
197 if (!me || !them
198 || me == them
199 || !them->is_alive
200 || !me->is_alive) {
201 return "-";
202 }
203 if (player_has_embassy(me, them)) {
204 if (player_has_embassy(them, me)) {
205 return Q_("?embassy:Both");
206 } else {
207 return Q_("?embassy:Yes");
208 }
209 } else if (player_has_embassy(them, me)) {
210 return Q_("?embassy:With Us");
211 } else if (player_diplstate_get(me, them)->contact_turns_left > 0
212 || player_diplstate_get(them, me)->contact_turns_left > 0) {
213 return Q_("?embassy:Contact");
214 } else {
215 return Q_("?embassy:No Contact");
216 }
217}
218
219/**********************************************************************/
222const char *get_vision_status(const struct player *me,
223 const struct player *them)
224{
225 if (me && them && gives_shared_vision(me, them)) {
227 return Q_("?vision:Both");
228 } else {
229 return Q_("?vision:To Them");
230 }
231 } else if (me && them && gives_shared_vision(them, me)) {
232 return Q_("?vision:To Us");
233 } else {
234 return "";
235 }
236}
237
238/**********************************************************************/
242 struct Clause *pclause)
243{
244 struct city *pcity;
245
246 switch (pclause->type) {
247 case CLAUSE_ADVANCE:
248 fc_snprintf(buf, bufsiz, _("The %s give %s"),
251 return;
252 case CLAUSE_CITY:
253 pcity = game_city_by_number(pclause->value);
254 if (pcity) {
255 fc_snprintf(buf, bufsiz, _("The %s give %s"),
257 city_name_get(pcity));
258 } else {
259 fc_snprintf(buf, bufsiz,_("The %s give an unknown city"),
261 }
262 return;
263 case CLAUSE_GOLD:
264 fc_snprintf(buf, bufsiz, PL_("The %s give %d gold",
265 "The %s give %d gold", pclause->value),
267 pclause->value);
268 return;
269 case CLAUSE_MAP:
270 fc_snprintf(buf, bufsiz, _("The %s give their worldmap"),
272 return;
273 case CLAUSE_SEAMAP:
274 fc_snprintf(buf, bufsiz, _("The %s give their seamap"),
276 return;
277 case CLAUSE_CEASEFIRE:
278 fc_snprintf(buf, bufsiz, _("The parties agree on a cease-fire"));
279 return;
280 case CLAUSE_PEACE:
281 fc_snprintf(buf, bufsiz, _("The parties agree on a peace"));
282 return;
283 case CLAUSE_ALLIANCE:
284 fc_snprintf(buf, bufsiz, _("The parties create an alliance"));
285 return;
286 case CLAUSE_VISION:
287 fc_snprintf(buf, bufsiz, _("The %s give shared vision"),
289 return;
290 case CLAUSE_EMBASSY:
291 fc_snprintf(buf, bufsiz, _("The %s give an embassy"),
293 return;
295 fc_snprintf(buf, bufsiz, _("The %s share tiles"),
297 return;
298 case CLAUSE_COUNT:
300 return;
301 }
302
304 if (bufsiz > 0) {
305 *buf = '\0';
306 }
307}
308
309/**********************************************************************/
314static void catastrophe_scaled(int *chance, int *rate, int max,
315 int current, int accum, int level)
316{
317 /* 20 from factor in update_environmental_upset() */
318 int numer = 20 * max;
319 int denom = map_num_tiles();
320
321 if (chance) {
322 *chance = CLIP(0,
323 (int)((((long)accum * numer) + (denom - 1)) / denom),
324 max);
325 }
326 if (rate) {
327 *rate = DIVIDE(((long)(current - level) * numer) + (denom - 1), denom);
328 }
329}
330
331/**********************************************************************/
334void global_warming_scaled(int *chance, int *rate, int max)
335{
336 return catastrophe_scaled(chance, rate, max,
339}
340
341/**********************************************************************/
344void nuclear_winter_scaled(int *chance, int *rate, int max)
345{
346 return catastrophe_scaled(chance, rate, max,
349}
350
351/**********************************************************************/
355{
357 const struct research *presearch = research_get(client_player());
358 int idx = 0;
359
360 if (A_UNSET != presearch->researching) {
361 idx = (NUM_TILES_PROGRESS * presearch->bulbs_researched
362 / (presearch->client.researching_cost + 1));
363 }
364
365 /* This clipping can be necessary since we can end up with excess
366 * research */
367 idx = CLIP(0, idx, NUM_TILES_PROGRESS - 1);
369 } else {
371 }
372}
373
374/**********************************************************************/
378{
379 int idx;
380
382 /* Highest sprite kicks in at about 25% risk */
384 idx = CLIP(0, idx, NUM_TILES_PROGRESS-1);
385 } else {
386 idx = 0;
387 }
389}
390
391/**********************************************************************/
395{
396 int idx;
397
399 /* Highest sprite kicks in at about 25% risk */
401 idx = CLIP(0, idx, NUM_TILES_PROGRESS-1);
402 } else {
403 idx = 0;
404 }
405
407}
408
409/**********************************************************************/
413{
415 && government_count() > 0) {
417
418 return get_government_sprite(tileset, gov);
419 } else {
420 /* HACK: the UNHAPPY citizen is used for the government
421 * when we don't know any better. */
423 }
424}
425
426/**********************************************************************/
431{
432 struct city *pcity;
433 struct unit *punit;
434
435 if (!can_client_change_view()) {
436 return;
437 }
438
440 if (get_num_units_in_focus() > 0) {
442 } else if (client_has_player()
443 && NULL != (pcity = player_primary_capital(client_player()))) {
444 /* Else focus on the capital. */
446 } else if (NULL != client.conn.playing
448 /* Just focus on any city. */
450 fc_assert_ret(pcity != NULL);
452 } else if (NULL != client.conn.playing
454 /* Just focus on any unit. */
458 } else {
459 struct tile *ctile = native_pos_to_tile(&(wld.map), wld.map.xsize / 2, wld.map.ysize / 2);
460
461 /* Just any known tile will do; search near the middle first. */
462 /* Iterate outward from the center tile. We have to give a radius that
463 * is guaranteed to be larger than the map will be. Although this is
464 * a misuse of map.xsize and map.ysize (which are native dimensions),
465 * it should give a sufficiently large radius. */
467 if (client_tile_get_known(ptile) != TILE_UNKNOWN) {
468 ctile = ptile;
469 break;
470 }
472
474 }
475 can_slide = TRUE;
476}
477
478/**********************************************************************/
482{
483 return VUT_UTYPE == target.kind
484 ? B_LAST + utype_number(target.value.utype)
486}
487
488/**********************************************************************/
492{
493 struct universal target = {
494 .kind = VUT_UTYPE,
495 .value = {.utype = punittype}};
496
497 return cid_encode(target);
498}
499
500/**********************************************************************/
503cid cid_encode_building(const struct impr_type *pimprove)
504{
505 struct universal target = {
507 .value = {.building = pimprove}
508 };
509
510 return cid_encode(target);
511}
512
513/**********************************************************************/
516cid cid_encode_from_city(const struct city *pcity)
517{
518 return cid_encode(pcity->production);
519}
520
521/**********************************************************************/
525{
526 struct universal target;
527
528 if (id >= B_LAST) {
529 target.kind = VUT_UTYPE;
530 target.value.utype = utype_by_number(id - B_LAST);
531 } else {
532 target.kind = VUT_IMPROVEMENT;
534 }
535
536 return target;
537}
538
539/**********************************************************************/
543bool city_unit_supported(const struct city *pcity,
544 const struct universal *target)
545{
546 if (VUT_UTYPE == target->kind) {
547 const struct unit_type *tvtype = target->value.utype;
548
550 if (unit_type_get(punit) == tvtype) {
551 return TRUE;
552 }
554 }
555 return FALSE;
556}
557
558/**********************************************************************/
562bool city_unit_present(const struct city *pcity,
563 const struct universal *target)
564{
565 if (VUT_UTYPE == target->kind) {
566 const struct unit_type *tvtype = target->value.utype;
567
569 if (unit_type_get(punit) == tvtype) {
570 return TRUE;
571 }
572 }
574 }
575 return FALSE;
576}
577
578/**********************************************************************/
581bool city_building_present(const struct city *pcity,
582 const struct universal *target)
583{
584 return VUT_IMPROVEMENT == target->kind
585 && city_has_building(pcity, target->value.building);
586}
587
588/**********************************************************************/
591static int target_get_section(struct universal target)
592{
593 if (VUT_UTYPE == target.kind) {
595 return 2;
596 } else {
597 return 3;
598 }
599 } else {
601 return 1;
602 } else if (is_small_wonder(target.value.building)) {
603 return 4;
604 } else if (is_great_wonder(target.value.building)) {
605 return 5;
606 } else {
607 return 0;
608 }
609 }
610}
611
612/**********************************************************************/
615static int fc_cmp(const void *p1, const void *p2)
616{
617 const struct item *i1 = p1, *i2 = p2;
618 int s1 = target_get_section(i1->item);
619 int s2 = target_get_section(i2->item);
620
621 if (s1 == s2) {
622 return fc_strcasecmp(i1->descr, i2->descr);
623 }
624
625 return s1 - s2;
626}
627
628/**********************************************************************/
639void name_and_sort_items(struct universal *targets, int num_targets,
640 struct item *items,
641 bool show_cost, struct city *pcity)
642{
643 int i;
644
645 for (i = 0; i < num_targets; i++) {
646 struct universal target = targets[i];
647 int cost;
648 struct item *pitem = &items[i];
649 const char *name;
650
651 pitem->item = target;
652
653 if (VUT_UTYPE == target.kind) {
656 } else {
659 cost = -1;
660 } else {
661 if (pcity != NULL) {
662 cost = impr_build_shield_cost(pcity, target.value.building);
663 } else {
664 cost = MAX(target.value.building->build_cost * game.info.shieldbox / 100, 1);
665 }
666 }
667 }
668
669 if (show_cost) {
670 if (cost < 0) {
671 fc_snprintf(pitem->descr, sizeof(pitem->descr), "%s (XX)", name);
672 } else {
673 fc_snprintf(pitem->descr, sizeof(pitem->descr),
674 "%s (%d)", name, cost);
675 }
676 } else {
677 (void) fc_strlcpy(pitem->descr, name, sizeof(pitem->descr));
678 }
679 }
680
681 qsort(items, num_targets, sizeof(struct item), fc_cmp);
682}
683
684/**********************************************************************/
690 struct city **selected_cities,
692 bool append_wonders, bool change_prod,
694{
695 cid first = append_units ? B_LAST : 0;
696 cid last = (append_units
697 ? utype_count() + B_LAST
699 cid id;
700 int items_used = 0;
701
702 for (id = first; id < last; id++) {
703 bool append = FALSE;
704 struct universal target = cid_decode(id);
705
706 if (!append_units && (append_wonders != is_wonder(target.value.building))) {
707 continue;
708 }
709
710 if (!change_prod) {
711 if (client_has_player()) {
713 append |= test_func(pcity, &target);
715 } else {
716 cities_iterate(pcity) {
717 append |= test_func(pcity, &target);
719 }
720 } else {
721 int i;
722
723 for (i = 0; i < num_selected_cities; i++) {
724 append |= test_func(selected_cities[i], &target);
725 }
726 }
727
728 if (!append) {
729 continue;
730 }
731
732 targets[items_used] = target;
733 items_used++;
734 }
735
736 return items_used;
737}
738
739/**********************************************************************/
746{
748 int cids_used = 0;
749 cid id;
750
751 if (NULL == client.conn.playing) {
752 return 0;
753 }
754
755 memset(mapping, 0, sizeof(mapping));
758 }
760
761 for (id = 0; id < ARRAY_SIZE(mapping); id++) {
762 if (mapping[id]) {
763 targets[cids_used] = cid_decode(id);
764 cids_used++;
765 }
766 }
767
768 return cids_used;
769}
770
771/**********************************************************************/
778{
779 int cids_used = 0;
780
781 if (NULL == client.conn.playing) {
782 return 0;
783 }
784
785 improvement_iterate(pimprove) {
787 targets[cids_used].kind = VUT_IMPROVEMENT;
788 targets[cids_used].value.building = pimprove;
789 cids_used++;
790 }
792
795 targets[cids_used].kind = VUT_UTYPE;
796 targets[cids_used].value.utype = punittype;
797 cids_used++;
798 }
800
801 return cids_used;
802}
803
804/**********************************************************************/
809 struct city *pcity,
810 bool advanced_tech)
811{
812 struct player *pplayer = client_player();
813 int cids_used = 0;
814
815 improvement_iterate(pimprove) {
816 bool can_build;
818
819 if (NULL != pcity) {
820 /* Can the city build? */
821 can_build = can_city_build_improvement_now(pcity, pimprove);
823 pimprove);
824 } else if (NULL != pplayer) {
825 /* Can our player build? */
826 can_build = can_player_build_improvement_now(pplayer, pimprove);
828 pimprove);
829 } else {
830 /* Global observer case: can any player build? */
834 can_build = TRUE;
835 break;
836 }
838
843 break;
844 }
846 }
847
849 || (!advanced_tech && can_build)) {
850 targets[cids_used].kind = VUT_IMPROVEMENT;
851 targets[cids_used].value.building = pimprove;
852 cids_used++;
853 }
855
857 bool can_build;
859
860 if (NULL != pcity) {
861 /* Can the city build? */
864 } else if (NULL != pplayer) {
865 /* Can our player build? */
868 } else {
869 /* Global observer case: can any player build? */
873 can_build = TRUE;
874 break;
875 }
877
882 break;
883 }
885 }
886
888 || (!advanced_tech && can_build)) {
889 targets[cids_used].kind = VUT_UTYPE;
890 targets[cids_used].value.utype = punittype;
891 cids_used++;
892 }
894
895 return cids_used;
896}
897
898/**********************************************************************/
902 struct city *pcity)
903{
904 int cids_used = 0;
905
906 fc_assert_ret_val(pcity != NULL, 0);
907
908 city_built_iterate(pcity, pimprove) {
909 targets[cids_used].kind = VUT_IMPROVEMENT;
910 targets[cids_used].value.building = pimprove;
911 cids_used++;
913
914 return cids_used;
915}
916
917/**********************************************************************/
922{
923 struct unit_list *plist;
924
926 /* Other players don't see inside the city (but observers do). */
928 } else {
929 plist = pcity->units_supported;
930 }
931
932 return unit_list_size(plist);
933}
934
935/**********************************************************************/
940{
941 struct unit_list *plist;
942
944 /* Other players don't see inside the city (but observers do). */
946 } else {
947 plist = pcity->tile->units;
948 }
949
950 return unit_list_size(plist);
951}
952
953/**********************************************************************/
956void handle_event(const char *featured_text, struct tile *ptile,
957 enum event_type event, int turn, int phase, int conn_id)
958{
960 struct text_tag_list *tags;
961 int where = MW_OUTPUT; /* where to display the message */
962 bool fallback_needed = FALSE; /* we want fallback if actual 'where' is not
963 * usable */
964 bool shown = FALSE; /* Message displayed somewhere at least */
965
967 /* Server may have added a new event; leave as MW_OUTPUT */
968 log_verbose("Unknown event type %d!", event);
969 } else {
971 }
972
973 /* Get the original text. */
975 sizeof(plain_text), &tags, conn_id != -1);
976
977 /* Display link marks when an user is pointed us something. */
978 if (conn_id != -1) {
980 if (text_tag_type(ptag) == TTT_LINK) {
982 }
984 }
985
986 /* Maybe highlight our player and user names if someone is talking
987 * about us. */
988 if (-1 != conn_id
989 && client.conn.id != conn_id
991 const char *username = client.conn.username;
992 size_t userlen = strlen(username);
993 const char *playername = ((client_player() && !client_is_observer())
995 size_t playerlen = playername ? strlen(playername) : 0;
996 const char *p;
997
998 if (playername && playername[0] == '\0') {
1000 }
1001
1002 if (username && username[0] == '\0') {
1003 username = NULL;
1004 }
1005
1006 for (p = plain_text; *p != '\0'; p++) {
1007 if (NULL != username
1008 && 0 == fc_strncasecmp(p, username, userlen)) {
1010 p - plain_text + userlen,
1012
1013 fc_assert(ptag != NULL);
1014
1015 if (ptag != NULL) {
1016 /* Appends to be sure it will be applied at last. */
1018 }
1019 } else if (NULL != playername
1020 && 0 == fc_strncasecmp(p, playername, playerlen)) {
1022 p - plain_text + playerlen,
1024
1025 fc_assert(ptag != NULL);
1026
1027 if (ptag != NULL) {
1028 /* Appends to be sure it will be applied at last. */
1030 }
1031 }
1032 }
1033 }
1034
1035 /* Popup */
1036 if (BOOL_VAL(where & MW_POPUP)) {
1037 /* Popups are usually not shown if player is under AI control.
1038 * Server operator messages are shown always. */
1039 if (NULL == client.conn.playing
1041 || event == E_MESSAGE_WALL) {
1042 popup_notify_goto_dialog(_("Popup Request"), plain_text, tags, ptile);
1043 shown = TRUE;
1044 } else {
1045 /* Force to chatline so it will be visible somewhere at least.
1046 * Messages window may still handle this so chatline is not needed
1047 * after all. */
1049 }
1050 }
1051
1052 /* Message window */
1053 if (BOOL_VAL(where & MW_MESSAGES)) {
1054 /* When the game isn't running, the messages dialog isn't present. */
1055 if (C_S_RUNNING <= client_state()) {
1056 meswin_add(plain_text, tags, ptile, event, turn, phase);
1057 shown = TRUE;
1058 } else {
1059 /* Force to chatline instead. */
1061 }
1062 }
1063
1064 /* Chatline */
1065 if (BOOL_VAL(where & MW_OUTPUT) || (fallback_needed && !shown)) {
1066 output_window_event(plain_text, tags, conn_id);
1067 }
1068
1069 if (turn == game.info.turn) {
1071 }
1072
1073 /* Free tags */
1075}
1076
1077/**********************************************************************/
1081void create_event(struct tile *ptile, enum event_type event,
1082 const struct ft_color color, const char *format, ...)
1083{
1084 va_list ap;
1085 char message[MAX_LEN_MSG];
1086
1087 va_start(ap, format);
1088 fc_vsnprintf(message, sizeof(message), format, ap);
1089 va_end(ap);
1090
1093
1097 } else {
1099 }
1100}
1101
1102/**********************************************************************/
1107struct city *get_nearest_city(const struct unit *punit, int *sq_dist)
1108{
1109 struct city *pcity_near;
1110 int pcity_near_dist;
1111
1112 if ((pcity_near = tile_city(unit_tile(punit)))) {
1113 pcity_near_dist = 0;
1114 } else {
1115 pcity_near = NULL;
1116 pcity_near_dist = -1;
1117 players_iterate(pplayer) {
1118 city_list_iterate(pplayer->cities, pcity_current) {
1119 int dist = sq_map_distance(pcity_current->tile, unit_tile(punit));
1120
1121 if (pcity_near_dist == -1 || dist < pcity_near_dist
1122 || (dist == pcity_near_dist
1125 pcity_near_dist = dist;
1126 }
1129 }
1130
1131 if (sq_dist) {
1133 }
1134
1135 return pcity_near;
1136}
1137
1138/**********************************************************************/
1143void cityrep_buy(struct city *pcity)
1144{
1145 int value;
1146
1149 _("You can't buy %s in %s!"),
1151 city_link(pcity));
1152 return;
1153 }
1154 value = pcity->client.buy_cost;
1155
1156 if (city_owner(pcity)->economic.gold >= value) {
1157 city_buy_production(pcity);
1158 } else {
1159 /* Split into two to allow localization of two pluralisations. */
1160 char buf[MAX_LEN_MSG];
1161
1162 /* TRANS: %s is a production type; this whole string is a sentence
1163 * fragment that is only ever included in one other string
1164 * (search comments for this string to find it) */
1165 fc_snprintf(buf, ARRAY_SIZE(buf), PL_("%s costs %d gold",
1166 "%s costs %d gold", value),
1168 value);
1170 /* TRANS: %s is a pre-pluralised sentence fragment:
1171 * "%s costs %d gold" */
1172 PL_("%s and you only have %d gold.",
1173 "%s and you only have %d gold.",
1174 city_owner(pcity)->economic.gold),
1175 buf, city_owner(pcity)->economic.gold);
1176 }
1177}
1178
1179/**********************************************************************/
1183{
1184 int lux_end, sci_end, tax, lux, sci;
1185 int delta = 10;
1186
1187 if (!can_client_issue_orders()) {
1188 return;
1189 }
1190
1193
1197
1198 idx *= 10;
1199
1200 if (reverse) {
1201 if (idx < lux_end) {
1202 lux -= delta;
1203 tax += delta;
1204 } else if (idx < sci_end) {
1205 sci -= delta;
1206 lux += delta;
1207 } else {
1208 tax -= delta;
1209 sci += delta;
1210 }
1211 } else {
1212 if (idx < lux_end) {
1213 lux -= delta;
1214 sci += delta;
1215 } else if (idx < sci_end) {
1216 sci -= delta;
1217 tax += delta;
1218 } else {
1219 tax -= delta;
1220 lux += delta;
1221 }
1222 }
1223
1225}
1226
1227/**********************************************************************/
1230bool can_units_do_connect(struct unit_list *punits,
1231 enum unit_activity activity,
1232 struct extra_type *tgt)
1233{
1235 if (can_unit_do_connect(punit, activity, tgt)) {
1236 return TRUE;
1237 }
1239
1240 return FALSE;
1241}
1242
1243/**********************************************************************/
1248{
1249 /* A double init would cause a leak. */
1251
1254}
1255
1256/**********************************************************************/
1264{
1266
1267 if (pclass->hp_loss_pct > 0) {
1268 return UNIT_BG_HP_LOSS;
1269 }
1270
1271 if (pclass->move_type == UMT_LAND) {
1272 return UNIT_BG_LAND;
1273 }
1274 if (pclass->move_type == UMT_SEA) {
1275 return UNIT_BG_SEA;
1276 }
1277
1278 fc_assert(pclass->move_type == UMT_BOTH);
1279
1281 /* Unit moves on both sea and land by speed determined by terrain */
1282 return UNIT_BG_AMPHIBIOUS;
1283 }
1284
1285 return UNIT_BG_FLYING;
1286}
1287
1288/**********************************************************************/
1291static int city_buy_cost_compare(const void *a, const void *b)
1292{
1293 const struct city *ca, *cb;
1294
1295 ca = *((const struct city **) a);
1296 cb = *((const struct city **) b);
1297
1298 return ca->client.buy_cost - cb->client.buy_cost;
1299}
1300
1301/**********************************************************************/
1306{
1307 const struct player *pplayer = client_player();
1308 struct connection *pconn;
1309
1310 if (!pplayer || !pplayer->cities
1311 || city_list_size(pplayer->cities) < 1) {
1312 return;
1313 }
1314
1315 int gold = pplayer->economic.gold;
1316 if (gold < 1) {
1317 return;
1318 }
1319
1320 const int n = city_list_size(pplayer->cities);
1321 struct city *cities[n];
1322 int i, count = 0;
1323
1324 city_list_iterate(pplayer->cities, pcity) {
1325 if (!is_city_hilited(pcity) || !city_can_buy(pcity)) {
1326 continue;
1327 }
1328 cities[count++] = pcity;
1330
1331 if (count < 1) {
1332 return;
1333 }
1334
1335 qsort(cities, count, sizeof(*cities), city_buy_cost_compare);
1336
1337 pconn = &client.conn;
1339
1340 for (i = 0; i < count && gold > 0; i++) {
1341 gold -= cities[i]->client.buy_cost;
1343 }
1344
1346}
1347
1348/**********************************************************************/
1351void unit_focus_set_status(struct player *pplayer)
1352{
1353 unit_list_iterate(pplayer->units, punit) {
1356}
1357
1358/**********************************************************************/
1361void client_player_init(struct player *pplayer)
1362{
1364 pplayer->client.tile_vision[v].vec = NULL;
1365 pplayer->client.tile_vision[v].bits = 0;
1367}
1368
1369/**********************************************************************/
1373{
1374 players_iterate(pplayer) {
1375 int new_size;
1376
1377 if (pplayer == client.conn.playing) {
1379 } else {
1380 /* We don't need (or have) information about players other
1381 * than user of the client. Allocate just one bit as that's
1382 * the minimum bitvector size (cannot allocate 0 bits)*/
1383 new_size = 1;
1384 }
1385
1387 dbv_resize(&pplayer->client.tile_vision[v], new_size);
1389
1390 dbv_resize(&pplayer->tile_known, new_size);
1392}
1393
1394/**********************************************************************/
1398{
1399 char str[MAX_LEN_MAPDEF];
1400 char mi_map[MAPIMG_LAYER_COUNT + 1];
1401 enum mapimg_layer layer;
1402 int map_pos = 0;
1403
1404 /* Only one definition allowed. */
1405 while (mapimg_count() != 0) {
1406 mapimg_delete(0);
1407 }
1408
1409 /* Map image definition: zoom, turns */
1410 fc_snprintf(str, sizeof(str), "zoom=%d:turns=0:format=%s",
1412
1413 /* Map image definition: show */
1415 cat_snprintf(str, sizeof(str), ":show=all");
1416 /* use all available knowledge */
1418 } else {
1419 cat_snprintf(str, sizeof(str), ":show=plrid:plrid=%d",
1421 /* use only player knowledge */
1423 }
1424
1425 /* Map image definition: map */
1426 for (layer = mapimg_layer_begin(); layer != mapimg_layer_end();
1427 layer = mapimg_layer_next(layer)) {
1428 if (gui_options.mapimg_layer[layer]) {
1429 mi_map[map_pos++] = mapimg_layer_name(layer)[0];
1430 }
1431 }
1432 mi_map[map_pos] = '\0';
1433
1434 if (map_pos == 0) {
1435 /* no value set - use dummy setting */
1436 sz_strlcpy(mi_map, "-");
1437 }
1438 cat_snprintf(str, sizeof(str), ":map=%s", mi_map);
1439
1440 log_debug("client map image definition: %s", str);
1441
1442 if (!mapimg_define(str, FALSE) || !mapimg_isvalid(0)) {
1443 /* An error in the definition string or an error validation the string.
1444 * The error message is available via mapimg_error(). */
1445 return FALSE;
1446 }
1447
1448 return TRUE;
1449}
1450
1451/**********************************************************************/
1454bool mapimg_client_createmap(const char *filename)
1455{
1456 struct mapdef *pmapdef;
1457 char mapimgfile[512];
1458
1459 if (NULL == filename || '\0' == filename[0]) {
1461 } else {
1462 sz_strlcpy(mapimgfile, filename);
1463 }
1464
1465 if (!mapimg_client_define()) {
1466 return FALSE;
1467 }
1468
1470 if (!pmapdef) {
1471 return FALSE;
1472 }
1473
1475}
1476
1477/**********************************************************************/
1481{
1482 struct option *poption = optset_option_by_name(server_optset, "nationset");
1483 const char *setting_str;
1484
1485 if (poption == NULL
1488 setting_str = "";
1489 }
1490
1492}
1493
1494/**********************************************************************/
1498{
1500}
1501
1502/**********************************************************************/
1507enum ai_level server_ai_level(void)
1508{
1509 enum ai_level lvl = game.info.skill_level;
1510
1511 players_iterate(pplayer) {
1512 if (is_ai(pplayer) && pplayer->ai_common.skill_level != lvl) {
1513 return ai_level_invalid();
1514 }
1516
1517 if (!is_settable_ai_level(lvl)) {
1518 return ai_level_invalid();
1519 }
1520
1521 return lvl;
1522}
#define NUM_ACTIONS
Definition actions.h:313
#define str
Definition astring.c:76
#define n
Definition astring.c:77
void dbv_resize(struct dbv *pdbv, int bits)
Definition bitvector.c:71
void output_window_event(const char *plain_text, const struct text_tag_list *tags, int conn_id)
const char * city_improvement_name_translation(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:662
bool can_city_build_unit_later(const struct city *pcity, const struct unit_type *punittype)
Definition city.c:965
bool can_city_build_now(const struct city *pcity, const struct universal *target)
Definition city.c:1006
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1231
const char * city_name_get(const struct city *pcity)
Definition city.c:1128
void city_remove_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3359
bool can_city_build_improvement_now(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:853
bool city_production_is_genus(const struct city *pcity, enum impr_genus_id genus)
Definition city.c:716
bool can_city_build_improvement_later(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:870
bool can_city_build_unit_now(const struct city *pcity, const struct unit_type *punittype)
Definition city.c:945
const char * city_production_name_translation(const struct city *pcity)
Definition city.c:699
#define cities_iterate_end
Definition city.h:517
#define city_list_iterate(citylist, pcity)
Definition city.h:508
#define city_tile(_pcity_)
Definition city.h:564
#define cities_iterate(pcity)
Definition city.h:512
@ CITIZEN_UNHAPPY
Definition city.h:270
#define city_owner(_pcity_)
Definition city.h:563
#define city_list_iterate_end
Definition city.h:510
#define city_built_iterate(_pcity, _p)
Definition city.h:822
#define city_built_iterate_end
Definition city.h:828
int city_buy_production(struct city *pcity)
int city_change_production(struct city *pcity, struct universal *target)
bool city_can_buy(const struct city *pcity)
void refresh_city_dialog(struct city *pcity)
void city_report_dialog_update(void)
bool client_is_global_observer(void)
bool client_is_observer(void)
struct civclient client
enum client_states client_state(void)
bool can_client_issue_orders(void)
bool client_has_player(void)
bool can_client_change_view(void)
#define client_player()
@ C_S_RUNNING
Definition client_main.h:47
enum known_type client_tile_get_known(const struct tile *ptile)
Definition climap.c:36
static int target_get_section(struct universal target)
Definition climisc.c:591
int collect_eventually_buildable_targets(struct universal *targets, struct city *pcity, bool advanced_tech)
Definition climisc.c:808
bool city_unit_supported(const struct city *pcity, const struct universal *target)
Definition climisc.c:543
enum ai_level server_ai_level(void)
Definition climisc.c:1507
void client_change_all(struct universal *from, struct universal *to)
Definition climisc.c:165
cid cid_encode_building(const struct impr_type *pimprove)
Definition climisc.c:503
void create_event(struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition climisc.c:1081
int collect_buildable_targets(struct universal *targets)
Definition climisc.c:777
void client_player_init(struct player *pplayer)
Definition climisc.c:1361
bool mapimg_client_createmap(const char *filename)
Definition climisc.c:1454
void client_remove_city(struct city *pcity)
Definition climisc.c:134
void client_unit_init_act_prob_cache(struct unit *punit)
Definition climisc.c:1247
void nuclear_winter_scaled(int *chance, int *rate, int max)
Definition climisc.c:344
const char * get_embassy_status(const struct player *me, const struct player *them)
Definition climisc.c:194
void buy_production_in_selected_cities(void)
Definition climisc.c:1305
void common_taxrates_callback(int idx, bool reverse)
Definition climisc.c:1182
static int city_buy_cost_compare(const void *a, const void *b)
Definition climisc.c:1291
bool mapimg_client_define(void)
Definition climisc.c:1397
int collect_currently_building_targets(struct universal *targets)
Definition climisc.c:745
enum unit_bg_color_type unit_color_type(const struct unit_type *punittype)
Definition climisc.c:1263
struct sprite * client_warming_sprite(void)
Definition climisc.c:377
bool can_units_do_connect(struct unit_list *punits, enum unit_activity activity, struct extra_type *tgt)
Definition climisc.c:1230
void cityrep_buy(struct city *pcity)
Definition climisc.c:1143
void global_warming_scaled(int *chance, int *rate, int max)
Definition climisc.c:334
void client_player_maps_reset(void)
Definition climisc.c:1372
bool client_nation_is_in_current_set(const struct nation_type *pnation)
Definition climisc.c:1497
cid cid_encode_from_city(const struct city *pcity)
Definition climisc.c:516
void name_and_sort_items(struct universal *targets, int num_targets, struct item *items, bool show_cost, struct city *pcity)
Definition climisc.c:639
static int fc_cmp(const void *p1, const void *p2)
Definition climisc.c:615
struct sprite * client_cooling_sprite(void)
Definition climisc.c:394
struct sprite * client_research_sprite(void)
Definition climisc.c:354
int num_present_units_in_city(struct city *pcity)
Definition climisc.c:939
cid cid_encode(struct universal target)
Definition climisc.c:481
void client_remove_unit(struct unit *punit)
Definition climisc.c:72
bool city_building_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:581
struct nation_set * client_current_nation_set(void)
Definition climisc.c:1480
int num_supported_units_in_city(struct city *pcity)
Definition climisc.c:921
int collect_already_built_targets(struct universal *targets, struct city *pcity)
Definition climisc.c:901
struct city * get_nearest_city(const struct unit *punit, int *sq_dist)
Definition climisc.c:1107
struct universal cid_decode(cid id)
Definition climisc.c:524
void unit_focus_set_status(struct player *pplayer)
Definition climisc.c:1351
void handle_event(const char *featured_text, struct tile *ptile, enum event_type event, int turn, int phase, int conn_id)
Definition climisc.c:956
void center_on_something(void)
Definition climisc.c:430
cid cid_encode_unit(const struct unit_type *punittype)
Definition climisc.c:491
void client_diplomacy_clause_string(char *buf, int bufsiz, struct Clause *pclause)
Definition climisc.c:241
const char * get_vision_status(const struct player *me, const struct player *them)
Definition climisc.c:222
struct sprite * client_government_sprite(void)
Definition climisc.c:412
static void catastrophe_scaled(int *chance, int *rate, int max, int current, int accum, int level)
Definition climisc.c:314
bool city_unit_present(const struct city *pcity, const struct universal *target)
Definition climisc.c:562
int collect_production_targets(struct universal *targets, struct city **selected_cities, int num_selected_cities, bool append_units, bool append_wonders, bool change_prod, TestCityFunc test_func)
Definition climisc.c:689
#define MAX_NUM_PRODUCTION_TARGETS
Definition climisc.h:87
int cid
Definition climisc.h:31
bool(* TestCityFunc)(const struct city *, const struct universal *)
Definition climisc.h:85
unit_bg_color_type
Definition climisc.h:125
@ UNIT_BG_AMPHIBIOUS
Definition climisc.h:128
@ UNIT_BG_SEA
Definition climisc.h:127
@ UNIT_BG_FLYING
Definition climisc.h:129
@ UNIT_BG_LAND
Definition climisc.h:126
@ UNIT_BG_HP_LOSS
Definition climisc.h:125
char * incite_cost
Definition comments.c:74
#define MAX_LEN_MSG
Definition conn_types.h:37
void connection_do_buffer(struct connection *pc)
Definition connection.c:324
void connection_do_unbuffer(struct connection *pc)
Definition connection.c:336
struct unit * get_focus_unit_on_tile(const struct tile *ptile)
Definition control.c:391
struct unit_list * get_units_in_focus(void)
Definition control.c:177
void unit_focus_advance(void)
Definition control.c:670
bool can_unit_do_connect(struct unit *punit, enum unit_activity activity, struct extra_type *tgt)
Definition control.c:1389
void update_unit_pix_label(struct unit_list *punitlist)
Definition control.c:967
struct unit * head_of_units_in_focus(void)
Definition control.c:405
int get_num_units_in_focus(void)
Definition control.c:185
void control_unit_killed(struct unit *punit)
Definition control.c:226
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:74
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit int cost
Definition dialogs_g.h:74
int int id
Definition editgui_g.h:28
enum event_type event
Definition events.c:81
#define Q_(String)
Definition fcintl.h:70
#define PL_(String1, String2, n)
Definition fcintl.h:71
#define _(String)
Definition fcintl.h:67
size_t featured_text_apply_tag(const char *text_source, char *featured_text, size_t featured_text_len, enum text_tag_type tag_type, ft_offset_t start_offset, ft_offset_t stop_offset,...)
enum text_link_type text_tag_link_type(const struct text_tag *ptag)
size_t featured_text_to_plain_text(const char *featured_text, char *plain_text, size_t plain_text_len, struct text_tag_list **tags, bool replace_link_text)
const struct ft_color ftc_client
const char * city_link(const struct city *pcity)
int text_tag_link_id(const struct text_tag *ptag)
struct text_tag * text_tag_new(enum text_tag_type tag_type, ft_offset_t start_offset, ft_offset_t stop_offset,...)
#define text_tag_list_iterate_end
#define text_tag_list_iterate(tags, ptag)
#define FT_OFFSET_UNSET
static bool ft_color_requested(const struct ft_color color)
text_tag_type
@ TTT_LINK
@ TTT_COLOR
struct civ_game game
Definition game.c:62
struct world wld
Definition game.c:63
void game_remove_unit(struct world *gworld, struct unit *punit)
Definition game.c:124
void game_remove_city(struct world *gworld, struct city *pcity)
Definition game.c:178
struct city * game_city_by_number(int id)
Definition game.c:107
Government_type_id government_count(void)
Definition government.c:71
struct government * government_of_player(const struct player *pplayer)
Definition government.c:114
void popdown_city_dialog(struct city *pcity)
Definition citydlg.c:587
void popup_notify_goto_dialog(const char *headline, const char *lines, const struct text_tag_list *tags, struct tile *ptile)
Definition dialogs.c:196
void update_unit_info_label(struct unit_list *punits)
Definition mapview.c:275
struct impr_type * improvement_by_number(const Impr_type_id id)
bool can_player_build_improvement_later(const struct player *p, const struct impr_type *pimprove)
bool can_player_build_improvement_now(const struct player *p, struct impr_type *pimprove)
Impr_type_id improvement_number(const struct impr_type *pimprove)
int impr_build_shield_cost(const struct city *pcity, const struct impr_type *pimprove)
bool is_wonder(const struct impr_type *pimprove)
bool is_great_wonder(const struct impr_type *pimprove)
bool is_convert_improvement(const struct impr_type *pimprove)
const char * improvement_name_translation(const struct impr_type *pimprove)
Impr_type_id improvement_count(void)
bool is_small_wonder(const struct impr_type *pimprove)
#define improvement_iterate_end
#define improvement_iterate(_p)
#define B_LAST
Definition improvement.h:42
const char * name
Definition inputfile.c:127
#define fc_assert_ret(condition)
Definition log.h:191
#define log_verbose(message,...)
Definition log.h:109
#define fc_assert(condition)
Definition log.h:176
#define fc_assert_ret_val(condition, val)
Definition log.h:194
#define log_debug(message,...)
Definition log.h:115
int sq_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:641
int map_num_tiles(void)
Definition map.c:1014
struct tile * native_pos_to_tile(const struct civ_map *nmap, int nat_x, int nat_y)
Definition map.c:443
#define iterate_outward(nmap, start_tile, max_dist, itr_tile)
Definition map.h:367
#define iterate_outward_end
Definition map.h:371
#define MAP_INDEX_SIZE
Definition map.h:137
bool is_city_hilited(struct city *pcity)
struct mapdef * mapimg_isvalid(int id)
Definition mapimg.c:1121
bool mapimg_define(const char *maparg, bool check)
Definition mapimg.c:769
bool mapimg_delete(int id)
Definition mapimg.c:1204
int mapimg_count(void)
Definition mapimg.c:573
bool mapimg_create(struct mapdef *pmapdef, bool force, const char *savename, const char *path)
Definition mapimg.c:1332
#define MAX_LEN_MAPDEF
Definition mapimg.h:65
void refresh_city_mapcanvas(struct city *pcity, struct tile *ptile, bool full_refresh, bool write_to_screen)
void center_tile_mapcanvas(const struct tile *ptile)
void link_mark_add_new(enum text_link_type type, int id)
bool can_slide
void refresh_unit_mapcanvas(struct unit *punit, struct tile *ptile, bool full_refresh, bool write_to_screen)
#define fc_malloc(sz)
Definition mem.h:34
void meswin_add(const char *message, const struct text_tag_list *tags, struct tile *ptile, enum event_type event, int turn, int phase)
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
struct nation_type * nation_of_unit(const struct unit *punit)
Definition nation.c:463
struct nation_type * nation_of_city(const struct city *pcity)
Definition nation.c:454
bool nation_is_in_set(const struct nation_type *pnation, const struct nation_set *pset)
Definition nation.c:837
struct nation_set * nation_set_by_setting_value(const char *setting)
Definition nation.c:859
const char * nation_plural_for_player(const struct player *pplayer)
Definition nation.c:178
const struct option_set * server_optset
Definition options.c:4019
const char * option_str_get(const struct option *poption)
Definition options.c:892
enum option_type option_type(const struct option *poption)
Definition options.c:657
int messages_where[E_COUNT]
Definition options.c:5039
struct client_options gui_options
Definition options.c:71
struct option * optset_option_by_name(const struct option_set *poptset, const char *name)
Definition options.c:430
#define MW_POPUP
Definition options.h:580
#define MW_OUTPUT
Definition options.h:578
#define MW_MESSAGES
Definition options.h:579
int dsend_packet_player_rates(struct connection *pc, int tax, int luxury, int science)
void play_sound_for_event(enum event_type type)
Definition packhand.c:1511
struct city_list * cities
Definition packhand.c:119
bool is_settable_ai_level(enum ai_level level)
Definition player.c:1919
const char * player_name(const struct player *pplayer)
Definition player.c:895
struct city * player_primary_capital(const struct player *pplayer)
Definition player.c:1337
int player_index(const struct player *pplayer)
Definition player.c:829
struct player_diplstate * player_diplstate_get(const struct player *plr1, const struct player *plr2)
Definition player.c:324
bool can_player_see_units_in_city(const struct player *pplayer, const struct city *pcity)
Definition player.c:1133
bool can_player_see_city_internals(const struct player *pplayer, const struct city *pcity)
Definition player.c:1149
bool player_has_embassy(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:208
bool gives_shared_vision(const struct player *me, const struct player *them)
Definition player.c:1485
#define players_iterate_end
Definition player.h:537
#define players_iterate(_pplayer)
Definition player.h:532
#define is_ai(plr)
Definition player.h:230
#define is_human(plr)
Definition player.h:229
bool are_universals_equal(const struct universal *psource1, const struct universal *psource2)
struct research * research_get(const struct player *pplayer)
Definition research.c:128
struct setting_list * level[OLEVELS_NUM]
Definition settings.c:190
#define CLIP(lower, current, upper)
Definition shared.h:57
#define DIVIDE(n, d)
Definition shared.h:78
#define ARRAY_SIZE(x)
Definition shared.h:85
#define BOOL_VAL(x)
Definition shared.h:70
#define MAX(x, y)
Definition shared.h:54
Definition city.h:320
int id
Definition city.h:326
struct unit_list * info_units_present
Definition city.h:474
struct unit_list * info_units_supported
Definition city.h:473
bool occupied
Definition city.h:460
struct universal production
Definition city.h:396
int buy_cost
Definition city.h:466
struct tile * tile
Definition city.h:322
struct unit_list * units_supported
Definition city.h:406
struct city::@17::@20 client
struct packet_game_info info
Definition game.h:89
int xsize
Definition map_types.h:78
int ysize
Definition map_types.h:78
struct connection conn
Definition client_main.h:96
bool mapimg_layer[MAPIMG_LAYER_COUNT]
Definition options.h:227
struct ft_color highlight_our_names
Definition options.h:176
char mapimg_format[64]
Definition options.h:225
char mapimg_filename[512]
Definition options.h:228
Definition colors.h:21
struct player * playing
Definition connection.h:151
char username[MAX_LEN_NAME]
Definition connection.h:164
int bits
Definition bitvector.h:33
unsigned char * vec
Definition bitvector.h:34
int build_cost
Definition improvement.h:60
Definition climisc.h:80
struct universal item
Definition climisc.h:81
enum ai_level skill_level
struct city_list * cities
Definition player.h:279
struct dbv tile_vision[V_COUNT]
Definition player.h:357
struct unit_list * units
Definition player.h:280
struct player::@70::@73 client
struct player_economic economic
Definition player.h:282
Definition tile.h:50
struct unit_list * units
Definition tile.h:58
Definition unit.h:138
struct unit::@81::@83 client
int id
Definition unit.h:145
struct act_prob * act_prob_cache
Definition unit.h:228
int homecity
Definition unit.h:146
enum unit_focus_status focus_status
Definition unit.h:214
enum universals_n kind
Definition fc_types.h:903
universals_u value
Definition fc_types.h:902
struct civ_map map
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:974
size_t fc_strlcpy(char *dest, const char *src, size_t n)
Definition support.c:791
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:189
int cat_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:1000
int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap)
Definition support.c:900
int fc_strncasecmp(const char *str0, const char *str1, size_t n)
Definition support.c:238
#define sz_strlcpy(dest, src)
Definition support.h:189
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
const char * advance_name_translation(const struct advance *padvance)
Definition tech.c:290
#define A_UNSET
Definition tech.h:48
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
@ TILE_UNKNOWN
Definition tile.h:36
#define TILE_XY(ptile)
Definition tile.h:43
struct sprite * get_government_sprite(const struct tileset *t, const struct government *gov)
Definition tilespec.c:6797
struct sprite * get_indicator_sprite(const struct tileset *t, enum indicator_type indicator, int idx)
Definition tilespec.c:7003
struct sprite * get_citizen_sprite(const struct tileset *t, enum citizen_category type, int citizen_index, const struct city *pcity)
Definition tilespec.c:6726
@ INDICATOR_COOLING
Definition tilespec.h:308
@ INDICATOR_WARMING
Definition tilespec.h:307
@ INDICATOR_BULB
Definition tilespec.h:306
#define NUM_TILES_PROGRESS
Definition tilespec.h:195
const struct unit_type * utype
Definition fc_types.h:724
const struct impr_type * building
Definition fc_types.h:717
int get_transporter_occupancy(const struct unit *ptrans)
Definition unit.c:1779
bool unit_transport_unload(struct unit *pcargo)
Definition unit.c:2386
struct unit_list * unit_transport_cargo(const struct unit *ptrans)
Definition unit.c:2447
#define unit_tile(_pu)
Definition unit.h:390
@ FOCUS_AVAIL
Definition unit.h:53
#define unit_owner(_pu)
Definition unit.h:389
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
#define unit_list_iterate_end
Definition unitlist.h:33
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
const char * unit_rule_name(const struct unit *punit)
Definition unittype.c:1587
Unit_type_id utype_count(void)
Definition unittype.c:80
struct unit_type * utype_by_number(const Unit_type_id id)
Definition unittype.c:112
Unit_type_id utype_number(const struct unit_type *punittype)
Definition unittype.c:100
bool can_player_build_unit_later(const struct player *p, const struct unit_type *punittype)
Definition unittype.c:2099
int utype_build_shield_cost(const struct city *pcity, const struct player *pplayer, const struct unit_type *punittype)
Definition unittype.c:1438
bool can_player_build_unit_now(const struct player *p, const struct unit_type *punittype)
Definition unittype.c:2078
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1560
const char * utype_values_translation(const struct unit_type *punittype)
Definition unittype.c:1617
static bool uclass_has_flag(const struct unit_class *punitclass, enum unit_class_flag_id flag)
Definition unittype.h:766
#define utype_class(_t_)
Definition unittype.h:749
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition unittype.h:617
#define unit_type_iterate(_p)
Definition unittype.h:852
#define unit_type_iterate_end
Definition unittype.h:859
#define vision_layer_iterate(v)
Definition vision.h:77
#define vision_layer_iterate_end
Definition vision.h:80