Freeciv-3.2: /fast/freeciv/nightly/S3_2/server/maphand.c Source File

Freeciv-3.2

Loading...
Searching...
No Matches
maphand.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* utility */
19#include "bitvector.h"
20#include "fcintl.h"
21#include "log.h"
22#include "mem.h"
23#include "rand.h"
24#include "support.h"
25
26/* common */
27#include "ai.h"
28#include "base.h"
29#include "borders.h"
30#include "events.h"
31#include "game.h"
32#include "map.h"
33#include "movement.h"
34#include "nation.h"
35#include "packets.h"
36#include "player.h"
37#include "road.h"
38#include "specialist.h"
39#include "unit.h"
40#include "unitlist.h"
41#include "vision.h"
42
43/* server */
44#include "citytools.h"
45#include "cityturn.h"
46#include "notify.h"
47#include "plrhand.h"
48#include "sanitycheck.h"
49#include "sernet.h"
50#include "srv_main.h"
51#include "unithand.h"
52#include "unittools.h"
53
54/* server/advisors */
55#include "advdata.h"
56
57/* server/generator */
58#include "mapgen_utils.h"
59
60#include "maphand.h"
61
62#define MAXIMUM_CLAIMED_OCEAN_SIZE (20)
63
64/* Suppress send_tile_info() during game_load() */
65 static bool send_tile_suppressed = FALSE;
66
67static void player_tile_init(struct tile *ptile, struct player *pplayer);
68static void player_tile_free(struct tile *ptile, struct player *pplayer);
69static bool give_tile_info_from_player_to_player(struct player *pfrom,
70 struct player *pdest,
71 struct tile *ptile);
72static void shared_vision_change_seen(struct player *pplayer,
73 struct tile *ptile,
74 const v_radius_t change,
75 bool can_reveal_tiles);
76static void map_change_seen(struct player *pplayer,
77 struct tile *ptile,
78 const v_radius_t change,
79 bool can_reveal_tiles);
80static void map_change_own_seen(struct player *pplayer,
81 struct tile *ptile,
82 const v_radius_t change);
83static inline int map_get_seen(const struct player *pplayer,
84 const struct tile *ptile,
85 enum vision_layer vlayer);
86static inline bool map_is_also_seen(const struct tile *ptile,
87 const struct player *pplayer,
88 enum vision_layer vlayer);
89
90static bool is_claimable_ocean(struct tile *ptile, struct tile *source,
91 struct player *pplayer);
92
93/**********************************************************************/
96 static bool is_terrain_ecologically_wet(struct tile *ptile)
97{
98 return (is_terrain_class_near_tile(&(wld.map), ptile, TC_OCEAN)
99 || tile_has_river(ptile)
100 || count_river_near_tile(&(wld.map), ptile, NULL) > 0);
101}
102
103/**********************************************************************/
106 void global_warming(int effect)
107{
108 climate_change(TRUE, effect);
109 notify_player(NULL, NULL, E_GLOBAL_ECO, ftc_server,
110 _("Global warming has occurred!"));
111 notify_player(NULL, NULL, E_GLOBAL_ECO, ftc_server,
112 _("Coastlines have been flooded and vast "
113 "ranges of grassland have become deserts."));
114}
115
116/**********************************************************************/
119 void nuclear_winter(int effect)
120{
121 climate_change(FALSE, effect);
122 notify_player(NULL, NULL, E_GLOBAL_ECO, ftc_server,
123 _("Nuclear winter has occurred!"));
124 notify_player(NULL, NULL, E_GLOBAL_ECO, ftc_server,
125 _("Wetlands have dried up and vast "
126 "ranges of grassland have become tundra."));
127}
128
129/**********************************************************************/
133 void climate_change(bool warming, int effect)
134{
135 int k = map_num_tiles();
136 bool used[k];
137 const struct civ_map *nmap = &(wld.map);
138
139 memset(used, 0, sizeof(used));
140
141 log_verbose("Climate change: %s (%d)",
142 warming ? "Global warming" : "Nuclear winter", effect);
143
144 while (effect > 0 && (k--) > 0) {
145 struct terrain *old, *candidates[2], *new;
146 struct tile *ptile;
147 int i;
148
149 do {
150 /* We want to transform a tile at most once due to a climate change. */
151 ptile = rand_map_pos(&(wld.map));
152 } while (used[tile_index(ptile)]);
153 used[tile_index(ptile)] = TRUE;
154
155 old = tile_terrain(ptile);
156 /* Prefer the transformation that's appropriate to the ambient moisture,
157 * but be prepared to fall back in exceptional circumstances */
158 {
159 struct terrain *wetter, *drier;
160
161 wetter = warming ? old->warmer_wetter_result : old->cooler_wetter_result;
162 drier = warming ? old->warmer_drier_result : old->cooler_drier_result;
163 if (is_terrain_ecologically_wet(ptile)) {
164 candidates[0] = wetter;
165 candidates[1] = drier;
166 } else {
167 candidates[0] = drier;
168 candidates[1] = wetter;
169 }
170 }
171
172 /* If the preferred transformation is ruled out for some exceptional reason
173 * specific to this tile, fall back to the other, rather than letting this
174 * tile be immune to change. */
175 for (i = 0; i < 2; i++) {
176 new = candidates[i];
177
178 /* If the preferred transformation simply hasn't been specified
179 * for this terrain at all, don't fall back to the other. */
180 if (new == T_NONE) {
181 break;
182 }
183
184 if (tile_city(ptile) != NULL && terrain_has_flag(new, TER_NO_CITIES)) {
185 /* do not change to a terrain with the flag TER_NO_CITIES if the tile
186 * has a city */
187 continue;
188 }
189
190 /* Only change between water and land at coastlines, and between
191 * frozen and unfrozen at ice margin */
192 if (!terrain_surroundings_allow_change(nmap, ptile, new)) {
193 continue;
194 }
195
196 /* OK! */
197 break;
198 }
199 if (i == 2) {
200 /* Neither transformation was permitted. Give up. */
201 continue;
202 }
203
204 if (new != T_NONE && old != new) {
205 effect--;
206
207 /* Check terrain changing activities.
208 These would not be caught by the check if unit can continue activity
209 after the terrain change has taken place, as the activity itself is still
210 legal, but would be towards different terrain, and terrain types are not
211 activity targets (target is NULL) */
212 unit_list_iterate(ptile->units, punit) {
213 if (punit->activity_target == NULL) {
214 /* Target is always NULL for terrain changing activities. */
215 if (punit->activity == ACTIVITY_CULTIVATE
216 || punit->activity == ACTIVITY_PLANT
217 || punit->activity == ACTIVITY_TRANSFORM) {
218 unit_activities_cancel(punit);
219 }
220 }
221 } unit_list_iterate_end;
222
223 /* Really change the terrain. */
224 tile_change_terrain(ptile, new);
225 check_terrain_change(ptile, old);
226 update_tile_knowledge(ptile);
227
228 tile_change_side_effects(ptile, FALSE);
229
230 } else if (old == new) {
231 /* This counts toward a climate change although nothing is changed. */
232 effect--;
233 }
234 }
235}
236
237/**********************************************************************/
241 bool upgrade_city_extras(struct city *pcity, struct extra_type **gained)
242{
243 struct tile *ptile = pcity->tile;
244 struct player *pplayer = city_owner(pcity);
245 bool upgradet = FALSE;
246
247 extra_type_iterate(pextra) {
248 if (!tile_has_extra(ptile, pextra)) {
249 if (extra_has_flag(pextra, EF_ALWAYS_ON_CITY_CENTER)
250 || (extra_has_flag(pextra, EF_AUTO_ON_CITY_CENTER)
251 && player_can_build_extra(pextra, pplayer, ptile)
252 && !tile_has_conflicting_extra(ptile, pextra))) {
253 tile_add_extra(pcity->tile, pextra);
254 if (gained != NULL) {
255 if (upgradet) {
256 *gained = NULL;
257 } else {
258 *gained = pextra;
259 }
260 }
261 upgradet = TRUE;
262 }
263 }
264 } extra_type_iterate_end;
265
266 return upgradet;
267}
268
269/**********************************************************************/
276 void upgrade_all_city_extras(struct player *pplayer, bool discovery)
277{
278 int cities_upgradet = 0;
279 struct extra_type *upgradet = NULL;
280 bool multiple_types = FALSE;
281 int cities_total = city_list_size(pplayer->cities);
282 int percent;
283
284 conn_list_do_buffer(pplayer->connections);
285
286 city_list_iterate(pplayer->cities, pcity) {
287 struct extra_type *new_upgrade;
288
289 if (upgrade_city_extras(pcity, &new_upgrade)) {
290 update_tile_knowledge(pcity->tile);
291 cities_upgradet++;
292 if (new_upgrade == NULL) {
293 /* This single city alone had multiple types */
294 multiple_types = TRUE;
295 } else if (upgradet == NULL) {
296 /* First gained */
297 upgradet = new_upgrade;
298 } else if (upgradet != new_upgrade) {
299 /* Different type from what another city got. */
300 multiple_types = TRUE;
301 }
302 }
303 } city_list_iterate_end;
304
305 if (cities_total > 0) {
306 percent = cities_upgradet * 100 / cities_total;
307 } else {
308 percent = 0;
309 }
310
311 if (cities_upgradet > 0) {
312 if (discovery) {
313 if (percent >= 75) {
314 notify_player(pplayer, NULL, E_TECH_GAIN, ftc_server,
315 _("New hope sweeps like fire through the country as "
316 "the discovery of new infrastructure building technology "
317 "is announced."));
318 }
319 } else {
320 if (percent >= 75) {
321 notify_player(pplayer, NULL, E_TECH_GAIN, ftc_server,
322 _("The people are pleased to hear that your "
323 "scientists finally know about new infrastructure building "
324 "technology."));
325 }
326 }
327
328 if (multiple_types) {
329 notify_player(pplayer, NULL, E_TECH_GAIN, ftc_server,
330 _("Workers spontaneously gather and upgrade all "
331 "possible cities with better infrastructure."));
332 } else {
333 notify_player(pplayer, NULL, E_TECH_GAIN, ftc_server,
334 _("Workers spontaneously gather and upgrade all "
335 "possible cities with %s."), extra_name_translation(upgradet));
336 }
337 }
338
339 conn_list_do_unbuffer(pplayer->connections);
340}
341
342/**********************************************************************/
345 bool really_gives_vision(struct player *me, struct player *them)
346{
347 return BV_ISSET(me->server.really_gives_vision, player_index(them));
348}
349
350/**********************************************************************/
353 static void buffer_shared_vision(struct player *pplayer)
354{
355 players_iterate(pplayer2) {
356 if (really_gives_vision(pplayer, pplayer2)) {
357 conn_list_compression_freeze(pplayer2->connections);
358 conn_list_do_buffer(pplayer2->connections);
359 }
360 } players_iterate_end;
361 conn_list_compression_freeze(pplayer->connections);
362 conn_list_do_buffer(pplayer->connections);
363}
364
365/**********************************************************************/
368 static void unbuffer_shared_vision(struct player *pplayer)
369{
370 players_iterate(pplayer2) {
371 if (really_gives_vision(pplayer, pplayer2)) {
372 conn_list_do_unbuffer(pplayer2->connections);
373 conn_list_compression_thaw(pplayer2->connections);
374 }
375 } players_iterate_end;
376 conn_list_do_unbuffer(pplayer->connections);
377 conn_list_compression_thaw(pplayer->connections);
378}
379
380/**********************************************************************/
384 void give_map_from_player_to_player(struct player *pfrom, struct player *pdest)
385{
386 buffer_shared_vision(pdest);
387
388 whole_map_iterate(&(wld.map), ptile) {
389 give_tile_info_from_player_to_player(pfrom, pdest, ptile);
390 } whole_map_iterate_end;
391
392 unbuffer_shared_vision(pdest);
393 city_thaw_workers_queue();
394 sync_cities();
395}
396
397/**********************************************************************/
400 void give_seamap_from_player_to_player(struct player *pfrom, struct player *pdest)
401{
402 buffer_shared_vision(pdest);
403
404 whole_map_iterate(&(wld.map), ptile) {
405 if (is_ocean_tile(ptile)) {
406 give_tile_info_from_player_to_player(pfrom, pdest, ptile);
407 }
408 } whole_map_iterate_end;
409
410 unbuffer_shared_vision(pdest);
411 city_thaw_workers_queue();
412 sync_cities();
413}
414
415/**********************************************************************/
418 void give_citymap_from_player_to_player(struct city *pcity,
419 struct player *pfrom, struct player *pdest)
420{
421 struct tile *pcenter = city_tile(pcity);
422 const struct civ_map *nmap = &(wld.map);
423
424 buffer_shared_vision(pdest);
425
426 city_tile_iterate(nmap, city_map_radius_sq_get(pcity), pcenter, ptile) {
427 give_tile_info_from_player_to_player(pfrom, pdest, ptile);
428 } city_tile_iterate_end;
429
430 unbuffer_shared_vision(pdest);
431 city_thaw_workers_queue();
432 sync_cities();
433}
434
435/**********************************************************************/
444 void send_all_known_tiles(struct conn_list *dest)
445{
446 int tiles_sent;
447
448 if (!dest) {
449 dest = game.est_connections;
450 }
451
452 /* send whole map piece by piece to each player to balance the load
453 of the send buffers better */
454 tiles_sent = 0;
455 conn_list_do_buffer(dest);
456
457 whole_map_iterate(&(wld.map), ptile) {
458 tiles_sent++;
459 if ((tiles_sent % wld.map.xsize) == 0) {
460 conn_list_do_unbuffer(dest);
461 flush_packets();
462 conn_list_do_buffer(dest);
463 }
464
465 send_tile_info(dest, ptile, FALSE);
466 } whole_map_iterate_end;
467
468 conn_list_do_unbuffer(dest);
469 flush_packets();
470}
471
472/**********************************************************************/
475 bool send_tile_suppression(bool now)
476{
477 bool formerly = send_tile_suppressed;
478
479 send_tile_suppressed = now;
480 return formerly;
481}
482
483/**********************************************************************/
491 void send_tile_info(struct conn_list *dest, struct tile *ptile,
492 bool send_unknown)
493{
494 struct packet_tile_info info;
495 const struct player *owner;
496 const struct player *eowner;
497
498 if (dest == NULL) {
499 CALL_FUNC_EACH_AI(tile_info, ptile);
500 }
501
502 if (send_tile_suppressed) {
503 return;
504 }
505
506 if (!dest) {
507 dest = game.est_connections;
508 }
509
510 info.tile = tile_index(ptile);
511
512 if (ptile->spec_sprite) {
513 sz_strlcpy(info.spec_sprite, ptile->spec_sprite);
514 } else {
515 info.spec_sprite[0] = '\0';
516 }
517
518 conn_list_iterate(dest, pconn) {
519 struct player *pplayer = pconn->playing;
520 bool known;
521
522 if (NULL == pplayer && !pconn->observer) {
523 continue;
524 }
525
526 if (pplayer != NULL) {
527 known = map_is_known(ptile, pplayer);
528 }
529
530 if (pplayer == NULL || (known && map_is_also_seen(ptile, pplayer, V_MAIN))) {
531 struct extra_type *resource;
532
533 info.known = TILE_KNOWN_SEEN;
534 info.continent = tile_continent(ptile);
535 owner = tile_owner(ptile);
536 eowner = extra_owner(ptile);
537 info.owner = (owner ? player_number(owner) : MAP_TILE_OWNER_NULL);
538 info.extras_owner = (eowner ? player_number(eowner) : MAP_TILE_OWNER_NULL);
539 info.worked = (NULL != tile_worked(ptile))
540 ? tile_worked(ptile)->id
541 : IDENTITY_NUMBER_ZERO;
542
543 info.terrain = (NULL != tile_terrain(ptile))
544 ? terrain_number(tile_terrain(ptile))
545 : terrain_count();
546
547 resource = tile_resource(ptile);
548 if (resource != NULL
549 && (pplayer == NULL
550 || player_knows_extra_exist(pplayer, resource, ptile))) {
551 info.resource = extra_number(resource);
552 } else {
553 info.resource = MAX_EXTRA_TYPES;
554 }
555
556 info.placing = (NULL != ptile->placing)
557 ? extra_number(ptile->placing)
558 : -1;
559 info.place_turn = (NULL != ptile->placing)
560 ? game.info.turn + ptile->infra_turns
561 : 0;
562
563 if (pplayer != NULL) {
564 dbv_to_bv(info.extras.vec, &(map_get_player_tile(ptile, pplayer)->extras));
565 } else {
566 info.extras = ptile->extras;
567 }
568
569 if (ptile->label != NULL) {
570 /* Always leave final '\0' in place */
571 strncpy(info.label, ptile->label, sizeof(info.label) - 1);
572 } else {
573 info.label[0] = '\0';
574 }
575
576 send_packet_tile_info(pconn, &info);
577 } else if (pplayer != NULL && known) {
578 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
579 struct vision_site *psite = map_get_playermap_site(plrtile);
580
581 info.known = TILE_KNOWN_UNSEEN;
582 info.continent = tile_continent(ptile);
583 owner = (game.server.foggedborders
584 ? plrtile->owner
585 : tile_owner(ptile));
586 eowner = plrtile->extras_owner;
587 info.owner = (owner ? player_number(owner) : MAP_TILE_OWNER_NULL);
588 info.extras_owner = (eowner ? player_number(eowner) : MAP_TILE_OWNER_NULL);
589 info.worked = (NULL != psite)
590 ? psite->identity
591 : IDENTITY_NUMBER_ZERO;
592
593 info.terrain = (NULL != plrtile->terrain)
594 ? terrain_number(plrtile->terrain)
595 : terrain_count();
596 info.resource = (NULL != plrtile->resource)
597 ? extra_number(plrtile->resource)
598 : MAX_EXTRA_TYPES;
599 info.placing = -1;
600 info.place_turn = 0;
601
602 dbv_to_bv(info.extras.vec, &(plrtile->extras));
603
604 /* Labels never change, so they are not subject to fog of war */
605 if (ptile->label != NULL) {
606 sz_strlcpy(info.label, ptile->label);
607 } else {
608 info.label[0] = '\0';
609 }
610
611 send_packet_tile_info(pconn, &info);
612 } else if (send_unknown) {
613 info.known = TILE_UNKNOWN;
614 info.continent = 0;
615 info.owner = MAP_TILE_OWNER_NULL;
616 info.extras_owner = MAP_TILE_OWNER_NULL;
617 info.worked = IDENTITY_NUMBER_ZERO;
618
619 info.terrain = terrain_count();
620 info.resource = MAX_EXTRA_TYPES;
621 info.placing = -1;
622 info.place_turn = 0;
623
624 BV_CLR_ALL(info.extras);
625
626 info.label[0] = '\0';
627
628 send_packet_tile_info(pconn, &info);
629 }
630 }
631 conn_list_iterate_end;
632}
633
634/**********************************************************************/
640 static bool unit_is_on_layer(const struct unit *punit,
641 enum vision_layer vlayer)
642{
643 return unit_type_get(punit)->vlayer == vlayer;
644}
645
646/**********************************************************************/
649 void send_map_info(struct conn_list *dest)
650{
651 struct packet_map_info minfo;
652
653 minfo.xsize = wld.map.xsize;
654 minfo.ysize = wld.map.ysize;
655 minfo.topology_id = wld.map.topology_id;
656 minfo.wrap_id = wld.map.wrap_id;
657 minfo.north_latitude = wld.map.north_latitude;
658 minfo.south_latitude = wld.map.south_latitude;
659
660 lsend_packet_map_info(dest, &minfo);
661}
662
663/**********************************************************************/
667 static void shared_vision_change_seen(struct player *pplayer,
668 struct tile *ptile,
669 const v_radius_t change,
670 bool can_reveal_tiles)
671{
672 map_change_own_seen(pplayer, ptile, change);
673 map_change_seen(pplayer, ptile, change, can_reveal_tiles);
674
675 players_iterate(pplayer2) {
676 if (really_gives_vision(pplayer, pplayer2)) {
677 map_change_seen(pplayer2, ptile, change, can_reveal_tiles);
678 }
679 } players_iterate_end;
680}
681
682/**********************************************************************/
685 void map_vision_update(struct player *pplayer, struct tile *ptile,
686 const v_radius_t old_radius_sq,
687 const v_radius_t new_radius_sq,
688 bool can_reveal_tiles)
689{
690 v_radius_t change;
691 int max_radius;
692
693 if (old_radius_sq[V_MAIN] == new_radius_sq[V_MAIN]
694 && old_radius_sq[V_INVIS] == new_radius_sq[V_INVIS]
695 && old_radius_sq[V_SUBSURFACE] == new_radius_sq[V_SUBSURFACE]) {
696 return;
697 }
698
699 /* Determines 'max_radius' value. */
700 max_radius = 0;
701 vision_layer_iterate(v) {
702 if (max_radius < old_radius_sq[v]) {
703 max_radius = old_radius_sq[v];
704 }
705 if (max_radius < new_radius_sq[v]) {
706 max_radius = new_radius_sq[v];
707 }
708 } vision_layer_iterate_end;
709
710#ifdef FREECIV_DEBUG
711 log_debug("Updating vision at (%d, %d) in a radius of %d.",
712 TILE_XY(ptile), max_radius);
713 vision_layer_iterate(v) {
714 log_debug(" vision layer %d is changing from %d to %d.",
715 v, old_radius_sq[v], new_radius_sq[v]);
716 } vision_layer_iterate_end;
717#endif /* FREECIV_DEBUG */
718
719 buffer_shared_vision(pplayer);
720 circle_dxyr_iterate(&(wld.map), ptile, max_radius, tile1, dx, dy, dr) {
721 vision_layer_iterate(v) {
722 if (dr > old_radius_sq[v] && dr <= new_radius_sq[v]) {
723 change[v] = 1;
724 } else if (dr > new_radius_sq[v] && dr <= old_radius_sq[v]) {
725 change[v] = -1;
726 } else {
727 change[v] = 0;
728 }
729 } vision_layer_iterate_end;
730 shared_vision_change_seen(pplayer, tile1, change, can_reveal_tiles);
731 } circle_dxyr_iterate_end;
732 unbuffer_shared_vision(pplayer);
733}
734
735/**********************************************************************/
740 void map_set_border_vision(struct player *pplayer,
741 const bool is_enabled)
742{
743 const v_radius_t radius_sq = V_RADIUS(is_enabled ? 1 : -1, 0, 0);
744
745 if (pplayer->server.border_vision == is_enabled) {
746 /* No change. Changing the seen count beyond what already exists would
747 * be a bug. */
748 return;
749 }
750
751 /* Set the new border seer value. */
752 pplayer->server.border_vision = is_enabled;
753
754 whole_map_iterate(&(wld.map), ptile) {
755 if (pplayer == ptile->owner) {
756 /* The tile is within the player's borders. */
757 shared_vision_change_seen(pplayer, ptile, radius_sq, TRUE);
758 }
759 } whole_map_iterate_end;
760}
761
762/**********************************************************************/
768 void map_show_tile(struct player *src_player, struct tile *ptile)
769{
770 static int recurse = 0;
771
772 log_debug("Showing %i,%i to %s", TILE_XY(ptile), player_name(src_player));
773
774 fc_assert(recurse == 0);
775 recurse++;
776
777 players_iterate(pplayer) {
778 if (pplayer == src_player || really_gives_vision(src_player, pplayer)) {
779 struct city *pcity;
780
781 if (!map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
782 map_set_known(ptile, pplayer);
783
784 /* As the tile may be fogged send_tile_info won't always do this for us */
785 update_player_tile_knowledge(pplayer, ptile);
786 update_player_tile_last_seen(pplayer, ptile);
787
788 send_tile_info(pplayer->connections, ptile, FALSE);
789
790 /* Remove old cities that exist no more */
791 reality_check_city(pplayer, ptile);
792
793 if ((pcity = tile_city(ptile))) {
794 /* As the tile may be fogged send_city_info won't do this for us */
795 update_dumb_city(pplayer, pcity);
796 send_city_info(pplayer, pcity);
797 }
798
799 vision_layer_iterate(v) {
800 if (0 < map_get_seen(pplayer, ptile, v)) {
801 unit_list_iterate(ptile->units, punit) {
802 if (unit_is_on_layer(punit, v)) {
803 send_unit_info(pplayer->connections, punit);
804 }
805 } unit_list_iterate_end;
806 }
807 } vision_layer_iterate_end;
808 }
809 }
810 } players_iterate_end;
811
812 recurse--;
813}
814
815/**********************************************************************/
820 void map_hide_tile(struct player *src_player, struct tile *ptile)
821{
822 static int recurse = 0;
823
824 log_debug("Hiding %d,%d to %s", TILE_XY(ptile), player_name(src_player));
825
826 fc_assert(recurse == 0);
827 recurse++;
828
829 players_iterate(pplayer) {
830 if (pplayer == src_player || really_gives_vision(src_player, pplayer)) {
831 if (map_is_known(ptile, pplayer)) {
832 if (0 < map_get_seen(pplayer, ptile, V_MAIN)) {
833 update_player_tile_last_seen(pplayer, ptile);
834 }
835
836 /* Remove city. */
837 remove_dumb_city(pplayer, ptile);
838
839 /* Remove units. */
840 vision_layer_iterate(v) {
841 if (0 < map_get_seen(pplayer, ptile, v)) {
842 unit_list_iterate(ptile->units, punit) {
843 if (unit_is_on_layer(punit, v)) {
844 unit_goes_out_of_sight(pplayer, punit);
845 }
846 } unit_list_iterate_end;
847 }
848 } vision_layer_iterate_end;
849 }
850
851 map_clear_known(ptile, pplayer);
852
853 send_tile_info(pplayer->connections, ptile, TRUE);
854 }
855 } players_iterate_end;
856
857 recurse--;
858}
859
860/**********************************************************************/
864 void map_show_circle(struct player *pplayer, struct tile *ptile, int radius_sq)
865{
866 buffer_shared_vision(pplayer);
867
868 circle_iterate(&(wld.map), ptile, radius_sq, tile1) {
869 map_show_tile(pplayer, tile1);
870 } circle_iterate_end;
871
872 unbuffer_shared_vision(pplayer);
873}
874
875/**********************************************************************/
879 void map_show_all(struct player *pplayer)
880{
881 buffer_shared_vision(pplayer);
882
883 whole_map_iterate(&(wld.map), ptile) {
884 map_show_tile(pplayer, ptile);
885 } whole_map_iterate_end;
886
887 unbuffer_shared_vision(pplayer);
888}
889
890/**********************************************************************/
894 bool map_is_known(const struct tile *ptile, const struct player *pplayer)
895{
896 if (pplayer->tile_known.vec == NULL) {
897 /* Player map not initialized yet */
898 return FALSE;
899 }
900
901 return dbv_isset(&pplayer->tile_known, tile_index(ptile));
902}
903
904/**********************************************************************/
909 static inline bool map_is_also_seen(const struct tile *ptile,
910 const struct player *pplayer,
911 enum vision_layer vlayer)
912{
913 return map_get_seen(pplayer, ptile, vlayer) > 0;
914}
915
916/**********************************************************************/
920 bool map_is_known_and_seen(const struct tile *ptile,
921 const struct player *pplayer,
922 enum vision_layer vlayer)
923{
924 return map_is_known(ptile, pplayer) && map_is_also_seen(ptile, pplayer, vlayer);
925}
926
927/**********************************************************************/
934 static inline int map_get_seen(const struct player *pplayer,
935 const struct tile *ptile,
936 enum vision_layer vlayer)
937{
938 return map_get_player_tile(ptile, pplayer)->seen_count[vlayer];
939}
940
941/**********************************************************************/
947 void map_change_seen(struct player *pplayer,
948 struct tile *ptile,
949 const v_radius_t change,
950 bool can_reveal_tiles)
951{
952 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
953 bool revealing_tile = FALSE;
954
955#ifdef FREECIV_DEBUG
956 log_debug("%s() for player %s (nb %d) at (%d, %d).",
957 __FUNCTION__, player_name(pplayer), player_number(pplayer),
958 TILE_XY(ptile));
959 vision_layer_iterate(v) {
960 log_debug(" vision layer %d is changing from %d to %d.",
961 v, plrtile->seen_count[v], plrtile->seen_count[v] + change[v]);
962 } vision_layer_iterate_end;
963#endif /* FREECIV_DEBUG */
964
965 /* Removes units out of vision. First, check invisible layers because
966 * we must remove all units before fog of war because clients expect
967 * the tile is empty when it is fogged. */
968 if (0 > change[V_INVIS]
969 && plrtile->seen_count[V_INVIS] == -change[V_INVIS]) {
970 log_debug("(%d, %d): hiding invisible units to player %s (nb %d).",
971 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
972
973 unit_list_iterate(ptile->units, punit) {
974 if (unit_is_on_layer(punit, V_INVIS)
975 && can_player_see_unit(pplayer, punit)
976 && (plrtile->seen_count[V_MAIN] + change[V_MAIN] <= 0
977 || !pplayers_allied(pplayer, unit_owner(punit)))) {
978 /* Allied units on seen tiles (V_MAIN) are always seen.
979 * That's how can_player_see_unit_at() works. */
980 unit_goes_out_of_sight(pplayer, punit);
981 }
982 } unit_list_iterate_end;
983 }
984 if (0 > change[V_SUBSURFACE]
985 && plrtile->seen_count[V_SUBSURFACE] == -change[V_SUBSURFACE]) {
986 log_debug("(%d, %d): hiding subsurface units to player %s (nb %d).",
987 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
988
989 unit_list_iterate(ptile->units, punit) {
990 if (unit_is_on_layer(punit, V_SUBSURFACE)
991 && can_player_see_unit(pplayer, punit)) {
992 unit_goes_out_of_sight(pplayer, punit);
993 }
994 } unit_list_iterate_end;
995 }
996
997 if (0 > change[V_MAIN]
998 && plrtile->seen_count[V_MAIN] == -change[V_MAIN]) {
999 log_debug("(%d, %d): hiding visible units to player %s (nb %d).",
1000 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1001
1002 unit_list_iterate(ptile->units, punit) {
1003 if (unit_is_on_layer(punit, V_MAIN)
1004 && can_player_see_unit(pplayer, punit)) {
1005 unit_goes_out_of_sight(pplayer, punit);
1006 }
1007 } unit_list_iterate_end;
1008 }
1009
1010 vision_layer_iterate(v) {
1011 /* Avoid underflow. */
1012 fc_assert(0 <= change[v] || -change[v] <= plrtile->seen_count[v]);
1013 plrtile->seen_count[v] += change[v];
1014 } vision_layer_iterate_end;
1015
1016 /* V_MAIN vision ranges must always be more than invisible ranges
1017 * (see comment in common/vision.h), so we assume that the V_MAIN
1018 * seen count cannot be inferior to V_INVIS or V_SUBSURFACE seen count.
1019 * Moreover, when the fog of war is disabled, V_MAIN has an extra
1020 * seen count point. */
1021 fc_assert(plrtile->seen_count[V_INVIS] + !game.info.fogofwar
1022 <= plrtile->seen_count[V_MAIN]);
1023 fc_assert(plrtile->seen_count[V_SUBSURFACE] + !game.info.fogofwar
1024 <= plrtile->seen_count[V_MAIN]);
1025
1026 if (!map_is_known(ptile, pplayer)) {
1027 if (0 < plrtile->seen_count[V_MAIN] && can_reveal_tiles) {
1028 log_debug("(%d, %d): revealing tile to player %s (nb %d).",
1029 TILE_XY(ptile), player_name(pplayer),
1030 player_number(pplayer));
1031
1032 map_set_known(ptile, pplayer);
1033 revealing_tile = TRUE;
1034 } else {
1035 return;
1036 }
1037 }
1038
1039 /* Fog the tile. */
1040 if (0 > change[V_MAIN] && 0 == plrtile->seen_count[V_MAIN]) {
1041 struct city *pcity;
1042
1043 log_debug("(%d, %d): fogging tile for player %s (nb %d).",
1044 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1045
1046 pcity = ptile->worked;
1047
1048 if (pcity != NULL && city_owner(pcity) == pplayer) {
1049 city_map_update_empty(pcity, ptile);
1050 pcity->specialists[DEFAULT_SPECIALIST]++;
1051 }
1052
1053 update_player_tile_last_seen(pplayer, ptile);
1054 if (game.server.foggedborders) {
1055 plrtile->owner = tile_owner(ptile);
1056 }
1057 plrtile->extras_owner = extra_owner(ptile);
1058 send_tile_info(pplayer->connections, ptile, FALSE);
1059 }
1060
1061 if ((revealing_tile && 0 < plrtile->seen_count[V_MAIN])
1062 || (0 < change[V_MAIN]
1063 /* plrtile->seen_count[V_MAIN] Always set to 1
1064 * when the fog of war is disabled. */
1065 && (change[V_MAIN] + !game.info.fogofwar
1066 == (plrtile->seen_count[V_MAIN])))) {
1067 struct city *pcity;
1068
1069 log_debug("(%d, %d): unfogging tile for player %s (nb %d).",
1070 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1071
1072 /* Send info about the tile itself.
1073 * It has to be sent first because the client needs correct
1074 * continent number before it can handle following packets
1075 */
1076 update_player_tile_knowledge(pplayer, ptile);
1077 send_tile_info(pplayer->connections, ptile, FALSE);
1078
1079 /* Discover units. */
1080 unit_list_iterate(ptile->units, punit) {
1081 /* Be sure not to revive dead unit on client when it's not yet
1082 * removed from the tile. This could happen when "unit_lost" lua script
1083 * somehow causes tile of the dead unit to unfog again. */
1084 if (unit_is_on_layer(punit, V_MAIN)
1085 && !punit->server.dying) {
1086 send_unit_info(pplayer->connections, punit);
1087 }
1088 } unit_list_iterate_end;
1089
1090 /* Discover cities. */
1091 reality_check_city(pplayer, ptile);
1092
1093 if (NULL != (pcity = tile_city(ptile))) {
1094 send_city_info(pplayer, pcity);
1095 }
1096 }
1097
1098 if ((revealing_tile && 0 < plrtile->seen_count[V_INVIS])
1099 || (0 < change[V_INVIS]
1100 && change[V_INVIS] == plrtile->seen_count[V_INVIS])) {
1101 log_debug("(%d, %d): revealing invisible units to player %s (nb %d).",
1102 TILE_XY(ptile), player_name(pplayer),
1103 player_number(pplayer));
1104 /* Discover units. */
1105 unit_list_iterate(ptile->units, punit) {
1106 if (unit_is_on_layer(punit, V_INVIS)) {
1107 send_unit_info(pplayer->connections, punit);
1108 }
1109 } unit_list_iterate_end;
1110 }
1111 if ((revealing_tile && 0 < plrtile->seen_count[V_SUBSURFACE])
1112 || (0 < change[V_SUBSURFACE]
1113 && change[V_SUBSURFACE] == plrtile->seen_count[V_SUBSURFACE])) {
1114 log_debug("(%d, %d): revealing subsurface units to player %s (nb %d).",
1115 TILE_XY(ptile), player_name(pplayer),
1116 player_number(pplayer));
1117 /* Discover units. */
1118 unit_list_iterate(ptile->units, punit) {
1119 if (unit_is_on_layer(punit, V_SUBSURFACE)) {
1120 send_unit_info(pplayer->connections, punit);
1121 }
1122 } unit_list_iterate_end;
1123 }
1124}
1125
1126/**********************************************************************/
1133 static inline int player_tile_own_seen(const struct player_tile *plrtile,
1134 enum vision_layer vlayer)
1135{
1136 return plrtile->own_seen[vlayer];
1137}
1138
1139/**********************************************************************/
1142 static void map_change_own_seen(struct player *pplayer,
1143 struct tile *ptile,
1144 const v_radius_t change)
1145{
1146 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1147
1148 vision_layer_iterate(v) {
1149 plrtile->own_seen[v] += change[v];
1150 } vision_layer_iterate_end;
1151}
1152
1153/**********************************************************************/
1156 void change_playertile_site(struct player_tile *ptile,
1157 struct vision_site *new_site)
1158{
1159 if (ptile->site == new_site) {
1160 /* Do nothing. */
1161 return;
1162 }
1163
1164 if (ptile->site != NULL) {
1165 /* Releasing old site from tile */
1166 vision_site_destroy(ptile->site);
1167 }
1168
1169 ptile->site = new_site;
1170}
1171
1172/**********************************************************************/
1175 void map_set_known(struct tile *ptile, struct player *pplayer)
1176{
1177 dbv_set(&pplayer->tile_known, tile_index(ptile));
1178}
1179
1180/**********************************************************************/
1183 void map_clear_known(struct tile *ptile, struct player *pplayer)
1184{
1185 dbv_clr(&pplayer->tile_known, tile_index(ptile));
1186}
1187
1188/**********************************************************************/
1193 void map_know_and_see_all(struct player *pplayer)
1194{
1195 const v_radius_t radius_sq = V_RADIUS(1, 1, 1);
1196
1197 buffer_shared_vision(pplayer);
1198 whole_map_iterate(&(wld.map), ptile) {
1199 map_change_seen(pplayer, ptile, radius_sq, TRUE);
1200 } whole_map_iterate_end;
1201 unbuffer_shared_vision(pplayer);
1202}
1203
1204/**********************************************************************/
1207 void show_map_to_all(void)
1208{
1209 players_iterate(pplayer) {
1210 map_know_and_see_all(pplayer);
1211 } players_iterate_end;
1212}
1213
1214/**********************************************************************/
1218 void player_map_init(struct player *pplayer)
1219{
1220 pplayer->server.private_map
1221 = fc_realloc(pplayer->server.private_map,
1222 MAP_INDEX_SIZE * sizeof(*pplayer->server.private_map));
1223
1224 whole_map_iterate(&(wld.map), ptile) {
1225 player_tile_init(ptile, pplayer);
1226 } whole_map_iterate_end;
1227
1228 dbv_init(&pplayer->tile_known, MAP_INDEX_SIZE);
1229}
1230
1231/**********************************************************************/
1234 void player_map_free(struct player *pplayer)
1235{
1236 if (!pplayer->server.private_map) {
1237 return;
1238 }
1239
1240 whole_map_iterate(&(wld.map), ptile) {
1241 player_tile_free(ptile, pplayer);
1242 } whole_map_iterate_end;
1243
1244 free(pplayer->server.private_map);
1245 pplayer->server.private_map = NULL;
1246
1247 dbv_free(&pplayer->tile_known);
1248}
1249
1250/**********************************************************************/
1255 void remove_player_from_maps(struct player *pplayer)
1256{
1257 /* only after removing borders! */
1258 conn_list_do_buffer(game.est_connections);
1259 whole_map_iterate(&(wld.map), ptile) {
1260 /* Clear all players' knowledge about the removed player, and free
1261 * data structures (including those in removed player's player map). */
1262 bool reality_changed = FALSE;
1263
1264 players_iterate(aplayer) {
1265 struct player_tile *aplrtile;
1266 bool changed = FALSE;
1267
1268 if (!aplayer->server.private_map) {
1269 continue;
1270 }
1271 aplrtile = map_get_player_tile(ptile, aplayer);
1272
1273 /* Free vision sites (cities) for removed and other players */
1274 if (aplrtile && aplrtile->site
1275 && vision_site_owner(aplrtile->site) == pplayer) {
1276 change_playertile_site(aplrtile, NULL);
1277 changed = TRUE;
1278 }
1279
1280 /* Remove references to player from others' maps */
1281 if (aplrtile->owner == pplayer) {
1282 aplrtile->owner = NULL;
1283 changed = TRUE;
1284 }
1285 if (aplrtile->extras_owner == pplayer) {
1286 aplrtile->extras_owner = NULL;
1287 changed = TRUE;
1288 }
1289
1290 /* Must ensure references to dying player are gone from clients
1291 * before player is destroyed */
1292 if (changed) {
1293 /* This will use player tile if fogged */
1294 send_tile_info(pplayer->connections, ptile, FALSE);
1295 }
1296 } players_iterate_end;
1297
1298 /* Clear removed player's knowledge */
1299 if (pplayer->tile_known.vec) {
1300 map_clear_known(ptile, pplayer);
1301 }
1302
1303 /* Free all claimed tiles. */
1304 if (tile_owner(ptile) == pplayer) {
1305 tile_set_owner(ptile, NULL, NULL);
1306 reality_changed = TRUE;
1307 }
1308 if (extra_owner(ptile) == pplayer) {
1309 ptile->extras_owner = NULL;
1310 reality_changed = TRUE;
1311 }
1312
1313 if (reality_changed) {
1314 /* Update anyone who can see the tile (e.g. global observers) */
1315 send_tile_info(NULL, ptile, FALSE);
1316 }
1317 } whole_map_iterate_end;
1318 conn_list_do_unbuffer(game.est_connections);
1319}
1320
1321/**********************************************************************/
1325 static void player_tile_init(struct tile *ptile, struct player *pplayer)
1326{
1327 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1328
1329 plrtile->terrain = T_UNKNOWN;
1330 plrtile->resource = NULL;
1331 plrtile->owner = NULL;
1332 plrtile->extras_owner = NULL;
1333 plrtile->site = NULL;
1334 dbv_init(&(plrtile->extras), extra_count());
1335 if (!game.server.last_updated_year) {
1336 plrtile->last_updated = game.info.turn;
1337 } else {
1338 plrtile->last_updated = game.info.year;
1339 }
1340
1341 plrtile->seen_count[V_MAIN] = !game.server.fogofwar_old;
1342 plrtile->seen_count[V_INVIS] = 0;
1343 plrtile->seen_count[V_SUBSURFACE] = 0;
1344 memcpy(plrtile->own_seen, plrtile->seen_count, sizeof(v_radius_t));
1345}
1346
1347/**********************************************************************/
1350 static void player_tile_free(struct tile *ptile, struct player *pplayer)
1351{
1352 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1353
1354 if (plrtile->site != NULL) {
1355 vision_site_destroy(plrtile->site);
1356 }
1357
1358 dbv_free(&(plrtile->extras));
1359}
1360
1361/**********************************************************************/
1364 struct vision_site *map_get_player_city(const struct tile *ptile,
1365 const struct player *pplayer)
1366{
1367 struct vision_site *psite = map_get_player_site(ptile, pplayer);
1368
1369 fc_assert_ret_val(psite == NULL || psite->location == ptile, NULL);
1370
1371 return psite;
1372}
1373
1374/**********************************************************************/
1379 struct player_tile *map_get_player_tile(const struct tile *ptile,
1380 const struct player *pplayer)
1381{
1382 fc_assert_ret_val(pplayer->server.private_map, NULL);
1383
1384 return pplayer->server.private_map + tile_index(ptile);
1385}
1386
1387/**********************************************************************/
1395 bool update_player_tile_knowledge(struct player *pplayer, struct tile *ptile)
1396{
1397 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1398
1399 if (plrtile->terrain != ptile->terrain
1400 || !bv_match_dbv(&(plrtile->extras), ptile->extras.vec)
1401 || plrtile->resource != ptile->resource
1402 || plrtile->owner != tile_owner(ptile)
1403 || plrtile->extras_owner != extra_owner(ptile)) {
1404 plrtile->terrain = ptile->terrain;
1405 extra_type_iterate(pextra) {
1406 if (player_knows_extra_exist(pplayer, pextra, ptile)) {
1407 dbv_set(&(plrtile->extras), extra_number(pextra));
1408 } else {
1409 dbv_clr(&(plrtile->extras), extra_number(pextra));
1410 }
1411 } extra_type_iterate_end;
1412 if (ptile->resource != NULL
1413 && player_knows_extra_exist(pplayer, ptile->resource, ptile)) {
1414 plrtile->resource = ptile->resource;
1415 } else {
1416 plrtile->resource = NULL;
1417 }
1418 plrtile->owner = tile_owner(ptile);
1419 plrtile->extras_owner = extra_owner(ptile);
1420
1421 return TRUE;
1422 }
1423
1424 return FALSE;
1425}
1426
1427/**********************************************************************/
1436 void update_tile_knowledge(struct tile *ptile)
1437{
1438 if (server_state() == S_S_INITIAL) {
1439 return;
1440 }
1441
1442 /* Players */
1443 players_iterate(pplayer) {
1444 if (map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
1445 if (update_player_tile_knowledge(pplayer, ptile)) {
1446 send_tile_info(pplayer->connections, ptile, FALSE);
1447 }
1448 }
1449 } players_iterate_end;
1450
1451 /* Global observers */
1452 conn_list_iterate(game.est_connections, pconn) {
1453 struct player *pplayer = pconn->playing;
1454
1455 if (NULL == pplayer && pconn->observer) {
1456 send_tile_info(pconn->self, ptile, FALSE);
1457 }
1458 } conn_list_iterate_end;
1459}
1460
1461/**********************************************************************/
1464 void update_player_tile_last_seen(struct player *pplayer,
1465 struct tile *ptile)
1466{
1467 if (!game.server.last_updated_year) {
1468 map_get_player_tile(ptile, pplayer)->last_updated = game.info.turn;
1469 } else {
1470 map_get_player_tile(ptile, pplayer)->last_updated = game.info.year;
1471 }
1472}
1473
1474/**********************************************************************/
1482 static bool really_give_tile_info_from_player_to_player(struct player *pfrom,
1483 struct player *pdest,
1484 struct tile *ptile)
1485{
1486 if (!map_is_known_and_seen(ptile, pdest, V_MAIN)) {
1487 /* I can just hear people scream as they try to comprehend this if :).
1488 * Let me try in words:
1489 * 1) if the tile is seen by pfrom the info is sent to pdest
1490 * OR
1491 * 2) if the tile is known by pfrom AND (they have more recent info
1492 * OR it is not known by pdest)
1493 */
1494 if (map_is_known_and_seen(ptile, pfrom, V_MAIN)
1495 || (map_is_known(ptile, pfrom)
1496 && (((map_get_player_tile(ptile, pfrom)->last_updated
1497 > map_get_player_tile(ptile, pdest)->last_updated))
1498 || !map_is_known(ptile, pdest)))) {
1499 struct player_tile *from_tile, *dest_tile;
1500
1501 from_tile = map_get_player_tile(ptile, pfrom);
1502 dest_tile = map_get_player_tile(ptile, pdest);
1503 /* Update and send tile knowledge */
1504 map_set_known(ptile, pdest);
1505 dest_tile->terrain = from_tile->terrain;
1506 dbv_copy(&(dest_tile->extras), &(from_tile->extras));
1507 dest_tile->resource = from_tile->resource;
1508 dest_tile->owner = from_tile->owner;
1509 dest_tile->extras_owner = from_tile->extras_owner;
1510 dest_tile->last_updated = from_tile->last_updated;
1511 send_tile_info(pdest->connections, ptile, FALSE);
1512
1513 /* Update and send city knowledge */
1514 /* Remove outdated cities */
1515 if (dest_tile->site) {
1516 if (!from_tile->site) {
1517 /* As the city was gone on the newer from_tile
1518 it will be removed by this function */
1519 reality_check_city(pdest, ptile);
1520 } else { /* We have a dest_city. update */
1521 if (from_tile->site->identity
1522 != dest_tile->site->identity) {
1523 /* As the city was gone on the newer from_tile
1524 it will be removed by this function */
1525 reality_check_city(pdest, ptile);
1526 }
1527 }
1528 }
1529
1530 /* Set and send new city info */
1531 if (from_tile->site) {
1532 if (!dest_tile->site) {
1533 /* We cannot assign new vision site with change_playertile_site(),
1534 * since location is not yet set up for new site */
1535 dest_tile->site = vision_site_copy(from_tile->site);
1536 }
1537 /* Note that we don't care if receiver knows vision source city
1538 * or not. */
1539 send_city_info_at_tile(pdest, pdest->connections, NULL, ptile);
1540 }
1541
1542 city_map_update_tile_frozen(ptile);
1543
1544 return TRUE;
1545 }
1546 }
1547
1548 return FALSE;
1549}
1550
1551/**********************************************************************/
1555 static void really_give_map_from_player_to_player(struct player *pfrom,
1556 struct player *pdest)
1557{
1558 whole_map_iterate(&(wld.map), ptile) {
1559 really_give_tile_info_from_player_to_player(pfrom, pdest, ptile);
1560 } whole_map_iterate_end;
1561
1562 city_thaw_workers_queue();
1563 sync_cities();
1564}
1565
1566/**********************************************************************/
1575 static bool give_tile_info_from_player_to_player(struct player *pfrom,
1576 struct player *pdest,
1577 struct tile *ptile)
1578{
1579 bool updt = really_give_tile_info_from_player_to_player(pfrom, pdest, ptile);
1580
1581 players_iterate(pplayer2) {
1582 if (really_gives_vision(pdest, pplayer2)) {
1583 updt |= really_give_tile_info_from_player_to_player(pfrom, pplayer2, ptile);
1584 }
1585 } players_iterate_end;
1586
1587 return updt;
1588}
1589
1590/**********************************************************************/
1595 static void create_vision_dependencies(void)
1596{
1597 int added;
1598
1599 players_iterate(pplayer) {
1600 pplayer->server.really_gives_vision = pplayer->gives_shared_vision;
1601 } players_iterate_end;
1602
1603 /* In words: This terminates when it has run a round without adding
1604 a dependency. One loop only propagates dependencies one level deep,
1605 which is why we keep doing it as long as changes occur. */
1606 do {
1607 added = 0;
1608 players_iterate(pplayer) {
1609 players_iterate(pplayer2) {
1610 if (really_gives_vision(pplayer, pplayer2)
1611 && pplayer != pplayer2) {
1612 players_iterate(pplayer3) {
1613 if (really_gives_vision(pplayer2, pplayer3)
1614 && !really_gives_vision(pplayer, pplayer3)
1615 && pplayer != pplayer3) {
1616 BV_SET(pplayer->server.really_gives_vision, player_index(pplayer3));
1617 added++;
1618 }
1619 } players_iterate_end;
1620 }
1621 } players_iterate_end;
1622 } players_iterate_end;
1623 } while (added > 0);
1624}
1625
1626/**********************************************************************/
1629 void give_shared_vision(struct player *pfrom, struct player *pto)
1630{
1631 bv_player save_vision[player_slot_count()];
1632
1633 if (pfrom == pto) {
1634 return;
1635 }
1636
1637 if (gives_shared_vision(pfrom, pto)) {
1638 log_error("Trying to give shared vision from %s to %s, "
1639 "but that vision is already given!",
1640 player_name(pfrom), player_name(pto));
1641 return;
1642 }
1643
1644 players_iterate(pplayer) {
1645 save_vision[player_index(pplayer)] = pplayer->server.really_gives_vision;
1646 } players_iterate_end;
1647
1648 BV_SET(pfrom->gives_shared_vision, player_index(pto));
1649 create_vision_dependencies();
1650 log_debug("giving shared vision from %s to %s",
1651 player_name(pfrom), player_name(pto));
1652
1653 players_iterate(pplayer) {
1654 buffer_shared_vision(pplayer);
1655 players_iterate(pplayer2) {
1656 if (really_gives_vision(pplayer, pplayer2)
1657 && !BV_ISSET(save_vision[player_index(pplayer)],
1658 player_index(pplayer2))) {
1659 log_debug("really giving shared vision from %s to %s",
1660 player_name(pplayer), player_name(pplayer2));
1661 whole_map_iterate(&(wld.map), ptile) {
1662 const struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1663 const v_radius_t change =
1664 V_RADIUS(player_tile_own_seen(plrtile, V_MAIN),
1665 player_tile_own_seen(plrtile, V_INVIS),
1666 player_tile_own_seen(plrtile, V_SUBSURFACE));
1667
1668 if (0 < change[V_MAIN] || 0 < change[V_INVIS]) {
1669 map_change_seen(pplayer2, ptile, change,
1670 map_is_known(ptile, pplayer));
1671 }
1672 } whole_map_iterate_end;
1673
1674 /* Squares that are not seen, but which pfrom may have more recent
1675 knowledge of */
1676 really_give_map_from_player_to_player(pplayer, pplayer2);
1677 }
1678 } players_iterate_end;
1679 unbuffer_shared_vision(pplayer);
1680 } players_iterate_end;
1681
1682 if (S_S_RUNNING == server_state()) {
1683 send_player_info_c(pfrom, NULL);
1684 }
1685}
1686
1687/**********************************************************************/
1690 void remove_shared_vision(struct player *pfrom, struct player *pto)
1691{
1692 bv_player save_vision[player_slot_count()];
1693
1694 fc_assert_ret(pfrom != pto);
1695 if (!gives_shared_vision(pfrom, pto)) {
1696 log_error("Tried removing the shared vision from %s to %s, "
1697 "but it did not exist in the first place!",
1698 player_name(pfrom), player_name(pto));
1699 return;
1700 }
1701
1702 players_iterate(pplayer) {
1703 save_vision[player_index(pplayer)] = pplayer->server.really_gives_vision;
1704 } players_iterate_end;
1705
1706 log_debug("removing shared vision from %s to %s",
1707 player_name(pfrom), player_name(pto));
1708
1709 BV_CLR(pfrom->gives_shared_vision, player_index(pto));
1710 create_vision_dependencies();
1711
1712 players_iterate(pplayer) {
1713 buffer_shared_vision(pplayer);
1714 players_iterate(pplayer2) {
1715 if (!really_gives_vision(pplayer, pplayer2)
1716 && BV_ISSET(save_vision[player_index(pplayer)],
1717 player_index(pplayer2))) {
1718 log_debug("really removing shared vision from %s to %s",
1719 player_name(pplayer), player_name(pplayer2));
1720 whole_map_iterate(&(wld.map), ptile) {
1721 const struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1722 const v_radius_t change =
1723 V_RADIUS(-player_tile_own_seen(plrtile, V_MAIN),
1724 -player_tile_own_seen(plrtile, V_INVIS),
1725 -player_tile_own_seen(plrtile, V_SUBSURFACE));
1726
1727 if (0 > change[V_MAIN] || 0 > change[V_INVIS]) {
1728 map_change_seen(pplayer2, ptile, change, FALSE);
1729 }
1730 } whole_map_iterate_end;
1731 }
1732 } players_iterate_end;
1733 unbuffer_shared_vision(pplayer);
1734 } players_iterate_end;
1735
1736 if (S_S_RUNNING == server_state()) {
1737 send_player_info_c(pfrom, NULL);
1738 }
1739}
1740
1741/**********************************************************************/
1744 void enable_fog_of_war_player(struct player *pplayer)
1745{
1746 const v_radius_t radius_sq = V_RADIUS(-1, 0, 0);
1747
1748 buffer_shared_vision(pplayer);
1749 whole_map_iterate(&(wld.map), ptile) {
1750 map_change_seen(pplayer, ptile, radius_sq, FALSE);
1751 } whole_map_iterate_end;
1752 unbuffer_shared_vision(pplayer);
1753}
1754
1755/**********************************************************************/
1758 void enable_fog_of_war(void)
1759{
1760 players_iterate(pplayer) {
1761 enable_fog_of_war_player(pplayer);
1762 } players_iterate_end;
1763}
1764
1765/**********************************************************************/
1768 void disable_fog_of_war_player(struct player *pplayer)
1769{
1770 const v_radius_t radius_sq = V_RADIUS(1, 0, 0);
1771
1772 buffer_shared_vision(pplayer);
1773 whole_map_iterate(&(wld.map), ptile) {
1774 map_change_seen(pplayer, ptile, radius_sq, FALSE);
1775 } whole_map_iterate_end;
1776 unbuffer_shared_vision(pplayer);
1777}
1778
1779/**********************************************************************/
1782 void disable_fog_of_war(void)
1783{
1784 players_iterate(pplayer) {
1785 disable_fog_of_war_player(pplayer);
1786 } players_iterate_end;
1787}
1788
1789/**********************************************************************/
1798 static void ocean_to_land_fix_rivers(struct tile *ptile)
1799{
1800 cardinal_adjc_iterate(&(wld.map), ptile, tile1) {
1801 bool ocean_near = FALSE;
1802
1803 cardinal_adjc_iterate(&(wld.map), tile1, tile2) {
1804 if (is_ocean_tile(tile2))
1805 ocean_near = TRUE;
1806 } cardinal_adjc_iterate_end;
1807
1808 if (!ocean_near) {
1809 /* If ruleset has several river types defined, this
1810 * may cause same tile to contain more than one river. */
1811 extra_type_by_cause_iterate(EC_ROAD, priver) {
1812 if (tile_has_extra(tile1, priver)
1813 && road_has_flag(extra_road_get(priver), RF_RIVER)) {
1814 tile_add_extra(ptile, priver);
1815 }
1816 } extra_type_by_cause_iterate_end;
1817 }
1818 } cardinal_adjc_iterate_end;
1819}
1820
1821/**********************************************************************/
1824 static void terrain_change_bounce_single_unit(struct unit *punit,
1825 struct tile *from)
1826{
1827 bool unit_alive = TRUE;
1828
1829 /* Look for a nearby safe tile */
1830 adjc_iterate(&(wld.map), from, ptile2) {
1831 if (can_unit_exist_at_tile(&(wld.map), punit, ptile2)
1832 && !is_non_allied_unit_tile(ptile2, unit_owner(punit))
1833 && !is_non_allied_city_tile(ptile2, unit_owner(punit))) {
1834 log_verbose("Moved %s %s due to changing terrain at (%d,%d).",
1835 nation_rule_name(nation_of_unit(punit)),
1836 unit_rule_name(punit), TILE_XY(unit_tile(punit)));
1837 notify_player(unit_owner(punit), unit_tile(punit),
1838 E_UNIT_RELOCATED, ftc_server,
1839 _("Moved your %s due to changing terrain."),
1840 unit_link(punit));
1841
1842 /* TODO: should a unit be able to bounce to a transport like is
1843 * done below? What if the unit can't legally enter the transport,
1844 * say because the transport is Unreachable and the unit doesn't
1845 * have it in its embarks field or because "Transport Embark"
1846 * isn't enabled? Kept like it was to preserve the old rules for
1847 * now. -- Sveinung */
1848 unit_alive = unit_move(punit, ptile2, 0,
1849 NULL, TRUE, FALSE, FALSE, FALSE, FALSE);
1850 if (unit_alive && punit->activity == ACTIVITY_SENTRY) {
1851 unit_activity_handling(punit, ACTIVITY_IDLE);
1852 }
1853 break;
1854 }
1855 } adjc_iterate_end;
1856
1857 if (unit_alive && unit_tile(punit) == from) {
1858 /* If we get here we could not move punit. */
1859
1860 /* Try to bounce transported units. */
1861 if (0 < get_transporter_occupancy(punit)) {
1862 struct unit_list *pcargo_units;
1863
1864 pcargo_units = unit_transport_cargo(punit);
1865 unit_list_iterate_safe(pcargo_units, pcargo) {
1866 terrain_change_bounce_single_unit(pcargo, from);
1867 } unit_list_iterate_safe_end;
1868 }
1869 }
1870}
1871
1872/**********************************************************************/
1876 static void check_units_single_tile(struct tile *ptile)
1877{
1878 unit_list_iterate_safe(ptile->units, punit) {
1879 int id = punit->id;
1880
1881 /* Top-level transports only. Each handle their own cargo */
1882 if (!unit_transported(punit)
1883 && !can_unit_exist_at_tile(&(wld.map), punit, ptile)) {
1884 terrain_change_bounce_single_unit(punit, ptile);
1885
1886 if (unit_is_alive(id) && unit_tile(punit) == ptile) {
1887 log_verbose("Disbanded %s %s due to changing land "
1888 " to sea at (%d, %d).",
1889 nation_rule_name(nation_of_unit(punit)),
1890 unit_rule_name(punit), TILE_XY(unit_tile(punit)));
1891 notify_player(unit_owner(punit), unit_tile(punit),
1892 E_UNIT_LOST_MISC, ftc_server,
1893 _("Disbanded your %s due to changing terrain."),
1894 unit_tile_link(punit));
1895 wipe_unit(punit, ULR_NONNATIVE_TERR, NULL);
1896 }
1897 }
1898 } unit_list_iterate_safe_end;
1899}
1900
1901/**********************************************************************/
1906 void bounce_units_on_terrain_change(struct tile *ptile)
1907{
1908 /* Check this tile for direct effect on its units */
1909 check_units_single_tile(ptile);
1910 /* We have to check adjacent tiles too, in case units in cities are now
1911 * illegal (e.g., boat in a city that has become landlocked). */
1912 adjc_iterate(&(wld.map), ptile, ptile2) {
1913 check_units_single_tile(ptile2);
1914 } adjc_iterate_end;
1915}
1916
1917/**********************************************************************/
1921 bool need_to_reassign_continents(const struct terrain *oldter,
1922 const struct terrain *newter)
1923{
1924 bool old_is_ocean, new_is_ocean;
1925
1926 if (!oldter || !newter) {
1927 return FALSE;
1928 }
1929
1930 old_is_ocean = is_ocean(oldter);
1931 new_is_ocean = is_ocean(newter);
1932
1933 return (old_is_ocean && !new_is_ocean)
1934 || (!old_is_ocean && new_is_ocean);
1935}
1936
1937/**********************************************************************/
1940 void terrain_changed(struct tile *ptile)
1941{
1942 struct city *pcity = tile_city(ptile);
1943
1944 if (pcity != NULL) {
1945 /* Tile is city center and new terrain may support better extras. */
1946 upgrade_city_extras(pcity, NULL);
1947 }
1948
1949 bounce_units_on_terrain_change(ptile);
1950}
1951
1952/**********************************************************************/
1959 void fix_tile_on_terrain_change(struct tile *ptile,
1960 struct terrain *oldter,
1961 bool extend_rivers)
1962{
1963 if (is_ocean(oldter) && !is_ocean_tile(ptile)) {
1964 if (extend_rivers) {
1965 ocean_to_land_fix_rivers(ptile);
1966 }
1967 city_landlocked_sell_coastal_improvements(ptile);
1968 }
1969
1970 terrain_changed(ptile);
1971}
1972
1973/**********************************************************************/
1979 void check_terrain_change(struct tile *ptile, struct terrain *oldter)
1980{
1981 struct terrain *newter = tile_terrain(ptile);
1982 struct tile *claimer;
1983 bool cont_reassigned = FALSE;
1984
1985 /* Check if new terrain is a freshwater terrain next to non-freshwater.
1986 * In that case, the new terrain is *changed*. */
1987 if (is_ocean(newter) && terrain_has_flag(newter, TER_FRESHWATER)) {
1988 bool nonfresh = FALSE;
1989
1990 adjc_iterate(&(wld.map), ptile, atile) {
1991 if (is_ocean(tile_terrain(atile))
1992 && !terrain_has_flag(tile_terrain(atile), TER_FRESHWATER)) {
1993 nonfresh = TRUE;
1994 break;
1995 }
1996 } adjc_iterate_end;
1997 if (nonfresh) {
1998 /* Need to pick a new, non-freshwater ocean type for this tile.
1999 * We don't want e.g. Deep Ocean to be propagated to this tile
2000 * and then to a whole lake by the flooding below, so we pick
2001 * the shallowest non-fresh oceanic type.
2002 * Prefer terrain that matches the frozenness of the target. */
2003 newter = most_shallow_ocean(terrain_has_flag(newter, TER_FROZEN));
2004 tile_change_terrain(ptile, newter);
2005 }
2006 }
2007
2008 if (need_to_reassign_continents(oldter, newter)) {
2009 assign_continent_numbers();
2010 cont_reassigned = TRUE;
2011
2012 phase_players_iterate(pplayer) {
2013 if (is_adv_data_phase_open(pplayer)) {
2014 /* Player is using continent numbers that they would assume to remain accurate.
2015 * Force refresh:
2016 * 1) Close the phase, so that it can be opened
2017 * 2) Open the phase, recalculating
2018 */
2019 adv_data_phase_done(pplayer);
2020 adv_data_phase_init(pplayer, FALSE);
2021 }
2022 } phase_players_iterate_end;
2023 }
2024
2025 fix_tile_on_terrain_change(ptile, oldter, TRUE);
2026
2027 /* Check for saltwater filling freshwater lake */
2028 if (game.scenario.lake_flooding
2029 && is_ocean(newter) && !terrain_has_flag(newter, TER_FRESHWATER)) {
2030 adjc_iterate(&(wld.map), ptile, atile) {
2031 if (terrain_has_flag(tile_terrain(atile), TER_FRESHWATER)) {
2032 struct terrain *aold = tile_terrain(atile);
2033
2034 tile_change_terrain(atile,
2035 most_shallow_ocean(terrain_has_flag(aold,
2036 TER_FROZEN)));
2037
2038 /* Recursive, but as lakes are of limited size, this
2039 * won't recurse so much as to cause stack problems. */
2040 check_terrain_change(atile, aold);
2041 update_tile_knowledge(atile);
2042 }
2043 } adjc_iterate_end;
2044 }
2045
2046 if (cont_reassigned) {
2047 send_all_known_tiles(NULL);
2048 }
2049
2050 claimer = tile_claimer(ptile);
2051 if (claimer != NULL && is_ocean_tile(ptile)) {
2052 if (!is_claimable_ocean(ptile, claimer, tile_owner(ptile))) {
2053 map_clear_border(ptile);
2054 }
2055 }
2056
2057 sanity_check_tile(ptile);
2058}
2059
2060/**********************************************************************/
2071 static bool is_claimable_ocean(struct tile *ptile, struct tile *source,
2072 struct player *pplayer)
2073{
2074 Continent_id cont = tile_continent(ptile);
2075 Continent_id cont1 = tile_continent(source);
2076 Continent_id cont2;
2077 int ocean_tiles;
2078 bool other_continent;
2079
2080 if (get_ocean_size(-cont) <= MAXIMUM_CLAIMED_OCEAN_SIZE
2081 && get_lake_surrounders(cont) == cont1) {
2082 return TRUE;
2083 }
2084
2085 if (ptile == source) {
2086 /* Source itself is always claimable. */
2087 return TRUE;
2088 }
2089
2090 if (num_known_tech_with_flag(pplayer, TF_CLAIM_OCEAN) > 0
2091 || (cont1 < 0 && num_known_tech_with_flag(pplayer, TF_CLAIM_OCEAN_LIMITED) > 0)) {
2092 return TRUE;
2093 }
2094
2095 ocean_tiles = 0;
2096 other_continent = FALSE;
2097 adjc_iterate(&(wld.map), ptile, tile2) {
2098 cont2 = tile_continent(tile2);
2099 if (tile2 == source) {
2100 /* Water next to border source is always claimable */
2101 return TRUE;
2102 }
2103 if (cont2 == cont) {
2104 ocean_tiles++;
2105 } else if (cont1 <= 0) {
2106 /* First adjacent land (only if border source is not on land) */
2107 cont1 = cont2;
2108 } else if (cont2 != cont1) {
2109 /* This water has two land continents adjacent, or land adjacent
2110 * that is of a different continent from the border source */
2111 other_continent = TRUE;
2112 }
2113 } adjc_iterate_end;
2114 if (!other_continent && ocean_tiles <= 2) {
2115 return TRUE;
2116 } else {
2117 return FALSE;
2118 }
2119}
2120
2121/**********************************************************************/
2124 static void map_unit_homecity_enqueue(struct tile *ptile)
2125{
2126 unit_list_iterate(ptile->units, punit) {
2127 struct city *phome = game_city_by_number(punit->homecity);
2128
2129 if (NULL == phome) {
2130 continue;
2131 }
2132
2133 city_refresh_queue_add(phome);
2134 } unit_list_iterate_end;
2135}
2136
2137/**********************************************************************/
2140 static void map_claim_border_ownership(struct tile *ptile,
2141 struct player *powner,
2142 struct tile *psource)
2143{
2144 struct player *ploser = tile_owner(ptile);
2145
2146 if ((ploser != powner && ploser != NULL)
2147 && (BORDERS_SEE_INSIDE == game.info.borders
2148 || BORDERS_EXPAND == game.info.borders
2149 || ploser->server.border_vision)) {
2150 const v_radius_t radius_sq = V_RADIUS(-1, 0, 0);
2151
2152 shared_vision_change_seen(ploser, ptile, radius_sq, FALSE);
2153 }
2154
2155 if (powner != NULL
2156 && (BORDERS_SEE_INSIDE == game.info.borders
2157 || BORDERS_EXPAND == game.info.borders
2158 || powner->server.border_vision)) {
2159 const v_radius_t radius_sq = V_RADIUS(1, 0, 0);
2160
2161 shared_vision_change_seen(powner, ptile, radius_sq, TRUE);
2162 }
2163
2164 tile_set_owner(ptile, powner, psource);
2165
2166 /* Needed only when foggedborders enabled, but we do it unconditionally
2167 * in case foggedborders ever gets enabled later. Better to have correct
2168 * information in player map just in case. */
2169 update_tile_knowledge(ptile);
2170
2171 if (ploser != powner) {
2172 if (S_S_RUNNING == server_state() && game.info.happyborders != HB_DISABLED) {
2173 map_unit_homecity_enqueue(ptile);
2174 }
2175
2176 if (!city_map_update_tile_frozen(ptile)) {
2177 send_tile_info(NULL, ptile, FALSE);
2178 }
2179 }
2180}
2181
2182/**********************************************************************/
2185 void map_claim_ownership(struct tile *ptile, struct player *powner,
2186 struct tile *psource, bool claim_bases)
2187{
2188 map_claim_border_ownership(ptile, powner, psource);
2189
2190 if (claim_bases) {
2191 tile_claim_bases(ptile, powner);
2192 }
2193}
2194
2195/**********************************************************************/
2198 void tile_claim_bases(struct tile *ptile, struct player *powner)
2199{
2200 struct player *base_loser = extra_owner(ptile);
2201
2202 /* This MUST be before potentially recursive call to map_claim_base(),
2203 * so that the recursive call will get new owner == base_loser and
2204 * abort recursion. */
2205 ptile->extras_owner = powner;
2206
2207 extra_type_by_cause_iterate(EC_BASE, pextra) {
2208 map_claim_base(ptile, pextra, powner, base_loser);
2209 } extra_type_by_cause_iterate_end;
2210}
2211
2212/**********************************************************************/
2215 void map_clear_border(struct tile *ptile)
2216{
2217 int radius_sq = tile_border_source_radius_sq(ptile);
2218
2219 circle_dxyr_iterate(&(wld.map), ptile, radius_sq, dtile, dx, dy, dr) {
2220 struct tile *claimer = tile_claimer(dtile);
2221
2222 if (claimer == ptile) {
2223 map_claim_ownership(dtile, NULL, NULL, FALSE);
2224 }
2225 } circle_dxyr_iterate_end;
2226}
2227
2228/**********************************************************************/
2232 void map_update_border(struct tile *ptile, struct player *owner,
2233 int old_radius_sq, int new_radius_sq)
2234{
2235 if (old_radius_sq == new_radius_sq) {
2236 /* No change */
2237 return;
2238 }
2239
2240 if (BORDERS_DISABLED == game.info.borders) {
2241 return;
2242 }
2243
2244 if (old_radius_sq < new_radius_sq) {
2245 map_claim_border(ptile, owner, new_radius_sq);
2246 } else {
2247 circle_dxyr_iterate(&(wld.map), ptile, old_radius_sq, dtile, dx, dy, dr) {
2248 if (dr > new_radius_sq) {
2249 struct tile *claimer = tile_claimer(dtile);
2250
2251 if (claimer == ptile) {
2252 map_claim_ownership(dtile, NULL, NULL, FALSE);
2253 }
2254 }
2255 } circle_dxyr_iterate_end;
2256 }
2257}
2258
2259/**********************************************************************/
2264 void map_claim_border(struct tile *ptile, struct player *owner,
2265 int radius_sq)
2266{
2267 if (BORDERS_DISABLED == game.info.borders) {
2268 return;
2269 }
2270
2271 if (owner == NULL) {
2272 /* Clear the border instead of claiming. Code below this block
2273 * cannot handle NULL owner. */
2274 map_clear_border(ptile);
2275
2276 return;
2277 }
2278
2279 if (radius_sq < 0) {
2280 radius_sq = tile_border_source_radius_sq(ptile);
2281 }
2282
2283 circle_dxyr_iterate(&(wld.map), ptile, radius_sq, dtile, dx, dy, dr) {
2284 struct tile *dclaimer = tile_claimer(dtile);
2285
2286 if (dclaimer == ptile) {
2287 /* Already claimed by the ptile */
2288 continue;
2289 }
2290
2291 if (dr != 0 && is_border_source(dtile)) {
2292 /* Do not claim border sources other than self */
2293 /* Note that this is extremely important at the moment for
2294 * base claiming to work correctly in case there's two
2295 * fortresses near each other. There could be infinite
2296 * recursion in them claiming each other. */
2297 continue;
2298 }
2299
2300 if (!map_is_known(dtile, owner) && game.info.borders < BORDERS_EXPAND) {
2301 continue;
2302 }
2303
2304 /* Always claim source itself (distance, dr, to it 0) */
2305 if (dr != 0 && NULL != dclaimer && dclaimer != ptile) {
2306 struct city *ccity = tile_city(dclaimer);
2307 int strength_old, strength_new;
2308
2309 if (ccity != NULL) {
2310 /* Previously claimed by city */
2311 int city_x, city_y;
2312
2313 map_distance_vector(&city_x, &city_y, ccity->tile, dtile);
2314
2315 if (map_vector_to_sq_distance(city_x, city_y)
2316 <= city_map_radius_sq_get(ccity)
2317 + game.info.border_city_permanent_radius_sq) {
2318 /* Tile is within region permanently claimed by city */
2319 continue;
2320 }
2321 }
2322
2323 strength_old = tile_border_strength(dtile, dclaimer);
2324 strength_new = tile_border_strength(dtile, ptile);
2325
2326 if (strength_new <= strength_old) {
2327 /* Stronger shall prevail,
2328 * in case of equal strength older shall prevail */
2329 continue;
2330 }
2331 }
2332
2333 if (is_ocean_tile(dtile)) {
2334 /* Only certain water tiles are claimable */
2335 if (is_claimable_ocean(dtile, ptile, owner)) {
2336 map_claim_ownership(dtile, owner, ptile, dr == 0);
2337 }
2338 } else {
2339 /* Only land tiles on the same island as the border source
2340 * are claimable */
2341 if (tile_continent(dtile) == tile_continent(ptile)) {
2342 map_claim_ownership(dtile, owner, ptile, dr == 0);
2343 }
2344 }
2345 } circle_dxyr_iterate_end;
2346}
2347
2348/**********************************************************************/
2351 void map_calculate_borders(void)
2352{
2353 if (BORDERS_DISABLED == game.info.borders) {
2354 return;
2355 }
2356
2357 if (wld.map.tiles == NULL) {
2358 /* Map not yet initialized */
2359 return;
2360 }
2361
2362 log_verbose("map_calculate_borders()");
2363
2364 whole_map_iterate(&(wld.map), ptile) {
2365 if (is_border_source(ptile)) {
2366 map_claim_border(ptile, ptile->owner, -1);
2367 }
2368 } whole_map_iterate_end;
2369
2370 log_verbose("map_calculate_borders() workers");
2371 city_thaw_workers_queue();
2372 city_refresh_queue_processing();
2373}
2374
2375/**********************************************************************/
2378 void map_claim_base(struct tile *ptile, struct extra_type *pextra,
2379 struct player *powner, struct player *ploser)
2380{
2381 struct base_type *pbase;
2382 bv_player *could_see_unit = NULL;
2383 int units_num = 0;
2384 int ul_size;
2385
2386 if (!tile_has_extra(ptile, pextra)) {
2387 return;
2388 }
2389
2390 if (pextra->eus != EUS_NORMAL) {
2391 ul_size = unit_list_size(ptile->units);
2392 } else {
2393 ul_size = 0;
2394 }
2395
2396 int stored_units[ul_size + 1];
2397
2398 if (ul_size > 0) {
2399 int i;
2400
2401 could_see_unit = fc_malloc(sizeof(*could_see_unit) * ul_size);
2402
2403 unit_list_iterate(ptile->units, aunit) {
2404 stored_units[units_num++] = aunit->id;
2405 } unit_list_iterate_end;
2406
2407 fc_assert(units_num == ul_size);
2408
2409 for (i = 0; i < units_num; i++) {
2410 struct unit *aunit = game_unit_by_number(stored_units[i]);
2411
2412 BV_CLR_ALL(could_see_unit[i]);
2413 players_iterate(aplayer) {
2414 if (can_player_see_unit(aplayer, aunit)) {
2415 BV_SET(could_see_unit[i], player_index(aplayer));
2416 }
2417 } players_iterate_end;
2418 }
2419 }
2420
2421 pbase = extra_base_get(pextra);
2422
2423 fc_assert_ret(pbase != NULL);
2424
2425 /* Transfer base provided vision to new owner */
2426 if (powner != NULL) {
2427 const v_radius_t old_radius_sq = V_RADIUS(-1, -1, -1);
2428 const v_radius_t new_radius_sq = V_RADIUS(pbase->vision_main_sq,
2429 pbase->vision_invis_sq,
2430 pbase->vision_subs_sq);
2431
2432 map_vision_update(powner, ptile, old_radius_sq, new_radius_sq,
2433 game.server.vision_reveal_tiles);
2434 }
2435
2436 if (ploser != NULL) {
2437 const v_radius_t old_radius_sq = V_RADIUS(pbase->vision_main_sq,
2438 pbase->vision_invis_sq,
2439 pbase->vision_subs_sq);
2440 const v_radius_t new_radius_sq = V_RADIUS(-1, -1, -1);
2441
2442 map_vision_update(ploser, ptile, old_radius_sq, new_radius_sq,
2443 game.server.vision_reveal_tiles);
2444 }
2445
2446 if (BORDERS_DISABLED != game.info.borders
2447 && territory_claiming_base(pbase) && powner != ploser) {
2448 /* Clear borders from old owner. New owner may not know all those
2449 * tiles and thus does not claim them when borders mode is less
2450 * than EXPAND. */
2451 if (ploser != NULL) {
2452 /* Set this particular tile owner by NULL so in recursion
2453 * both loser and owner will be NULL. */
2454 map_claim_border_ownership(ptile, NULL, ptile);
2455 map_clear_border(ptile);
2456 }
2457
2458 /* We here first claim this tile ownership -> now on extra_owner()
2459 * will return new owner. Then we claim border, which will recursively
2460 * lead to this tile and base being claimed. But at that point
2461 * ploser == powner and above check will abort the recursion. */
2462 if (powner != NULL) {
2463 map_claim_border_ownership(ptile, powner, ptile);
2464 map_claim_border(ptile, powner, -1);
2465 }
2466 city_thaw_workers_queue();
2467 city_refresh_queue_processing();
2468 }
2469
2470 if (units_num > 0) {
2471 int i;
2472
2473 for (i = 0; i < units_num; i++) {
2474 struct unit *aunit = game_unit_by_number(stored_units[i]);
2475
2476 players_iterate(aplayer) {
2477 if (can_player_see_unit(aplayer, aunit)) {
2478 if (!BV_ISSET(could_see_unit[i], player_index(aplayer))) {
2479 send_unit_info(aplayer->connections, aunit);
2480 }
2481 } else {
2482 if (BV_ISSET(could_see_unit[i], player_index(aplayer))) {
2483 unit_goes_out_of_sight(aplayer, aunit);
2484 }
2485 }
2486 } players_iterate_end;
2487 }
2488
2489 free(could_see_unit);
2490 }
2491}
2492
2493/**********************************************************************/
2499 void vision_change_sight(struct vision *vision, const v_radius_t radius_sq)
2500{
2501 map_vision_update(vision->player, vision->tile, vision->radius_sq,
2502 radius_sq, vision->can_reveal_tiles);
2503 memcpy(vision->radius_sq, radius_sq, sizeof(v_radius_t));
2504}
2505
2506/**********************************************************************/
2511 void vision_clear_sight(struct vision *vision)
2512{
2513 const v_radius_t vision_radius_sq = V_RADIUS(-1, -1, -1);
2514
2515 vision_change_sight(vision, vision_radius_sq);
2516}
2517
2518/**********************************************************************/
2521 void create_extra(struct tile *ptile, struct extra_type *pextra,
2522 struct player *pplayer)
2523{
2524 bool extras_removed = FALSE;
2525
2526 extra_type_iterate(old_extra) {
2527 if (tile_has_extra(ptile, old_extra)
2528 && !can_extras_coexist(old_extra, pextra)) {
2529 destroy_extra(ptile, old_extra);
2530 extras_removed = TRUE;
2531 }
2532 } extra_type_iterate_end;
2533
2534 if (pextra->eus != EUS_NORMAL) {
2535 unit_list_iterate(ptile->units, aunit) {
2536 if (is_native_extra_to_utype(pextra, unit_type_get(aunit))) {
2537 players_iterate(aplayer) {
2538 if (!pplayers_allied(pplayer, aplayer)
2539 && can_player_see_unit(aplayer, aunit)) {
2540 unit_goes_out_of_sight(aplayer, aunit);
2541 }
2542 } players_iterate_end;
2543 }
2544 } unit_list_iterate_end;
2545 }
2546
2547 tile_add_extra(ptile, pextra);
2548
2549 /* Watchtower might become effective. */
2550 unit_list_refresh_vision(ptile->units);
2551
2552 if (pextra->data.base != NULL) {
2553 /* Claim bases on tile */
2554 if (pplayer) {
2555 struct player *old_owner = extra_owner(ptile);
2556
2557 /* Created base from NULL -> pplayer */
2558 map_claim_base(ptile, pextra, pplayer, NULL);
2559
2560 if (old_owner != pplayer) {
2561 /* Existing bases from old_owner -> pplayer */
2562 extra_type_by_cause_iterate(EC_BASE, oldbase) {
2563 if (oldbase != pextra) {
2564 map_claim_base(ptile, oldbase, pplayer, old_owner);
2565 }
2566 } extra_type_by_cause_iterate_end;
2567
2568 ptile->extras_owner = pplayer;
2569 }
2570 } else {
2571 /* Player who already owns bases on tile claims new base */
2572 map_claim_base(ptile, pextra, extra_owner(ptile), NULL);
2573 }
2574 }
2575
2576 if (extras_removed) {
2577 /* Maybe conflicting extra that was removed was the only thing
2578 * making tile native to some unit. */
2579 bounce_units_on_terrain_change(ptile);
2580 }
2581}
2582
2583/**********************************************************************/
2586 void destroy_extra(struct tile *ptile, struct extra_type *pextra)
2587{
2588 bv_player base_seen;
2589 bool real = tile_map_check(&(wld.map), ptile);
2590
2591 /* Remember what players were able to see the base. */
2592 if (real) {
2593 BV_CLR_ALL(base_seen);
2594 players_iterate(pplayer) {
2595 if (map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
2596 BV_SET(base_seen, player_index(pplayer));
2597 }
2598 } players_iterate_end;
2599 }
2600
2601 if (real && is_extra_caused_by(pextra, EC_BASE)) {
2602 struct base_type *pbase = extra_base_get(pextra);
2603 struct player *owner = extra_owner(ptile);
2604
2605 if (territory_claiming_base(pbase)) {
2606 map_clear_border(ptile);
2607 }
2608
2609 if (NULL != owner
2610 && (0 <= pbase->vision_main_sq || 0 <= pbase->vision_invis_sq)) {
2611 /* Base provides vision, but no borders. */
2612 const v_radius_t old_radius_sq =
2613 V_RADIUS(0 <= pbase->vision_main_sq ? pbase->vision_main_sq : -1,
2614 0 <= pbase->vision_invis_sq ? pbase->vision_invis_sq : -1,
2615 0 <= pbase->vision_subs_sq ? pbase->vision_subs_sq : -1);
2616 const v_radius_t new_radius_sq = V_RADIUS(-1, -1, -1);
2617
2618 map_vision_update(owner, ptile, old_radius_sq, new_radius_sq,
2619 game.server.vision_reveal_tiles);
2620 }
2621 }
2622
2623 tile_remove_extra(ptile, pextra);
2624
2625 if (real) {
2626 /* Remove base from vision of players which were able to see the base. */
2627 players_iterate(pplayer) {
2628 if (BV_ISSET(base_seen, player_index(pplayer))
2629 && update_player_tile_knowledge(pplayer, ptile)) {
2630 send_tile_info(pplayer->connections, ptile, FALSE);
2631 }
2632 } players_iterate_end;
2633
2634 if (pextra->eus != EUS_NORMAL) {
2635 struct player *eowner = extra_owner(ptile);
2636
2637 unit_list_iterate(ptile->units, aunit) {
2638 if (is_native_extra_to_utype(pextra, unit_type_get(aunit))) {
2639 players_iterate(aplayer) {
2640 if (can_player_see_unit(aplayer, aunit)
2641 && !pplayers_allied(aplayer, eowner)) {
2642 send_unit_info(aplayer->connections, aunit);
2643 }
2644 } players_iterate_end;
2645 }
2646 } unit_list_iterate_end;
2647 }
2648 }
2649}
2650
2651/**********************************************************************/
2661 bool give_distorted_map(struct player *pfrom, struct player *pto,
2662 int prob, bool reveal_cities)
2663{
2664 bool updt = FALSE;
2665
2666 buffer_shared_vision(pto);
2667
2668 whole_map_iterate(&(wld.map), ptile) {
2669 if (fc_rand(100) < prob) {
2670 updt |= give_tile_info_from_player_to_player(pfrom, pto, ptile);
2671 } else if (reveal_cities && NULL != tile_city(ptile)) {
2672 updt|= give_tile_info_from_player_to_player(pfrom, pto, ptile);
2673 }
2674 } whole_map_iterate_end;
2675
2676 unbuffer_shared_vision(pto);
2677
2678 return updt;
2679}
2680
2681/**********************************************************************/
2689 void tile_change_side_effects(struct tile *ptile, bool refresh_city)
2690{
2691 struct city *pcity = ptile->worked;
2692
2693 /* Check the unit activities. */
2694 unit_activities_cancel_all_illegal_area(ptile);
2695
2696 if (pcity != NULL && !is_free_worked(pcity, ptile)
2697 && get_city_tile_output_bonus(pcity, ptile, NULL, EFT_TILE_WORKABLE) <= 0) {
2698 city_map_update_empty(pcity, ptile);
2699 pcity->specialists[DEFAULT_SPECIALIST]++;
2700
2701 if (refresh_city) {
2702 auto_arrange_workers(pcity);
2703 send_city_info(NULL, pcity);
2704 }
2705 }
2706}
is_adv_data_phase_open
bool is_adv_data_phase_open(struct player *pplayer)
Definition advdata.c:243
adv_data_phase_init
bool adv_data_phase_init(struct player *pplayer, bool is_new_phase)
Definition advdata.c:263
adv_data_phase_done
void adv_data_phase_done(struct player *pplayer)
Definition advdata.c:565
advdata.h
ai.h
CALL_FUNC_EACH_AI
#define CALL_FUNC_EACH_AI(_func,...)
Definition ai.h:384
territory_claiming_base
bool territory_claiming_base(const struct base_type *pbase)
Definition base.c:158
base.h
bv_match_dbv
bool bv_match_dbv(const struct dbv *match, const unsigned char *src)
Definition bitvector.c:205
dbv_init
void dbv_init(struct dbv *pdbv, int bits)
Definition bitvector.c:50
dbv_set
void dbv_set(struct dbv *pdbv, int bit)
Definition bitvector.c:144
dbv_isset
bool dbv_isset(const struct dbv *pdbv, int bit)
Definition bitvector.c:120
dbv_copy
void dbv_copy(struct dbv *dest, const struct dbv *src)
Definition bitvector.c:222
dbv_free
void dbv_free(struct dbv *pdbv)
Definition bitvector.c:95
dbv_clr
void dbv_clr(struct dbv *pdbv, int bit)
Definition bitvector.c:167
dbv_to_bv
void dbv_to_bv(unsigned char *dest, const struct dbv *src)
Definition bitvector.c:235
bitvector.h
BV_CLR_ALL
#define BV_CLR_ALL(bv)
Definition bitvector.h:95
BV_SET
#define BV_SET(bv, bit)
Definition bitvector.h:81
BV_ISSET
#define BV_ISSET(bv, bit)
Definition bitvector.h:78
BV_CLR
#define BV_CLR(bv, bit)
Definition bitvector.h:86
tile_border_source_radius_sq
int tile_border_source_radius_sq(struct tile *ptile)
Definition borders.c:33
is_border_source
bool is_border_source(struct tile *ptile)
Definition borders.c:116
tile_border_strength
int tile_border_strength(struct tile *ptile, struct tile *source)
Definition borders.c:101
borders.h
is_free_worked
bool is_free_worked(const struct city *pcity, const struct tile *ptile)
Definition city.c:3589
city_map_radius_sq_get
int city_map_radius_sq_get(const struct city *pcity)
Definition city.c:136
is_non_allied_city_tile
static bool is_non_allied_city_tile(const struct tile *ptile, const struct player *pplayer)
Definition city.h:762
city_list_iterate
#define city_list_iterate(citylist, pcity)
Definition city.h:508
city_tile
#define city_tile(_pcity_)
Definition city.h:564
city_owner
#define city_owner(_pcity_)
Definition city.h:563
city_list_iterate_end
#define city_list_iterate_end
Definition city.h:510
city_tile_iterate
#define city_tile_iterate(_nmap, _radius_sq, _city_tile, _tile)
Definition city.h:230
city_tile_iterate_end
#define city_tile_iterate_end
Definition city.h:238
city_map_update_empty
void city_map_update_empty(struct city *pcity, struct tile *ptile)
Definition citytools.c:3239
send_city_info
void send_city_info(struct player *dest, struct city *pcity)
Definition citytools.c:2343
update_dumb_city
bool update_dumb_city(struct player *pplayer, struct city *pcity)
Definition citytools.c:2740
sync_cities
void sync_cities(void)
Definition citytools.c:3313
city_map_update_tile_frozen
bool city_map_update_tile_frozen(struct tile *ptile)
Definition citytools.c:3296
remove_dumb_city
void remove_dumb_city(struct player *pplayer, struct tile *ptile)
Definition citytools.c:2832
city_landlocked_sell_coastal_improvements
void city_landlocked_sell_coastal_improvements(struct tile *ptile)
Definition citytools.c:3366
send_city_info_at_tile
void send_city_info_at_tile(struct player *pviewer, struct conn_list *dest, struct city *pcity, struct tile *ptile)
Definition citytools.c:2395
city_thaw_workers_queue
void city_thaw_workers_queue(void)
Definition citytools.c:193
reality_check_city
void reality_check_city(struct player *pplayer, struct tile *ptile)
Definition citytools.c:2811
citytools.h
auto_arrange_workers
void auto_arrange_workers(struct city *pcity)
Definition cityturn.c:366
city_refresh_queue_add
void city_refresh_queue_add(struct city *pcity)
Definition cityturn.c:197
city_refresh_queue_processing
void city_refresh_queue_processing(void)
Definition cityturn.c:213
cityturn.h
incite_cost
char * incite_cost
Definition comments.c:74
conn_list_do_unbuffer
void conn_list_do_unbuffer(struct conn_list *dest)
Definition connection.c:366
conn_list_compression_thaw
void conn_list_compression_thaw(const struct conn_list *pconn_list)
Definition connection.c:732
conn_list_do_buffer
void conn_list_do_buffer(struct conn_list *dest)
Definition connection.c:356
conn_list_compression_freeze
void conn_list_compression_freeze(const struct conn_list *pconn_list)
Definition connection.c:720
conn_list_iterate
#define conn_list_iterate(connlist, pconn)
Definition connection.h:108
conn_list_iterate_end
#define conn_list_iterate_end
Definition connection.h:110
punit
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
get_city_tile_output_bonus
int get_city_tile_output_bonus(const struct city *pcity, const struct tile *ptile, const struct output_type *poutput, enum effect_type effect_type)
Definition effects.c:916
events.h
extra_owner
struct player * extra_owner(const struct tile *ptile)
Definition extras.c:1114
extra_number
int extra_number(const struct extra_type *pextra)
Definition extras.c:161
extra_has_flag
bool extra_has_flag(const struct extra_type *pextra, enum extra_flag_id flag)
Definition extras.c:861
player_can_build_extra
bool player_can_build_extra(const struct extra_type *pextra, const struct player *pplayer, const struct tile *ptile)
Definition extras.c:468
extras
static struct extra_type extras[MAX_EXTRA_TYPES]
Definition extras.c:31
is_native_extra_to_utype
bool is_native_extra_to_utype(const struct extra_type *pextra, const struct unit_type *punittype)
Definition extras.c:852
can_extras_coexist
bool can_extras_coexist(const struct extra_type *pextra1, const struct extra_type *pextra2)
Definition extras.c:1003
extra_count
int extra_count(void)
Definition extras.c:153
player_knows_extra_exist
bool player_knows_extra_exist(const struct player *pplayer, const struct extra_type *pextra, const struct tile *ptile)
Definition extras.c:1149
extra_name_translation
const char * extra_name_translation(const struct extra_type *pextra)
Definition extras.c:194
extra_type_iterate
#define extra_type_iterate(_p)
Definition extras.h:315
extra_type_iterate_end
#define extra_type_iterate_end
Definition extras.h:321
is_extra_caused_by
#define is_extra_caused_by(e, c)
Definition extras.h:203
extra_base_get
#define extra_base_get(_e_)
Definition extras.h:190
extra_road_get
#define extra_road_get(_e_)
Definition extras.h:191
extra_type_by_cause_iterate_end
#define extra_type_by_cause_iterate_end
Definition extras.h:339
extra_type_by_cause_iterate
#define extra_type_by_cause_iterate(_cause, _extra)
Definition extras.h:333
HB_DISABLED
@ HB_DISABLED
Definition fc_types.h:1291
MAX_EXTRA_TYPES
#define MAX_EXTRA_TYPES
Definition fc_types.h:50
Continent_id
signed short Continent_id
Definition fc_types.h:375
BORDERS_DISABLED
@ BORDERS_DISABLED
Definition fc_types.h:1038
BORDERS_SEE_INSIDE
@ BORDERS_SEE_INSIDE
Definition fc_types.h:1040
BORDERS_EXPAND
@ BORDERS_EXPAND
Definition fc_types.h:1041
IDENTITY_NUMBER_ZERO
#define IDENTITY_NUMBER_ZERO
Definition fc_types.h:92
fcintl.h
_
#define _(String)
Definition fcintl.h:67
ftc_server
const struct ft_color ftc_server
Definition featured_text.c:77
unit_link
const char * unit_link(const struct unit *punit)
Definition featured_text.c:1122
unit_tile_link
const char * unit_tile_link(const struct unit *punit)
Definition featured_text.c:1139
game
struct civ_game game
Definition game.c:62
wld
struct world wld
Definition game.c:63
game_unit_by_number
struct unit * game_unit_by_number(int id)
Definition game.c:116
game_city_by_number
struct city * game_city_by_number(int id)
Definition game.c:107
game.h
owner
struct city * owner
Definition citydlg.c:220
source
static GtkWidget * source
Definition gotodlg.c:58
log.h
fc_assert_ret
#define fc_assert_ret(condition)
Definition log.h:191
log_verbose
#define log_verbose(message,...)
Definition log.h:109
fc_assert
#define fc_assert(condition)
Definition log.h:176
fc_assert_ret_val
#define fc_assert_ret_val(condition, val)
Definition log.h:194
log_debug
#define log_debug(message,...)
Definition log.h:115
log_error
#define log_error(message,...)
Definition log.h:103
map_num_tiles
int map_num_tiles(void)
Definition map.c:1014
rand_map_pos
struct tile * rand_map_pos(const struct civ_map *nmap)
Definition map.c:1088
map_vector_to_sq_distance
int map_vector_to_sq_distance(int dx, int dy)
Definition map.c:614
terrain_surroundings_allow_change
bool terrain_surroundings_allow_change(const struct civ_map *nmap, const struct tile *ptile, const struct terrain *pterrain)
Definition map.c:742
map_distance_vector
void map_distance_vector(int *dx, int *dy, const struct tile *tile0, const struct tile *tile1)
Definition map.c:1073
map.h
adjc_iterate_end
#define adjc_iterate_end
Definition map.h:433
MAP_INDEX_SIZE
#define MAP_INDEX_SIZE
Definition map.h:137
circle_dxyr_iterate
#define circle_dxyr_iterate(nmap, center_tile, sq_radius, _tile, dx, dy, dr)
Definition map.h:409
cardinal_adjc_iterate_end
#define cardinal_adjc_iterate_end
Definition map.h:459
adjc_iterate
#define adjc_iterate(nmap, center_tile, itr_tile)
Definition map.h:428
circle_dxyr_iterate_end
#define circle_dxyr_iterate_end
Definition map.h:420
cardinal_adjc_iterate
#define cardinal_adjc_iterate(nmap, center_tile, itr_tile)
Definition map.h:455
circle_iterate
#define circle_iterate(nmap, center_tile, sq_radius, tile_itr)
Definition map.h:401
whole_map_iterate
#define whole_map_iterate(_map, _tile)
Definition map.h:545
MAP_TILE_OWNER_NULL
#define MAP_TILE_OWNER_NULL
Definition map.h:602
whole_map_iterate_end
#define whole_map_iterate_end
Definition map.h:554
circle_iterate_end
#define circle_iterate_end
Definition map.h:404
assign_continent_numbers
void assign_continent_numbers(void)
Definition mapgen_utils.c:452
get_ocean_size
int get_ocean_size(Continent_id id)
Definition mapgen_utils.c:438
most_shallow_ocean
struct terrain * most_shallow_ocean(bool frozen)
Definition mapgen_utils.c:500
get_lake_surrounders
int get_lake_surrounders(Continent_id cont)
Definition mapgen_utils.c:420
mapgen_utils.h
player_map_init
void player_map_init(struct player *pplayer)
Definition maphand.c:1218
terrain_change_bounce_single_unit
static void terrain_change_bounce_single_unit(struct unit *punit, struct tile *from)
Definition maphand.c:1824
update_player_tile_last_seen
void update_player_tile_last_seen(struct player *pplayer, struct tile *ptile)
Definition maphand.c:1464
shared_vision_change_seen
static void shared_vision_change_seen(struct player *pplayer, struct tile *ptile, const v_radius_t change, bool can_reveal_tiles)
Definition maphand.c:667
vision_clear_sight
void vision_clear_sight(struct vision *vision)
Definition maphand.c:2511
map_claim_base
void map_claim_base(struct tile *ptile, struct extra_type *pextra, struct player *powner, struct player *ploser)
Definition maphand.c:2378
map_set_border_vision
void map_set_border_vision(struct player *pplayer, const bool is_enabled)
Definition maphand.c:740
map_claim_ownership
void map_claim_ownership(struct tile *ptile, struct player *powner, struct tile *psource, bool claim_bases)
Definition maphand.c:2185
player_tile_own_seen
static int player_tile_own_seen(const struct player_tile *plrtile, enum vision_layer vlayer)
Definition maphand.c:1133
map_is_known
bool map_is_known(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:894
map_is_also_seen
static bool map_is_also_seen(const struct tile *ptile, const struct player *pplayer, enum vision_layer vlayer)
Definition maphand.c:909
send_map_info
void send_map_info(struct conn_list *dest)
Definition maphand.c:649
really_give_tile_info_from_player_to_player
static bool really_give_tile_info_from_player_to_player(struct player *pfrom, struct player *pdest, struct tile *ptile)
Definition maphand.c:1482
send_tile_suppression
bool send_tile_suppression(bool now)
Definition maphand.c:475
destroy_extra
void destroy_extra(struct tile *ptile, struct extra_type *pextra)
Definition maphand.c:2586
check_units_single_tile
static void check_units_single_tile(struct tile *ptile)
Definition maphand.c:1876
really_give_map_from_player_to_player
static void really_give_map_from_player_to_player(struct player *pfrom, struct player *pdest)
Definition maphand.c:1555
disable_fog_of_war
void disable_fog_of_war(void)
Definition maphand.c:1782
really_gives_vision
bool really_gives_vision(struct player *me, struct player *them)
Definition maphand.c:345
unit_is_on_layer
static bool unit_is_on_layer(const struct unit *punit, enum vision_layer vlayer)
Definition maphand.c:640
map_know_and_see_all
void map_know_and_see_all(struct player *pplayer)
Definition maphand.c:1193
map_change_own_seen
static void map_change_own_seen(struct player *pplayer, struct tile *ptile, const v_radius_t change)
Definition maphand.c:1142
show_map_to_all
void show_map_to_all(void)
Definition maphand.c:1207
send_tile_info
void send_tile_info(struct conn_list *dest, struct tile *ptile, bool send_unknown)
Definition maphand.c:491
update_player_tile_knowledge
bool update_player_tile_knowledge(struct player *pplayer, struct tile *ptile)
Definition maphand.c:1395
map_get_seen
static int map_get_seen(const struct player *pplayer, const struct tile *ptile, enum vision_layer vlayer)
Definition maphand.c:934
ocean_to_land_fix_rivers
static void ocean_to_land_fix_rivers(struct tile *ptile)
Definition maphand.c:1798
give_map_from_player_to_player
void give_map_from_player_to_player(struct player *pfrom, struct player *pdest)
Definition maphand.c:384
send_all_known_tiles
void send_all_known_tiles(struct conn_list *dest)
Definition maphand.c:444
bounce_units_on_terrain_change
void bounce_units_on_terrain_change(struct tile *ptile)
Definition maphand.c:1906
give_seamap_from_player_to_player
void give_seamap_from_player_to_player(struct player *pfrom, struct player *pdest)
Definition maphand.c:400
remove_shared_vision
void remove_shared_vision(struct player *pfrom, struct player *pto)
Definition maphand.c:1690
need_to_reassign_continents
bool need_to_reassign_continents(const struct terrain *oldter, const struct terrain *newter)
Definition maphand.c:1921
is_claimable_ocean
static bool is_claimable_ocean(struct tile *ptile, struct tile *source, struct player *pplayer)
Definition maphand.c:2071
map_get_player_city
struct vision_site * map_get_player_city(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:1364
is_terrain_ecologically_wet
static bool is_terrain_ecologically_wet(struct tile *ptile)
Definition maphand.c:96
tile_claim_bases
void tile_claim_bases(struct tile *ptile, struct player *powner)
Definition maphand.c:2198
disable_fog_of_war_player
void disable_fog_of_war_player(struct player *pplayer)
Definition maphand.c:1768
climate_change
void climate_change(bool warming, int effect)
Definition maphand.c:133
enable_fog_of_war
void enable_fog_of_war(void)
Definition maphand.c:1758
send_tile_suppressed
static bool send_tile_suppressed
Definition maphand.c:65
create_vision_dependencies
static void create_vision_dependencies(void)
Definition maphand.c:1595
upgrade_all_city_extras
void upgrade_all_city_extras(struct player *pplayer, bool discovery)
Definition maphand.c:276
create_extra
void create_extra(struct tile *ptile, struct extra_type *pextra, struct player *pplayer)
Definition maphand.c:2521
map_update_border
void map_update_border(struct tile *ptile, struct player *owner, int old_radius_sq, int new_radius_sq)
Definition maphand.c:2232
map_set_known
void map_set_known(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1175
map_show_all
void map_show_all(struct player *pplayer)
Definition maphand.c:879
map_unit_homecity_enqueue
static void map_unit_homecity_enqueue(struct tile *ptile)
Definition maphand.c:2124
map_change_seen
static void map_change_seen(struct player *pplayer, struct tile *ptile, const v_radius_t change, bool can_reveal_tiles)
Definition maphand.c:947
map_show_tile
void map_show_tile(struct player *src_player, struct tile *ptile)
Definition maphand.c:768
give_citymap_from_player_to_player
void give_citymap_from_player_to_player(struct city *pcity, struct player *pfrom, struct player *pdest)
Definition maphand.c:418
nuclear_winter
void nuclear_winter(int effect)
Definition maphand.c:119
tile_change_side_effects
void tile_change_side_effects(struct tile *ptile, bool refresh_city)
Definition maphand.c:2689
player_tile_init
static void player_tile_init(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1325
terrain_changed
void terrain_changed(struct tile *ptile)
Definition maphand.c:1940
player_map_free
void player_map_free(struct player *pplayer)
Definition maphand.c:1234
unbuffer_shared_vision
static void unbuffer_shared_vision(struct player *pplayer)
Definition maphand.c:368
map_claim_border_ownership
static void map_claim_border_ownership(struct tile *ptile, struct player *powner, struct tile *psource)
Definition maphand.c:2140
map_is_known_and_seen
bool map_is_known_and_seen(const struct tile *ptile, const struct player *pplayer, enum vision_layer vlayer)
Definition maphand.c:920
change_playertile_site
void change_playertile_site(struct player_tile *ptile, struct vision_site *new_site)
Definition maphand.c:1156
map_calculate_borders
void map_calculate_borders(void)
Definition maphand.c:2351
fix_tile_on_terrain_change
void fix_tile_on_terrain_change(struct tile *ptile, struct terrain *oldter, bool extend_rivers)
Definition maphand.c:1959
enable_fog_of_war_player
void enable_fog_of_war_player(struct player *pplayer)
Definition maphand.c:1744
map_show_circle
void map_show_circle(struct player *pplayer, struct tile *ptile, int radius_sq)
Definition maphand.c:864
map_vision_update
void map_vision_update(struct player *pplayer, struct tile *ptile, const v_radius_t old_radius_sq, const v_radius_t new_radius_sq, bool can_reveal_tiles)
Definition maphand.c:685
map_claim_border
void map_claim_border(struct tile *ptile, struct player *owner, int radius_sq)
Definition maphand.c:2264
update_tile_knowledge
void update_tile_knowledge(struct tile *ptile)
Definition maphand.c:1436
remove_player_from_maps
void remove_player_from_maps(struct player *pplayer)
Definition maphand.c:1255
give_shared_vision
void give_shared_vision(struct player *pfrom, struct player *pto)
Definition maphand.c:1629
check_terrain_change
void check_terrain_change(struct tile *ptile, struct terrain *oldter)
Definition maphand.c:1979
give_distorted_map
bool give_distorted_map(struct player *pfrom, struct player *pto, int prob, bool reveal_cities)
Definition maphand.c:2661
map_hide_tile
void map_hide_tile(struct player *src_player, struct tile *ptile)
Definition maphand.c:820
buffer_shared_vision
static void buffer_shared_vision(struct player *pplayer)
Definition maphand.c:353
give_tile_info_from_player_to_player
static bool give_tile_info_from_player_to_player(struct player *pfrom, struct player *pdest, struct tile *ptile)
Definition maphand.c:1575
global_warming
void global_warming(int effect)
Definition maphand.c:106
upgrade_city_extras
bool upgrade_city_extras(struct city *pcity, struct extra_type **gained)
Definition maphand.c:241
map_clear_border
void map_clear_border(struct tile *ptile)
Definition maphand.c:2215
map_clear_known
void map_clear_known(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1183
player_tile_free
static void player_tile_free(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1350
MAXIMUM_CLAIMED_OCEAN_SIZE
#define MAXIMUM_CLAIMED_OCEAN_SIZE
Definition maphand.c:62
map_get_player_tile
struct player_tile * map_get_player_tile(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:1379
vision_change_sight
void vision_change_sight(struct vision *vision, const v_radius_t radius_sq)
Definition maphand.c:2499
maphand.h
map_get_player_site
#define map_get_player_site(_ptile_, _pplayer_)
Definition maphand.h:93
map_get_playermap_site
#define map_get_playermap_site(_plrtile_)
Definition maphand.h:92
mem.h
fc_realloc
#define fc_realloc(ptr, sz)
Definition mem.h:36
fc_malloc
#define fc_malloc(sz)
Definition mem.h:34
can_unit_exist_at_tile
bool can_unit_exist_at_tile(const struct civ_map *nmap, const struct unit *punit, const struct tile *ptile)
Definition movement.c:319
movement.h
nation_rule_name
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
nation_of_unit
struct nation_type * nation_of_unit(const struct unit *punit)
Definition nation.c:463
nation.h
notify_player
void notify_player(const struct player *pplayer, const struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition notify.c:292
notify.h
packets.h
lsend_packet_map_info
void lsend_packet_map_info(struct conn_list *dest, const struct packet_map_info *packet)
Definition packets_gen.c:10535
send_packet_tile_info
int send_packet_tile_info(struct connection *pc, const struct packet_tile_info *packet)
Definition packets_gen.c:3848
num_known_tech_with_flag
int num_known_tech_with_flag(const struct player *pplayer, enum tech_flag_id flag)
Definition player.c:1273
player_slot_count
int player_slot_count(void)
Definition player.c:418
player_number
int player_number(const struct player *pplayer)
Definition player.c:837
player_name
const char * player_name(const struct player *pplayer)
Definition player.c:895
can_player_see_unit
bool can_player_see_unit(const struct player *pplayer, const struct unit *punit)
Definition player.c:1104
player_index
int player_index(const struct player *pplayer)
Definition player.c:829
pplayers_allied
bool pplayers_allied(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1405
gives_shared_vision
bool gives_shared_vision(const struct player *me, const struct player *them)
Definition player.c:1485
player.h
players_iterate_end
#define players_iterate_end
Definition player.h:537
players_iterate
#define players_iterate(_pplayer)
Definition player.h:532
send_player_info_c
void send_player_info_c(struct player *src, struct conn_list *dest)
Definition plrhand.c:1142
plrhand.h
phase_players_iterate
#define phase_players_iterate(pplayer)
Definition plrhand.h:113
phase_players_iterate_end
#define phase_players_iterate_end
Definition plrhand.h:118
rand.h
fc_rand
#define fc_rand(_size)
Definition rand.h:56
road_has_flag
bool road_has_flag(const struct road_type *proad, enum road_flag_id flag)
Definition road.c:410
count_river_near_tile
int count_river_near_tile(struct civ_map *nmap, const struct tile *ptile, const struct extra_type *priver)
Definition road.c:334
road.h
sanitycheck.h
sanity_check_tile
#define sanity_check_tile(x)
Definition sanitycheck.h:42
flush_packets
void flush_packets(void)
Definition sernet.c:381
sernet.h
specialist.h
DEFAULT_SPECIALIST
#define DEFAULT_SPECIALIST
Definition specialist.h:43
server_state
enum server_states server_state(void)
Definition srv_main.c:333
srv_main.h
base_type
Definition base.h:41
city
Definition city.h:320
city::specialists
citizens specialists[SP_MAX]
Definition city.h:336
city::tile
struct tile * tile
Definition city.h:322
civ_game::last_updated_year
bool last_updated_year
Definition game.h:236
civ_game::vision_reveal_tiles
bool vision_reveal_tiles
Definition game.h:200
civ_game::fogofwar_old
bool fogofwar_old
Definition game.h:234
civ_game::est_connections
struct conn_list * est_connections
Definition game.h:97
civ_game::info
struct packet_game_info info
Definition game.h:89
civ_game::scenario
struct packet_scenario_info scenario
Definition game.h:87
civ_game::foggedborders
bool foggedborders
Definition game.h:147
civ_game::server
struct civ_game::@31::@35 server
civ_map
Definition map_types.h:71
civ_map::tiles
struct tile * tiles
Definition map_types.h:83
civ_map::xsize
int xsize
Definition map_types.h:78
civ_map::ysize
int ysize
Definition map_types.h:78
civ_map::north_latitude
int north_latitude
Definition map_types.h:79
civ_map::south_latitude
int south_latitude
Definition map_types.h:80
civ_map::topology_id
int topology_id
Definition map_types.h:72
civ_map::wrap_id
int wrap_id
Definition map_types.h:73
dbv::vec
unsigned char * vec
Definition bitvector.h:34
effect
Definition effects.h:365
extra_type
Definition extras.h:88
extra_type::resource
struct resource_type * resource
Definition extras.h:156
extra_type::data
struct extra_type::@25 data
extra_type::eus
enum extra_unit_seen_type eus
Definition extras.h:128
extra_type::base
struct base_type * base
Definition extras.h:154
packet_game_info::borders
enum borders_mode borders
Definition packets_gen.h:130
packet_game_info::happyborders
enum happyborders_type happyborders
Definition packets_gen.h:177
packet_game_info::turn
int turn
Definition packets_gen.h:241
packet_game_info::year
int year
Definition packets_gen.h:243
packet_game_info::border_city_permanent_radius_sq
int border_city_permanent_radius_sq
Definition packets_gen.h:129
packet_game_info::fogofwar
bool fogofwar
Definition packets_gen.h:150
packet_map_info
Definition packets_gen.h:267
packet_map_info::xsize
int xsize
Definition packets_gen.h:268
packet_scenario_info::lake_flooding
bool lake_flooding
Definition packets_gen.h:1611
packet_tile_info
Definition packets_gen.h:99
packet_tile_info::resource
Resource_type_id resource
Definition packets_gen.h:107
packet_tile_info::extras
bv_extras extras
Definition packets_gen.h:108
packet_tile_info::place_turn
int place_turn
Definition packets_gen.h:110
packet_tile_info::placing
int placing
Definition packets_gen.h:109
packet_tile_info::owner
int owner
Definition packets_gen.h:103
packet_tile_info::known
enum known_type known
Definition packets_gen.h:102
packet_tile_info::label
char label[MAX_LEN_MAP_LABEL]
Definition packets_gen.h:112
packet_tile_info::extras_owner
int extras_owner
Definition packets_gen.h:104
packet_tile_info::tile
int tile
Definition packets_gen.h:100
packet_tile_info::continent
Continent_id continent
Definition packets_gen.h:101
packet_tile_info::terrain
Terrain_type_id terrain
Definition packets_gen.h:106
packet_tile_info::worked
int worked
Definition packets_gen.h:105
packet_tile_info::spec_sprite
char spec_sprite[MAX_LEN_NAME]
Definition packets_gen.h:111
player_tile
Definition maphand.h:30
player_tile::extras_owner
struct player * extras_owner
Definition maphand.h:35
player_tile::seen_count
v_radius_t seen_count
Definition maphand.h:43
player_tile::site
struct vision_site * site
Definition maphand.h:31
player_tile::terrain
struct terrain * terrain
Definition maphand.h:33
player_tile::extras
struct dbv extras
Definition maphand.h:36
player_tile::last_updated
short last_updated
Definition maphand.h:44
player_tile::owner
struct player * owner
Definition maphand.h:34
player_tile::resource
struct extra_type * resource
Definition maphand.h:32
player
Definition player.h:247
player::cities
struct city_list * cities
Definition player.h:279
player::tile_known
struct dbv tile_known
Definition player.h:308
player::connections
struct conn_list * connections
Definition player.h:296
player::private_map
struct player_tile * private_map
Definition player.h:322
player::border_vision
bool border_vision
Definition player.h:325
player::server
struct player::@70::@72 server
terrain
Definition terrain.h:182
terrain::cooler_wetter_result
struct terrain * cooler_wetter_result
Definition terrain.h:241
terrain::cooler_drier_result
struct terrain * cooler_drier_result
Definition terrain.h:241
terrain::warmer_wetter_result
struct terrain * warmer_wetter_result
Definition terrain.h:240
terrain::warmer_drier_result
struct terrain * warmer_drier_result
Definition terrain.h:240
tile
Definition tile.h:50
tile::spec_sprite
char * spec_sprite
Definition tile.h:66
tile::label
char * label
Definition tile.h:65
tile::extras
bv_extras extras
Definition tile.h:55
tile::resource
struct extra_type * resource
Definition tile.h:56
tile::units
struct unit_list * units
Definition tile.h:58
tile::extras_owner
struct player * extras_owner
Definition tile.h:63
tile::terrain
struct terrain * terrain
Definition tile.h:57
tile::infra_turns
int infra_turns
Definition tile.h:62
tile::placing
struct extra_type * placing
Definition tile.h:61
tile::worked
struct city * worked
Definition tile.h:59
tile::claimer
struct tile * claimer
Definition tile.h:64
unit_type::vlayer
enum vision_layer vlayer
Definition unittype.h:569
unit
Definition unit.h:138
unit::activity
enum unit_activity activity
Definition unit.h:157
unit::id
int id
Definition unit.h:145
unit::server
struct unit::@81::@84 server
unit::activity_target
struct extra_type * activity_target
Definition unit.h:164
unit::homecity
int homecity
Definition unit.h:146
unit::dying
bool dying
Definition unit.h:250
vision_site
Definition vision.h:109
vision_site::identity
int identity
Definition vision.h:114
vision
Definition vision.h:85
vision::tile
struct tile * tile
Definition vision.h:88
vision::can_reveal_tiles
bool can_reveal_tiles
Definition vision.h:89
vision::radius_sq
v_radius_t radius_sq
Definition vision.h:92
vision::player
struct player * player
Definition vision.h:87
world::map
struct civ_map map
Definition world_object.h:38
support.h
sz_strlcpy
#define sz_strlcpy(dest, src)
Definition support.h:189
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
is_terrain_class_near_tile
bool is_terrain_class_near_tile(const struct civ_map *nmap, const struct tile *ptile, enum terrain_class tclass)
Definition terrain.c:612
terrain_count
Terrain_type_id terrain_count(void)
Definition terrain.c:118
terrain_number
Terrain_type_id terrain_number(const struct terrain *pterrain)
Definition terrain.c:147
T_UNKNOWN
#define T_UNKNOWN
Definition terrain.h:57
is_ocean
#define is_ocean(pterrain)
Definition terrain.h:301
is_ocean_tile
#define is_ocean_tile(ptile)
Definition terrain.h:303
T_NONE
#define T_NONE
Definition terrain.h:56
terrain_has_flag
#define terrain_has_flag(terr, flag)
Definition terrain.h:283
tile_add_extra
void tile_add_extra(struct tile *ptile, const struct extra_type *pextra)
Definition tile.c:955
tile_has_river
bool tile_has_river(const struct tile *ptile)
Definition tile.c:852
tile_map_check
bool tile_map_check(struct civ_map *nmap, struct tile *vtile)
Definition tile.c:1065
tile_remove_extra
void tile_remove_extra(struct tile *ptile, const struct extra_type *pextra)
Definition tile.c:965
tile_change_terrain
void tile_change_terrain(struct tile *ptile, struct terrain *pterrain)
Definition tile.c:496
tile_has_conflicting_extra
bool tile_has_conflicting_extra(const struct tile *ptile, const struct extra_type *pextra)
Definition tile.c:901
tile_set_owner
void tile_set_owner(struct tile *ptile, struct player *pplayer, struct tile *claimer)
Definition tile.c:69
tile_city
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
tile_claimer
#define tile_claimer(_tile)
Definition tile.h:100
tile_index
#define tile_index(_pt_)
Definition tile.h:88
tile_worked
#define tile_worked(_tile)
Definition tile.h:114
tile_resource
#define tile_resource(_tile)
Definition tile.h:102
TILE_KNOWN_UNSEEN
@ TILE_KNOWN_UNSEEN
Definition tile.h:37
TILE_UNKNOWN
@ TILE_UNKNOWN
Definition tile.h:36
TILE_KNOWN_SEEN
@ TILE_KNOWN_SEEN
Definition tile.h:38
tile_terrain
#define tile_terrain(_tile)
Definition tile.h:110
TILE_XY
#define TILE_XY(ptile)
Definition tile.h:43
tile_continent
#define tile_continent(_tile)
Definition tile.h:92
tile_has_extra
#define tile_has_extra(ptile, pextra)
Definition tile.h:147
tile_owner
#define tile_owner(_tile)
Definition tile.h:96
get_transporter_occupancy
int get_transporter_occupancy(const struct unit *ptrans)
Definition unit.c:1779
unit_is_alive
bool unit_is_alive(int id)
Definition unit.c:2249
unit_transported
bool unit_transported(const struct unit *pcargo)
Definition unit.c:2421
unit_transport_cargo
struct unit_list * unit_transport_cargo(const struct unit *ptrans)
Definition unit.c:2447
unit.h
unit_tile
#define unit_tile(_pu)
Definition unit.h:390
unit_owner
#define unit_owner(_pu)
Definition unit.h:389
is_non_allied_unit_tile
static bool is_non_allied_unit_tile(const struct tile *ptile, const struct player *pplayer)
Definition unit.h:425
unit_activity_handling
bool unit_activity_handling(struct unit *punit, enum unit_activity new_activity)
Definition unithand.c:6468
unithand.h
unitlist.h
unit_list_iterate
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
unit_list_iterate_safe
#define unit_list_iterate_safe(unitlist, _unit)
Definition unitlist.h:39
unit_list_iterate_end
#define unit_list_iterate_end
Definition unitlist.h:33
unit_list_iterate_safe_end
#define unit_list_iterate_safe_end
Definition unitlist.h:61
unit_goes_out_of_sight
void unit_goes_out_of_sight(struct player *pplayer, struct unit *punit)
Definition unittools.c:2712
send_unit_info
void send_unit_info(struct conn_list *dest, struct unit *punit)
Definition unittools.c:2725
unit_activities_cancel
void unit_activities_cancel(struct unit *punit)
Definition unittools.c:800
wipe_unit
void wipe_unit(struct unit *punit, enum unit_loss_reason reason, struct player *killer)
Definition unittools.c:2135
unit_activities_cancel_all_illegal_area
void unit_activities_cancel_all_illegal_area(const struct tile *ptile)
Definition unittools.c:845
unit_move
bool unit_move(struct unit *punit, struct tile *pdesttile, int move_cost, struct unit *embark_to, bool find_embark_target, bool conquer_city_allowed, bool conquer_extras_allowed, bool enter_hut, bool frighten_hut)
Definition unittools.c:3916
unit_list_refresh_vision
void unit_list_refresh_vision(struct unit_list *punitlist)
Definition unittools.c:4855
unittools.h
unit_type_get
const struct unit_type * unit_type_get(const struct unit *punit)
Definition unittype.c:123
unit_rule_name
const char * unit_rule_name(const struct unit *punit)
Definition unittype.c:1587
vision_site_copy
struct vision_site * vision_site_copy(const struct vision_site *psite)
Definition vision.c:135
vision_site_destroy
void vision_site_destroy(struct vision_site *psite)
Definition vision.c:74
vision.h
V_RADIUS
#define V_RADIUS(main_sq, invis_sq, subs_sq)
Definition vision.h:96
vision_layer_iterate
#define vision_layer_iterate(v)
Definition vision.h:77
vision_site_owner
#define vision_site_owner(v)
Definition vision.h:128
v_radius_t
short int v_radius_t[V_COUNT]
Definition vision.h:83
vision_layer_iterate_end
#define vision_layer_iterate_end
Definition vision.h:80