Freeciv-3.3
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;
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 {
461
462 /* Just any known tile will do; search near the middle first. */
463 /* Iterate outward from the center tile. We have to give a radius that
464 * is guaranteed to be larger than the map will be. Although this is
465 * a misuse of map.xsize and map.ysize (which are native dimensions),
466 * it should give a sufficiently large radius. */
468 if (client_tile_get_known(ptile) != TILE_UNKNOWN) {
469 ctile = ptile;
470 break;
471 }
473
475 }
476 can_slide = TRUE;
477}
478
479/**********************************************************************/
483{
484 return VUT_UTYPE == target.kind
485 ? B_LAST + utype_number(target.value.utype)
487}
488
489/**********************************************************************/
493{
494 struct universal target = {
495 .kind = VUT_UTYPE,
496 .value = {.utype = punittype}};
497
498 return cid_encode(target);
499}
500
501/**********************************************************************/
504cid cid_encode_building(const struct impr_type *pimprove)
505{
506 struct universal target = {
508 .value = {.building = pimprove}
509 };
510
511 return cid_encode(target);
512}
513
514/**********************************************************************/
517cid cid_encode_from_city(const struct city *pcity)
518{
519 return cid_encode(pcity->production);
520}
521
522/**********************************************************************/
526{
527 struct universal target;
528
529 if (id >= B_LAST) {
530 target.kind = VUT_UTYPE;
531 target.value.utype = utype_by_number(id - B_LAST);
532 } else {
533 target.kind = VUT_IMPROVEMENT;
535 }
536
537 return target;
538}
539
540/**********************************************************************/
544bool city_unit_supported(const struct city *pcity,
545 const struct universal *target)
546{
547 if (VUT_UTYPE == target->kind) {
548 const struct unit_type *tvtype = target->value.utype;
549
551 if (unit_type_get(punit) == tvtype) {
552 return TRUE;
553 }
555 }
556 return FALSE;
557}
558
559/**********************************************************************/
563bool city_unit_present(const struct city *pcity,
564 const struct universal *target)
565{
566 if (VUT_UTYPE == target->kind) {
567 const struct unit_type *tvtype = target->value.utype;
568
570 if (unit_type_get(punit) == tvtype) {
571 return TRUE;
572 }
573 }
575 }
576 return FALSE;
577}
578
579/**********************************************************************/
582bool city_building_present(const struct city *pcity,
583 const struct universal *target)
584{
585 return VUT_IMPROVEMENT == target->kind
586 && city_has_building(pcity, target->value.building);
587}
588
589/**********************************************************************/
592static int target_get_section(struct universal target)
593{
594 if (VUT_UTYPE == target.kind) {
596 return 2;
597 } else {
598 return 3;
599 }
600 } else {
602 return 1;
603 } else if (is_small_wonder(target.value.building)) {
604 return 4;
605 } else if (is_great_wonder(target.value.building)) {
606 return 5;
607 } else {
608 return 0;
609 }
610 }
611}
612
613/**********************************************************************/
616static int fc_cmp(const void *p1, const void *p2)
617{
618 const struct item *i1 = p1, *i2 = p2;
619 int s1 = target_get_section(i1->item);
620 int s2 = target_get_section(i2->item);
621
622 if (s1 == s2) {
623 return fc_strcasecmp(i1->descr, i2->descr);
624 }
625
626 return s1 - s2;
627}
628
629/**********************************************************************/
640void name_and_sort_items(struct universal *targets, int num_targets,
641 struct item *items,
642 bool show_cost, struct city *pcity)
643{
644 int i;
645
646 for (i = 0; i < num_targets; i++) {
647 struct universal target = targets[i];
648 int cost;
649 struct item *pitem = &items[i];
650 const char *name;
651
652 pitem->item = target;
653
654 if (VUT_UTYPE == target.kind) {
657 } else {
660 cost = -1;
661 } else {
662 if (pcity != NULL) {
663 cost = impr_build_shield_cost(pcity, target.value.building);
664 } else {
665 cost = MAX(target.value.building->build_cost * game.info.shieldbox / 100, 1);
666 }
667 }
668 }
669
670 if (show_cost) {
671 if (cost < 0) {
672 fc_snprintf(pitem->descr, sizeof(pitem->descr), "%s (XX)", name);
673 } else {
674 fc_snprintf(pitem->descr, sizeof(pitem->descr),
675 "%s (%d)", name, cost);
676 }
677 } else {
678 (void) fc_strlcpy(pitem->descr, name, sizeof(pitem->descr));
679 }
680 }
681
682 qsort(items, num_targets, sizeof(struct item), fc_cmp);
683}
684
685/**********************************************************************/
691 struct city **selected_cities,
693 bool append_wonders, bool change_prod,
695{
696 cid first = append_units ? B_LAST : 0;
697 cid last = (append_units
698 ? utype_count() + B_LAST
700 cid id;
701 int items_used = 0;
702
703 for (id = first; id < last; id++) {
704 bool append = FALSE;
705 struct universal target = cid_decode(id);
706
707 if (!append_units && (append_wonders != is_wonder(target.value.building))) {
708 continue;
709 }
710
711 if (!change_prod) {
712 if (client_has_player()) {
714 append |= test_func(pcity, &target);
716 } else {
717 cities_iterate(pcity) {
718 append |= test_func(pcity, &target);
720 }
721 } else {
722 int i;
723
724 for (i = 0; i < num_selected_cities; i++) {
725 append |= test_func(selected_cities[i], &target);
726 }
727 }
728
729 if (!append) {
730 continue;
731 }
732
733 targets[items_used] = target;
734 items_used++;
735 }
736
737 return items_used;
738}
739
740/**********************************************************************/
747{
749 int cids_used = 0;
750 cid id;
751
752 if (NULL == client.conn.playing) {
753 return 0;
754 }
755
756 memset(mapping, 0, sizeof(mapping));
759 }
761
762 for (id = 0; id < ARRAY_SIZE(mapping); id++) {
763 if (mapping[id]) {
764 targets[cids_used] = cid_decode(id);
765 cids_used++;
766 }
767 }
768
769 return cids_used;
770}
771
772/**********************************************************************/
779{
780 int cids_used = 0;
781
782 if (NULL == client.conn.playing) {
783 return 0;
784 }
785
786 improvement_iterate(pimprove) {
788 targets[cids_used].kind = VUT_IMPROVEMENT;
789 targets[cids_used].value.building = pimprove;
790 cids_used++;
791 }
793
796 targets[cids_used].kind = VUT_UTYPE;
797 targets[cids_used].value.utype = punittype;
798 cids_used++;
799 }
801
802 return cids_used;
803}
804
805/**********************************************************************/
810 struct city *pcity,
811 bool advanced_tech)
812{
813 struct player *pplayer = client_player();
814 int cids_used = 0;
815
816 improvement_iterate(pimprove) {
817 bool can_build;
819
820 if (NULL != pcity) {
821 /* Can the city build? */
822 can_build = can_city_build_improvement_now(pcity, pimprove);
824 pimprove);
825 } else if (NULL != pplayer) {
826 /* Can our player build? */
827 can_build = can_player_build_improvement_now(pplayer, pimprove);
829 pimprove);
830 } else {
831 /* Global observer case: can any player build? */
835 can_build = TRUE;
836 break;
837 }
839
844 break;
845 }
847 }
848
850 || (!advanced_tech && can_build)) {
851 targets[cids_used].kind = VUT_IMPROVEMENT;
852 targets[cids_used].value.building = pimprove;
853 cids_used++;
854 }
856
858 bool can_build;
860
861 if (NULL != pcity) {
862 /* Can the city build? */
865 } else if (NULL != pplayer) {
866 /* Can our player build? */
869 } else {
870 /* Global observer case: can any player build? */
874 can_build = TRUE;
875 break;
876 }
878
883 break;
884 }
886 }
887
889 || (!advanced_tech && can_build)) {
890 targets[cids_used].kind = VUT_UTYPE;
891 targets[cids_used].value.utype = punittype;
892 cids_used++;
893 }
895
896 return cids_used;
897}
898
899/**********************************************************************/
903 struct city *pcity)
904{
905 int cids_used = 0;
906
907 fc_assert_ret_val(pcity != NULL, 0);
908
909 city_built_iterate(pcity, pimprove) {
910 targets[cids_used].kind = VUT_IMPROVEMENT;
911 targets[cids_used].value.building = pimprove;
912 cids_used++;
914
915 return cids_used;
916}
917
918/**********************************************************************/
923{
924 struct unit_list *plist;
925
927 /* Other players don't see inside the city (but observers do). */
929 } else {
930 plist = pcity->units_supported;
931 }
932
933 return unit_list_size(plist);
934}
935
936/**********************************************************************/
941{
942 struct unit_list *plist;
943
945 /* Other players don't see inside the city (but observers do). */
947 } else {
948 plist = pcity->tile->units;
949 }
950
951 return unit_list_size(plist);
952}
953
954/**********************************************************************/
957void handle_event(const char *featured_text, struct tile *ptile,
958 enum event_type event, int turn, int phase, int conn_id)
959{
961 struct text_tag_list *tags;
962 int where = MW_OUTPUT; /* where to display the message */
963 bool fallback_needed = FALSE; /* we want fallback if actual 'where' is not
964 * usable */
965 bool shown = FALSE; /* Message displayed somewhere at least */
966
968 /* Server may have added a new event; leave as MW_OUTPUT */
969 log_verbose("Unknown event type %d!", event);
970 } else {
972 }
973
974 /* Get the original text. */
976 sizeof(plain_text), &tags, conn_id != -1);
977
978 /* Display link marks when an user is pointed us something. */
979 if (conn_id != -1) {
981 if (text_tag_type(ptag) == TTT_LINK) {
983 }
985 }
986
987 /* Maybe highlight our player and user names if someone is talking
988 * about us. */
989 if (-1 != conn_id
990 && client.conn.id != conn_id
992 const char *username = client.conn.username;
993 size_t userlen = strlen(username);
994 const char *playername = ((client_player() && !client_is_observer())
996 size_t playerlen = playername ? strlen(playername) : 0;
997 const char *p;
998
999 if (playername && playername[0] == '\0') {
1000 playername = NULL;
1001 }
1002
1003 if (username && username[0] == '\0') {
1004 username = NULL;
1005 }
1006
1007 for (p = plain_text; *p != '\0'; p++) {
1008 if (NULL != username
1009 && 0 == fc_strncasecmp(p, username, userlen)) {
1011 p - plain_text + userlen,
1013
1014 fc_assert(ptag != NULL);
1015
1016 if (ptag != NULL) {
1017 /* Appends to be sure it will be applied at last. */
1019 }
1020 } else if (NULL != playername
1021 && 0 == fc_strncasecmp(p, playername, playerlen)) {
1023 p - plain_text + playerlen,
1025
1026 fc_assert(ptag != NULL);
1027
1028 if (ptag != NULL) {
1029 /* Appends to be sure it will be applied at last. */
1031 }
1032 }
1033 }
1034 }
1035
1036 /* Popup */
1037 if (BOOL_VAL(where & MW_POPUP)) {
1038 /* Popups are usually not shown if player is under AI control.
1039 * Server operator messages are shown always. */
1040 if (NULL == client.conn.playing
1042 || event == E_MESSAGE_WALL) {
1043 popup_notify_goto_dialog(_("Popup Request"), plain_text, tags, ptile);
1044 shown = TRUE;
1045 } else {
1046 /* Force to chatline so it will be visible somewhere at least.
1047 * Messages window may still handle this so chatline is not needed
1048 * after all. */
1050 }
1051 }
1052
1053 /* Message window */
1054 if (BOOL_VAL(where & MW_MESSAGES)) {
1055 /* When the game isn't running, the messages dialog isn't present. */
1056 if (C_S_RUNNING <= client_state()) {
1057 meswin_add(plain_text, tags, ptile, event, turn, phase);
1058 shown = TRUE;
1059 } else {
1060 /* Force to chatline instead. */
1062 }
1063 }
1064
1065 /* Chatline */
1066 if (BOOL_VAL(where & MW_OUTPUT) || (fallback_needed && !shown)) {
1067 output_window_event(plain_text, tags, conn_id);
1068 }
1069
1070 if (turn == game.info.turn) {
1072 }
1073
1074 /* Free tags */
1076}
1077
1078/**********************************************************************/
1082void create_event(struct tile *ptile, enum event_type event,
1083 const struct ft_color color, const char *format, ...)
1084{
1085 va_list ap;
1086 char message[MAX_LEN_MSG];
1087
1088 va_start(ap, format);
1089 fc_vsnprintf(message, sizeof(message), format, ap);
1090 va_end(ap);
1091
1094
1098 } else {
1100 }
1101}
1102
1103/**********************************************************************/
1108struct city *get_nearest_city(const struct unit *punit, int *sq_dist)
1109{
1110 struct city *pcity_near;
1111 int pcity_near_dist;
1112
1113 if ((pcity_near = tile_city(unit_tile(punit)))) {
1114 pcity_near_dist = 0;
1115 } else {
1116 pcity_near = NULL;
1117 pcity_near_dist = -1;
1118 players_iterate(pplayer) {
1119 city_list_iterate(pplayer->cities, pcity_current) {
1120 int dist = sq_map_distance(pcity_current->tile, unit_tile(punit));
1121
1122 if (pcity_near_dist == -1 || dist < pcity_near_dist
1123 || (dist == pcity_near_dist
1126 pcity_near_dist = dist;
1127 }
1130 }
1131
1132 if (sq_dist) {
1134 }
1135
1136 return pcity_near;
1137}
1138
1139/**********************************************************************/
1144void cityrep_buy(struct city *pcity)
1145{
1146 int value;
1147
1150 _("You can't buy %s in %s!"),
1152 city_link(pcity));
1153 return;
1154 }
1155 value = pcity->client.buy_cost;
1156
1157 if (city_owner(pcity)->economic.gold >= value) {
1158 city_buy_production(pcity);
1159 } else {
1160 /* Split into two to allow localization of two pluralisations. */
1161 char buf[MAX_LEN_MSG];
1162
1163 /* TRANS: %s is a production type; this whole string is a sentence
1164 * fragment that is only ever included in one other string
1165 * (search comments for this string to find it) */
1166 fc_snprintf(buf, ARRAY_SIZE(buf), PL_("%s costs %d gold",
1167 "%s costs %d gold", value),
1169 value);
1171 /* TRANS: %s is a pre-pluralised sentence fragment:
1172 * "%s costs %d gold" */
1173 PL_("%s and you only have %d gold.",
1174 "%s and you only have %d gold.",
1175 city_owner(pcity)->economic.gold),
1176 buf, city_owner(pcity)->economic.gold);
1177 }
1178}
1179
1180/**********************************************************************/
1184{
1185 int lux_end, sci_end, tax, lux, sci;
1186 int delta = 10;
1187
1188 if (!can_client_issue_orders()) {
1189 return;
1190 }
1191
1194
1198
1199 idx *= 10;
1200
1201 if (reverse) {
1202 if (idx < lux_end) {
1203 lux -= delta;
1204 tax += delta;
1205 } else if (idx < sci_end) {
1206 sci -= delta;
1207 lux += delta;
1208 } else {
1209 tax -= delta;
1210 sci += delta;
1211 }
1212 } else {
1213 if (idx < lux_end) {
1214 lux -= delta;
1215 sci += delta;
1216 } else if (idx < sci_end) {
1217 sci -= delta;
1218 tax += delta;
1219 } else {
1220 tax -= delta;
1221 lux += delta;
1222 }
1223 }
1224
1226}
1227
1228/**********************************************************************/
1231bool can_units_do_connect(struct unit_list *punits,
1232 enum unit_activity activity,
1233 struct extra_type *tgt)
1234{
1236 if (can_unit_do_connect(punit, activity, tgt)) {
1237 return TRUE;
1238 }
1240
1241 return FALSE;
1242}
1243
1244/**********************************************************************/
1249{
1250 /* A double init would cause a leak. */
1252
1255}
1256
1257/**********************************************************************/
1265{
1267
1268 if (pclass->hp_loss_pct > 0) {
1269 return UNIT_BG_HP_LOSS;
1270 }
1271
1272 if (pclass->move_type == UMT_LAND) {
1273 return UNIT_BG_LAND;
1274 }
1275 if (pclass->move_type == UMT_SEA) {
1276 return UNIT_BG_SEA;
1277 }
1278
1279 fc_assert(pclass->move_type == UMT_BOTH);
1280
1282 /* Unit moves on both sea and land by speed determined by terrain */
1283 return UNIT_BG_AMPHIBIOUS;
1284 }
1285
1286 return UNIT_BG_FLYING;
1287}
1288
1289/**********************************************************************/
1292static int city_buy_cost_compare(const void *a, const void *b)
1293{
1294 const struct city *ca, *cb;
1295
1296 ca = *((const struct city **) a);
1297 cb = *((const struct city **) b);
1298
1299 return ca->client.buy_cost - cb->client.buy_cost;
1300}
1301
1302/**********************************************************************/
1307{
1308 const struct player *pplayer = client_player();
1309 struct connection *pconn;
1310
1311 if (!pplayer || !pplayer->cities
1312 || city_list_size(pplayer->cities) < 1) {
1313 return;
1314 }
1315
1316 int gold = pplayer->economic.gold;
1317 if (gold < 1) {
1318 return;
1319 }
1320
1321 const int n = city_list_size(pplayer->cities);
1322 struct city *cities[n];
1323 int i, count = 0;
1324
1325 city_list_iterate(pplayer->cities, pcity) {
1326 if (!is_city_hilited(pcity) || !city_can_buy(pcity)) {
1327 continue;
1328 }
1329 cities[count++] = pcity;
1331
1332 if (count < 1) {
1333 return;
1334 }
1335
1336 qsort(cities, count, sizeof(*cities), city_buy_cost_compare);
1337
1338 pconn = &client.conn;
1340
1341 for (i = 0; i < count && gold > 0; i++) {
1342 gold -= cities[i]->client.buy_cost;
1344 }
1345
1347}
1348
1349/**********************************************************************/
1352void unit_focus_set_status(struct player *pplayer)
1353{
1354 unit_list_iterate(pplayer->units, punit) {
1357}
1358
1359/**********************************************************************/
1362void client_player_init(struct player *pplayer)
1363{
1365 pplayer->client.tile_vision[v].vec = NULL;
1366 pplayer->client.tile_vision[v].bits = 0;
1368}
1369
1370/**********************************************************************/
1374{
1375 players_iterate(pplayer) {
1376 int new_size;
1377
1378 if (pplayer == client.conn.playing) {
1380 } else {
1381 /* We don't need (or have) information about players other
1382 * than user of the client. Allocate just one bit as that's
1383 * the minimum bitvector size (cannot allocate 0 bits)*/
1384 new_size = 1;
1385 }
1386
1388 dbv_resize(&pplayer->client.tile_vision[v], new_size);
1390
1391 dbv_resize(&pplayer->tile_known, new_size);
1393}
1394
1395/**********************************************************************/
1399{
1400 char str[MAX_LEN_MAPDEF];
1401 char mi_map[MAPIMG_LAYER_COUNT + 1];
1402 enum mapimg_layer layer;
1403 int map_pos = 0;
1404
1405 /* Only one definition allowed. */
1406 while (mapimg_count() != 0) {
1407 mapimg_delete(0);
1408 }
1409
1410 /* Map image definition: zoom, turns */
1411 fc_snprintf(str, sizeof(str), "zoom=%d:turns=0:format=%s",
1413
1414 /* Map image definition: show */
1416 cat_snprintf(str, sizeof(str), ":show=all");
1417 /* use all available knowledge */
1419 } else {
1420 cat_snprintf(str, sizeof(str), ":show=plrid:plrid=%d",
1422 /* use only player knowledge */
1424 }
1425
1426 /* Map image definition: map */
1427 for (layer = mapimg_layer_begin(); layer != mapimg_layer_end();
1428 layer = mapimg_layer_next(layer)) {
1429 if (gui_options.mapimg_layer[layer]) {
1430 mi_map[map_pos++] = mapimg_layer_name(layer)[0];
1431 }
1432 }
1433 mi_map[map_pos] = '\0';
1434
1435 if (map_pos == 0) {
1436 /* no value set - use dummy setting */
1437 sz_strlcpy(mi_map, "-");
1438 }
1439 cat_snprintf(str, sizeof(str), ":map=%s", mi_map);
1440
1441 log_debug("client map image definition: %s", str);
1442
1443 if (!mapimg_define(str, FALSE) || !mapimg_isvalid(0)) {
1444 /* An error in the definition string or an error validation the string.
1445 * The error message is available via mapimg_error(). */
1446 return FALSE;
1447 }
1448
1449 return TRUE;
1450}
1451
1452/**********************************************************************/
1455bool mapimg_client_createmap(const char *filename)
1456{
1457 struct mapdef *pmapdef;
1458 char mapimgfile[512];
1459
1460 if (NULL == filename || '\0' == filename[0]) {
1462 } else {
1463 sz_strlcpy(mapimgfile, filename);
1464 }
1465
1466 if (!mapimg_client_define()) {
1467 return FALSE;
1468 }
1469
1471 if (!pmapdef) {
1472 return FALSE;
1473 }
1474
1476}
1477
1478/**********************************************************************/
1482{
1483 struct option *poption = optset_option_by_name(server_optset, "nationset");
1484 const char *setting_str;
1485
1486 if (poption == NULL
1489 setting_str = "";
1490 }
1491
1493}
1494
1495/**********************************************************************/
1499{
1501}
1502
1503/**********************************************************************/
1508enum ai_level server_ai_level(void)
1509{
1510 enum ai_level lvl = game.info.skill_level;
1511
1512 players_iterate(pplayer) {
1513 if (is_ai(pplayer) && pplayer->ai_common.skill_level != lvl) {
1514 return ai_level_invalid();
1515 }
1517
1518 if (!is_settable_ai_level(lvl)) {
1519 return ai_level_invalid();
1520 }
1521
1522 return lvl;
1523}
#define NUM_ACTIONS
Definition actions.h:59
#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:663
bool can_city_build_unit_later(const struct city *pcity, const struct unit_type *punittype)
Definition city.c:968
bool can_city_build_now(const struct city *pcity, const struct universal *target)
Definition city.c:1011
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1236
const char * city_name_get(const struct city *pcity)
Definition city.c:1133
void city_remove_improvement(struct city *pcity, const struct impr_type *pimprove)
Definition city.c:3367
bool can_city_build_improvement_now(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:854
bool city_production_is_genus(const struct city *pcity, enum impr_genus_id genus)
Definition city.c:717
bool can_city_build_improvement_later(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:871
bool can_city_build_unit_now(const struct city *pcity, const struct unit_type *punittype)
Definition city.c:948
const char * city_production_name_translation(const struct city *pcity)
Definition city.c:700
#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:825
#define city_built_iterate_end
Definition city.h:831
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:592
int collect_eventually_buildable_targets(struct universal *targets, struct city *pcity, bool advanced_tech)
Definition climisc.c:809
bool city_unit_supported(const struct city *pcity, const struct universal *target)
Definition climisc.c:544
enum ai_level server_ai_level(void)
Definition climisc.c:1508
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:504
void create_event(struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition climisc.c:1082
int collect_buildable_targets(struct universal *targets)
Definition climisc.c:778
void client_player_init(struct player *pplayer)
Definition climisc.c:1362
bool mapimg_client_createmap(const char *filename)
Definition climisc.c:1455
void client_remove_city(struct city *pcity)
Definition climisc.c:134
void client_unit_init_act_prob_cache(struct unit *punit)
Definition climisc.c:1248
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:1306
void common_taxrates_callback(int idx, bool reverse)
Definition climisc.c:1183
static int city_buy_cost_compare(const void *a, const void *b)
Definition climisc.c:1292
bool mapimg_client_define(void)
Definition climisc.c:1398
int collect_currently_building_targets(struct universal *targets)
Definition climisc.c:746
enum unit_bg_color_type unit_color_type(const struct unit_type *punittype)
Definition climisc.c:1264
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:1231
void cityrep_buy(struct city *pcity)
Definition climisc.c:1144
void global_warming_scaled(int *chance, int *rate, int max)
Definition climisc.c:334
void client_player_maps_reset(void)
Definition climisc.c:1373
bool client_nation_is_in_current_set(const struct nation_type *pnation)
Definition climisc.c:1498
cid cid_encode_from_city(const struct city *pcity)
Definition climisc.c:517
void name_and_sort_items(struct universal *targets, int num_targets, struct item *items, bool show_cost, struct city *pcity)
Definition climisc.c:640
static int fc_cmp(const void *p1, const void *p2)
Definition climisc.c:616
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:940
cid cid_encode(struct universal target)
Definition climisc.c:482
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:582
struct nation_set * client_current_nation_set(void)
Definition climisc.c:1481
int num_supported_units_in_city(struct city *pcity)
Definition climisc.c:922
int collect_already_built_targets(struct universal *targets, struct city *pcity)
Definition climisc.c:902
struct city * get_nearest_city(const struct unit *punit, int *sq_dist)
Definition climisc.c:1108
struct universal cid_decode(cid id)
Definition climisc.c:525
void unit_focus_set_status(struct player *pplayer)
Definition climisc.c:1352
void handle_event(const char *featured_text, struct tile *ptile, enum event_type event, int turn, int phase, int conn_id)
Definition climisc.c:957
void center_on_something(void)
Definition climisc.c:430
cid cid_encode_unit(const struct unit_type *punittype)
Definition climisc.c:492
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:563
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:690
#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:61
struct world wld
Definition game.c:62
void game_remove_unit(struct world *gworld, struct unit *punit)
Definition game.c:123
void game_remove_city(struct world *gworld, struct city *pcity)
Definition game.c:184
struct city * game_city_by_number(int id)
Definition game.c:106
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:595
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:647
int map_num_tiles(void)
Definition map.c:1026
struct tile * native_pos_to_tile(const struct civ_map *nmap, int nat_x, int nat_y)
Definition map.c:449
#define iterate_outward(nmap, start_tile, max_dist, itr_tile)
Definition map.h:353
#define iterate_outward_end
Definition map.h:357
bool is_city_hilited(struct city *pcity)
struct mapdef * mapimg_isvalid(int id)
Definition mapimg.c:1124
bool mapimg_define(const char *maparg, bool check)
Definition mapimg.c:769
bool mapimg_delete(int id)
Definition mapimg.c:1207
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:1335
#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:4281
const char * option_str_get(const struct option *poption)
Definition options.c:928
enum option_type option_type(const struct option *poption)
Definition options.c:693
int messages_where[E_COUNT]
Definition options.c:5301
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:466
#define MW_POPUP
Definition options.h:617
#define MW_OUTPUT
Definition options.h:615
#define MW_MESSAGES
Definition options.h:616
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:1519
struct city_list * cities
Definition packhand.c:119
bool is_settable_ai_level(enum ai_level level)
Definition player.c:1925
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:1489
#define players_iterate_end
Definition player.h:539
#define players_iterate(_pplayer)
Definition player.h:534
#define is_ai(plr)
Definition player.h:232
#define is_human(plr)
Definition player.h:231
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
struct connection conn
Definition client_main.h:96
bool mapimg_layer[MAPIMG_LAYER_COUNT]
Definition options.h:228
struct ft_color highlight_our_names
Definition options.h:177
char mapimg_format[64]
Definition options.h:226
char mapimg_filename[512]
Definition options.h:229
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:281
struct dbv tile_vision[V_COUNT]
Definition player.h:359
struct unit_list * units
Definition player.h:282
struct player::@70::@73 client
struct player_economic economic
Definition player.h:284
Definition tile.h:50
struct unit_list * units
Definition tile.h:58
Definition unit.h:140
struct unit::@81::@83 client
int id
Definition unit.h:147
struct act_prob * act_prob_cache
Definition unit.h:231
int homecity
Definition unit.h:148
enum unit_focus_status focus_status
Definition unit.h:217
enum universals_n kind
Definition fc_types.h:880
universals_u value
Definition fc_types.h:879
struct civ_map map
int fc_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:960
size_t fc_strlcpy(char *dest, const char *src, size_t n)
Definition support.c:777
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:186
int cat_snprintf(char *str, size_t n, const char *format,...)
Definition support.c:986
int fc_vsnprintf(char *str, size_t n, const char *format, va_list ap)
Definition support.c:886
int fc_strncasecmp(const char *str0, const char *str1, size_t n)
Definition support.c:235
#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:300
#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:6832
struct sprite * get_indicator_sprite(const struct tileset *t, enum indicator_type indicator, int idx)
Definition tilespec.c:7038
struct sprite * get_citizen_sprite(const struct tileset *t, enum citizen_category type, int citizen_index, const struct city *pcity)
Definition tilespec.c:6761
@ INDICATOR_COOLING
Definition tilespec.h:310
@ INDICATOR_WARMING
Definition tilespec.h:309
@ INDICATOR_BULB
Definition tilespec.h:308
#define NUM_TILES_PROGRESS
Definition tilespec.h:197
const struct unit_type * utype
Definition fc_types.h:698
const struct impr_type * building
Definition fc_types.h:691
int get_transporter_occupancy(const struct unit *ptrans)
Definition unit.c:1821
bool unit_transport_unload(struct unit *pcargo)
Definition unit.c:2448
struct unit_list * unit_transport_cargo(const struct unit *ptrans)
Definition unit.c:2509
#define unit_tile(_pu)
Definition unit.h:397
@ FOCUS_AVAIL
Definition unit.h:54
#define unit_owner(_pu)
Definition unit.h:396
#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:773
#define utype_class(_t_)
Definition unittype.h:756
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition unittype.h:624
#define unit_type_iterate(_p)
Definition unittype.h:859
#define unit_type_iterate_end
Definition unittype.h:866
#define vision_layer_iterate(v)
Definition vision.h:77
#define vision_layer_iterate_end
Definition vision.h:80
#define MAP_NATIVE_WIDTH
#define MAP_INDEX_SIZE
#define MAP_NATIVE_HEIGHT