Freeciv-3.3: /fast/freeciv/nightly/main/server/maphand.c Source File

Freeciv-3.3

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 % MAP_NATIVE_WIDTH) == 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 info.altitude = ptile->altitude;
577
578 send_packet_tile_info(pconn, &info);
579 } else if (pplayer != NULL && known) {
580 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
581 struct vision_site *psite = map_get_playermap_site(plrtile);
582
583 info.known = TILE_KNOWN_UNSEEN;
584 info.continent = tile_continent(ptile);
585 owner = (game.server.foggedborders
586 ? plrtile->owner
587 : tile_owner(ptile));
588 eowner = plrtile->extras_owner;
589 info.owner = (owner ? player_number(owner) : MAP_TILE_OWNER_NULL);
590 info.extras_owner = (eowner ? player_number(eowner) : MAP_TILE_OWNER_NULL);
591 info.worked = (NULL != psite)
592 ? psite->identity
593 : IDENTITY_NUMBER_ZERO;
594
595 info.terrain = (NULL != plrtile->terrain)
596 ? terrain_number(plrtile->terrain)
597 : terrain_count();
598 info.resource = (NULL != plrtile->resource)
599 ? extra_number(plrtile->resource)
600 : MAX_EXTRA_TYPES;
601 info.placing = -1;
602 info.place_turn = 0;
603
604 dbv_to_bv(info.extras.vec, &(plrtile->extras));
605
606 /* Labels never change, so they are not subject to fog of war */
607 if (ptile->label != NULL) {
608 sz_strlcpy(info.label, ptile->label);
609 } else {
610 info.label[0] = '\0';
611 }
612
613 info.altitude = ptile->altitude;
614
615 send_packet_tile_info(pconn, &info);
616 } else if (send_unknown) {
617 info.known = TILE_UNKNOWN;
618 info.continent = 0;
619 info.owner = MAP_TILE_OWNER_NULL;
620 info.extras_owner = MAP_TILE_OWNER_NULL;
621 info.worked = IDENTITY_NUMBER_ZERO;
622
623 info.terrain = terrain_count();
624 info.resource = MAX_EXTRA_TYPES;
625 info.placing = -1;
626 info.place_turn = 0;
627
628 BV_CLR_ALL(info.extras);
629
630 info.label[0] = '\0';
631
632 info.altitude = 0;
633
634 send_packet_tile_info(pconn, &info);
635 }
636 }
637 conn_list_iterate_end;
638}
639
640/**********************************************************************/
646 static bool unit_is_on_layer(const struct unit *punit,
647 enum vision_layer vlayer)
648{
649 return unit_type_get(punit)->vlayer == vlayer;
650}
651
652/**********************************************************************/
655 void send_map_info(struct conn_list *dest)
656{
657 struct packet_map_info minfo;
658
659 minfo.xsize = MAP_NATIVE_WIDTH;
660 minfo.ysize = MAP_NATIVE_HEIGHT;
661 minfo.topology_id = wld.map.topology_id;
662 minfo.wrap_id = wld.map.wrap_id;
663 minfo.north_latitude = wld.map.north_latitude;
664 minfo.south_latitude = wld.map.south_latitude;
665 minfo.altitude_info = wld.map.altitude_info;
666
667 lsend_packet_map_info(dest, &minfo);
668}
669
670/**********************************************************************/
674 static void shared_vision_change_seen(struct player *pplayer,
675 struct tile *ptile,
676 const v_radius_t change,
677 bool can_reveal_tiles)
678{
679 map_change_own_seen(pplayer, ptile, change);
680 map_change_seen(pplayer, ptile, change, can_reveal_tiles);
681
682 players_iterate(pplayer2) {
683 if (really_gives_vision(pplayer, pplayer2)) {
684 map_change_seen(pplayer2, ptile, change, can_reveal_tiles);
685 }
686 } players_iterate_end;
687}
688
689/**********************************************************************/
692 void map_vision_update(struct player *pplayer, struct tile *ptile,
693 const v_radius_t old_radius_sq,
694 const v_radius_t new_radius_sq,
695 bool can_reveal_tiles)
696{
697 v_radius_t change;
698 int max_radius;
699
700 if (old_radius_sq[V_MAIN] == new_radius_sq[V_MAIN]
701 && old_radius_sq[V_INVIS] == new_radius_sq[V_INVIS]
702 && old_radius_sq[V_SUBSURFACE] == new_radius_sq[V_SUBSURFACE]) {
703 return;
704 }
705
706 /* Determines 'max_radius' value. */
707 max_radius = 0;
708 vision_layer_iterate(v) {
709 if (max_radius < old_radius_sq[v]) {
710 max_radius = old_radius_sq[v];
711 }
712 if (max_radius < new_radius_sq[v]) {
713 max_radius = new_radius_sq[v];
714 }
715 } vision_layer_iterate_end;
716
717#ifdef FREECIV_DEBUG
718 log_debug("Updating vision at (%d, %d) in a radius of %d.",
719 TILE_XY(ptile), max_radius);
720 vision_layer_iterate(v) {
721 log_debug(" vision layer %d is changing from %d to %d.",
722 v, old_radius_sq[v], new_radius_sq[v]);
723 } vision_layer_iterate_end;
724#endif /* FREECIV_DEBUG */
725
726 buffer_shared_vision(pplayer);
727 circle_dxyr_iterate(&(wld.map), ptile, max_radius, tile1, dx, dy, dr) {
728 vision_layer_iterate(v) {
729 if (dr > old_radius_sq[v] && dr <= new_radius_sq[v]) {
730 change[v] = 1;
731 } else if (dr > new_radius_sq[v] && dr <= old_radius_sq[v]) {
732 change[v] = -1;
733 } else {
734 change[v] = 0;
735 }
736 } vision_layer_iterate_end;
737 shared_vision_change_seen(pplayer, tile1, change, can_reveal_tiles);
738 } circle_dxyr_iterate_end;
739 unbuffer_shared_vision(pplayer);
740}
741
742/**********************************************************************/
747 void map_set_border_vision(struct player *pplayer,
748 const bool is_enabled)
749{
750 const v_radius_t radius_sq = V_RADIUS(is_enabled ? 1 : -1, 0, 0);
751
752 if (pplayer->server.border_vision == is_enabled) {
753 /* No change. Changing the seen count beyond what already exists would
754 * be a bug. */
755 return;
756 }
757
758 /* Set the new border seer value. */
759 pplayer->server.border_vision = is_enabled;
760
761 whole_map_iterate(&(wld.map), ptile) {
762 if (pplayer == ptile->owner) {
763 /* The tile is within the player's borders. */
764 shared_vision_change_seen(pplayer, ptile, radius_sq, TRUE);
765 }
766 } whole_map_iterate_end;
767}
768
769/**********************************************************************/
775 void map_show_tile(struct player *src_player, struct tile *ptile)
776{
777 static int recurse = 0;
778
779 log_debug("Showing %i,%i to %s", TILE_XY(ptile), player_name(src_player));
780
781 fc_assert(recurse == 0);
782 recurse++;
783
784 players_iterate(pplayer) {
785 if (pplayer == src_player || really_gives_vision(src_player, pplayer)) {
786 struct city *pcity;
787
788 if (!map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
789 map_set_known(ptile, pplayer);
790
791 /* As the tile may be fogged send_tile_info won't always do this for us */
792 update_player_tile_knowledge(pplayer, ptile);
793 update_player_tile_last_seen(pplayer, ptile);
794
795 send_tile_info(pplayer->connections, ptile, FALSE);
796
797 /* Remove old cities that exist no more */
798 reality_check_city(pplayer, ptile);
799
800 if ((pcity = tile_city(ptile))) {
801 /* As the tile may be fogged send_city_info won't do this for us */
802 update_dumb_city(pplayer, pcity);
803 send_city_info(pplayer, pcity);
804 }
805
806 vision_layer_iterate(v) {
807 if (0 < map_get_seen(pplayer, ptile, v)) {
808 unit_list_iterate(ptile->units, punit) {
809 if (unit_is_on_layer(punit, v)) {
810 send_unit_info(pplayer->connections, punit);
811 }
812 } unit_list_iterate_end;
813 }
814 } vision_layer_iterate_end;
815 }
816 }
817 } players_iterate_end;
818
819 recurse--;
820}
821
822/**********************************************************************/
827 void map_hide_tile(struct player *src_player, struct tile *ptile)
828{
829 static int recurse = 0;
830
831 log_debug("Hiding %d,%d to %s", TILE_XY(ptile), player_name(src_player));
832
833 fc_assert(recurse == 0);
834 recurse++;
835
836 players_iterate(pplayer) {
837 if (pplayer == src_player || really_gives_vision(src_player, pplayer)) {
838 if (map_is_known(ptile, pplayer)) {
839 if (0 < map_get_seen(pplayer, ptile, V_MAIN)) {
840 update_player_tile_last_seen(pplayer, ptile);
841 }
842
843 /* Remove city. */
844 remove_dumb_city(pplayer, ptile);
845
846 /* Remove units. */
847 vision_layer_iterate(v) {
848 if (0 < map_get_seen(pplayer, ptile, v)) {
849 unit_list_iterate(ptile->units, punit) {
850 if (unit_is_on_layer(punit, v)) {
851 unit_goes_out_of_sight(pplayer, punit);
852 }
853 } unit_list_iterate_end;
854 }
855 } vision_layer_iterate_end;
856 }
857
858 map_clear_known(ptile, pplayer);
859
860 send_tile_info(pplayer->connections, ptile, TRUE);
861 }
862 } players_iterate_end;
863
864 recurse--;
865}
866
867/**********************************************************************/
871 void map_show_circle(struct player *pplayer, struct tile *ptile, int radius_sq)
872{
873 buffer_shared_vision(pplayer);
874
875 circle_iterate(&(wld.map), ptile, radius_sq, tile1) {
876 map_show_tile(pplayer, tile1);
877 } circle_iterate_end;
878
879 unbuffer_shared_vision(pplayer);
880}
881
882/**********************************************************************/
886 void map_show_all(struct player *pplayer)
887{
888 buffer_shared_vision(pplayer);
889
890 whole_map_iterate(&(wld.map), ptile) {
891 map_show_tile(pplayer, ptile);
892 } whole_map_iterate_end;
893
894 unbuffer_shared_vision(pplayer);
895}
896
897/**********************************************************************/
901 bool map_is_known(const struct tile *ptile, const struct player *pplayer)
902{
903 if (pplayer->tile_known.vec == NULL) {
904 /* Player map not initialized yet */
905 return FALSE;
906 }
907
908 return dbv_isset(&pplayer->tile_known, tile_index(ptile));
909}
910
911/**********************************************************************/
916 static inline bool map_is_also_seen(const struct tile *ptile,
917 const struct player *pplayer,
918 enum vision_layer vlayer)
919{
920 return map_get_seen(pplayer, ptile, vlayer) > 0;
921}
922
923/**********************************************************************/
927 bool map_is_known_and_seen(const struct tile *ptile,
928 const struct player *pplayer,
929 enum vision_layer vlayer)
930{
931 return map_is_known(ptile, pplayer) && map_is_also_seen(ptile, pplayer, vlayer);
932}
933
934/**********************************************************************/
941 static inline int map_get_seen(const struct player *pplayer,
942 const struct tile *ptile,
943 enum vision_layer vlayer)
944{
945 return map_get_player_tile(ptile, pplayer)->seen_count[vlayer];
946}
947
948/**********************************************************************/
954 void map_change_seen(struct player *pplayer,
955 struct tile *ptile,
956 const v_radius_t change,
957 bool can_reveal_tiles)
958{
959 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
960 bool revealing_tile = FALSE;
961
962#ifdef FREECIV_DEBUG
963 log_debug("%s() for player %s (nb %d) at (%d, %d).",
964 __FUNCTION__, player_name(pplayer), player_number(pplayer),
965 TILE_XY(ptile));
966 vision_layer_iterate(v) {
967 log_debug(" vision layer %d is changing from %d to %d.",
968 v, plrtile->seen_count[v], plrtile->seen_count[v] + change[v]);
969 } vision_layer_iterate_end;
970#endif /* FREECIV_DEBUG */
971
972 /* Removes units out of vision. First, check invisible layers because
973 * we must remove all units before fog of war because clients expect
974 * the tile is empty when it is fogged. */
975 if (0 > change[V_INVIS]
976 && plrtile->seen_count[V_INVIS] == -change[V_INVIS]) {
977 log_debug("(%d, %d): hiding invisible units to player %s (nb %d).",
978 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
979
980 unit_list_iterate(ptile->units, punit) {
981 if (unit_is_on_layer(punit, V_INVIS)
982 && can_player_see_unit(pplayer, punit)
983 && (plrtile->seen_count[V_MAIN] + change[V_MAIN] <= 0
984 || !pplayers_allied(pplayer, unit_owner(punit)))) {
985 /* Allied units on seen tiles (V_MAIN) are always seen.
986 * That's how can_player_see_unit_at() works. */
987 unit_goes_out_of_sight(pplayer, punit);
988 }
989 } unit_list_iterate_end;
990 }
991 if (0 > change[V_SUBSURFACE]
992 && plrtile->seen_count[V_SUBSURFACE] == -change[V_SUBSURFACE]) {
993 log_debug("(%d, %d): hiding subsurface units to player %s (nb %d).",
994 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
995
996 unit_list_iterate(ptile->units, punit) {
997 if (unit_is_on_layer(punit, V_SUBSURFACE)
998 && can_player_see_unit(pplayer, punit)) {
999 unit_goes_out_of_sight(pplayer, punit);
1000 }
1001 } unit_list_iterate_end;
1002 }
1003
1004 if (0 > change[V_MAIN]
1005 && plrtile->seen_count[V_MAIN] == -change[V_MAIN]) {
1006 log_debug("(%d, %d): hiding visible units to player %s (nb %d).",
1007 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1008
1009 unit_list_iterate(ptile->units, punit) {
1010 if (unit_is_on_layer(punit, V_MAIN)
1011 && can_player_see_unit(pplayer, punit)) {
1012 unit_goes_out_of_sight(pplayer, punit);
1013 }
1014 } unit_list_iterate_end;
1015 }
1016
1017 vision_layer_iterate(v) {
1018 /* Avoid underflow. */
1019 fc_assert(0 <= change[v] || -change[v] <= plrtile->seen_count[v]);
1020 plrtile->seen_count[v] += change[v];
1021 } vision_layer_iterate_end;
1022
1023 /* V_MAIN vision ranges must always be more than invisible ranges
1024 * (see comment in common/vision.h), so we assume that the V_MAIN
1025 * seen count cannot be inferior to V_INVIS or V_SUBSURFACE seen count.
1026 * Moreover, when the fog of war is disabled, V_MAIN has an extra
1027 * seen count point. */
1028 fc_assert(plrtile->seen_count[V_INVIS] + !game.info.fogofwar
1029 <= plrtile->seen_count[V_MAIN]);
1030 fc_assert(plrtile->seen_count[V_SUBSURFACE] + !game.info.fogofwar
1031 <= plrtile->seen_count[V_MAIN]);
1032
1033 if (!map_is_known(ptile, pplayer)) {
1034 if (0 < plrtile->seen_count[V_MAIN] && can_reveal_tiles) {
1035 log_debug("(%d, %d): revealing tile to player %s (nb %d).",
1036 TILE_XY(ptile), player_name(pplayer),
1037 player_number(pplayer));
1038
1039 map_set_known(ptile, pplayer);
1040 revealing_tile = TRUE;
1041 } else {
1042 return;
1043 }
1044 }
1045
1046 /* Fog the tile. */
1047 if (0 > change[V_MAIN] && 0 == plrtile->seen_count[V_MAIN]) {
1048 struct city *pcity;
1049
1050 log_debug("(%d, %d): fogging tile for player %s (nb %d).",
1051 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1052
1053 pcity = ptile->worked;
1054
1055 if (pcity != NULL && city_owner(pcity) == pplayer) {
1056 city_map_update_empty(pcity, ptile);
1057 pcity->specialists[DEFAULT_SPECIALIST]++;
1058 }
1059
1060 update_player_tile_last_seen(pplayer, ptile);
1061 if (game.server.foggedborders) {
1062 plrtile->owner = tile_owner(ptile);
1063 }
1064 plrtile->extras_owner = extra_owner(ptile);
1065 send_tile_info(pplayer->connections, ptile, FALSE);
1066 }
1067
1068 if ((revealing_tile && 0 < plrtile->seen_count[V_MAIN])
1069 || (0 < change[V_MAIN]
1070 /* plrtile->seen_count[V_MAIN] Always set to 1
1071 * when the fog of war is disabled. */
1072 && (change[V_MAIN] + !game.info.fogofwar
1073 == (plrtile->seen_count[V_MAIN])))) {
1074 struct city *pcity;
1075
1076 log_debug("(%d, %d): unfogging tile for player %s (nb %d).",
1077 TILE_XY(ptile), player_name(pplayer), player_number(pplayer));
1078
1079 /* Send info about the tile itself.
1080 * It has to be sent first because the client needs correct
1081 * continent number before it can handle following packets
1082 */
1083 update_player_tile_knowledge(pplayer, ptile);
1084 send_tile_info(pplayer->connections, ptile, FALSE);
1085
1086 /* Discover units. */
1087 unit_list_iterate(ptile->units, punit) {
1088 /* Be sure not to revive dead unit on client when it's not yet
1089 * removed from the tile. This could happen when "unit_lost" lua script
1090 * somehow causes tile of the dead unit to unfog again. */
1091 if (unit_is_on_layer(punit, V_MAIN)
1092 && !punit->server.dying) {
1093 send_unit_info(pplayer->connections, punit);
1094 }
1095 } unit_list_iterate_end;
1096
1097 /* Discover cities. */
1098 reality_check_city(pplayer, ptile);
1099
1100 if (NULL != (pcity = tile_city(ptile))) {
1101 send_city_info(pplayer, pcity);
1102 }
1103 }
1104
1105 if ((revealing_tile && 0 < plrtile->seen_count[V_INVIS])
1106 || (0 < change[V_INVIS]
1107 && change[V_INVIS] == plrtile->seen_count[V_INVIS])) {
1108 log_debug("(%d, %d): revealing invisible units to player %s (nb %d).",
1109 TILE_XY(ptile), player_name(pplayer),
1110 player_number(pplayer));
1111 /* Discover units. */
1112 unit_list_iterate(ptile->units, punit) {
1113 if (unit_is_on_layer(punit, V_INVIS)) {
1114 send_unit_info(pplayer->connections, punit);
1115 }
1116 } unit_list_iterate_end;
1117 }
1118 if ((revealing_tile && 0 < plrtile->seen_count[V_SUBSURFACE])
1119 || (0 < change[V_SUBSURFACE]
1120 && change[V_SUBSURFACE] == plrtile->seen_count[V_SUBSURFACE])) {
1121 log_debug("(%d, %d): revealing subsurface units to player %s (nb %d).",
1122 TILE_XY(ptile), player_name(pplayer),
1123 player_number(pplayer));
1124 /* Discover units. */
1125 unit_list_iterate(ptile->units, punit) {
1126 if (unit_is_on_layer(punit, V_SUBSURFACE)) {
1127 send_unit_info(pplayer->connections, punit);
1128 }
1129 } unit_list_iterate_end;
1130 }
1131}
1132
1133/**********************************************************************/
1140 static inline int player_tile_own_seen(const struct player_tile *plrtile,
1141 enum vision_layer vlayer)
1142{
1143 return plrtile->own_seen[vlayer];
1144}
1145
1146/**********************************************************************/
1149 static void map_change_own_seen(struct player *pplayer,
1150 struct tile *ptile,
1151 const v_radius_t change)
1152{
1153 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1154
1155 vision_layer_iterate(v) {
1156 plrtile->own_seen[v] += change[v];
1157 } vision_layer_iterate_end;
1158}
1159
1160/**********************************************************************/
1163 void change_playertile_site(struct player_tile *ptile,
1164 struct vision_site *new_site)
1165{
1166 if (ptile->site == new_site) {
1167 /* Do nothing. */
1168 return;
1169 }
1170
1171 if (ptile->site != NULL) {
1172 /* Releasing old site from tile */
1173 vision_site_destroy(ptile->site);
1174 }
1175
1176 ptile->site = new_site;
1177}
1178
1179/**********************************************************************/
1182 void map_set_known(struct tile *ptile, struct player *pplayer)
1183{
1184 dbv_set(&pplayer->tile_known, tile_index(ptile));
1185}
1186
1187/**********************************************************************/
1190 void map_clear_known(struct tile *ptile, struct player *pplayer)
1191{
1192 dbv_clr(&pplayer->tile_known, tile_index(ptile));
1193}
1194
1195/**********************************************************************/
1200 void map_know_and_see_all(struct player *pplayer)
1201{
1202 const v_radius_t radius_sq = V_RADIUS(1, 1, 1);
1203
1204 buffer_shared_vision(pplayer);
1205 whole_map_iterate(&(wld.map), ptile) {
1206 map_change_seen(pplayer, ptile, radius_sq, TRUE);
1207 } whole_map_iterate_end;
1208 unbuffer_shared_vision(pplayer);
1209}
1210
1211/**********************************************************************/
1214 void show_map_to_all(void)
1215{
1216 players_iterate(pplayer) {
1217 map_know_and_see_all(pplayer);
1218 } players_iterate_end;
1219}
1220
1221/**********************************************************************/
1225 void player_map_init(struct player *pplayer)
1226{
1227 pplayer->server.private_map
1228 = fc_realloc(pplayer->server.private_map,
1229 MAP_INDEX_SIZE * sizeof(*pplayer->server.private_map));
1230
1231 whole_map_iterate(&(wld.map), ptile) {
1232 player_tile_init(ptile, pplayer);
1233 } whole_map_iterate_end;
1234
1235 dbv_init(&pplayer->tile_known, MAP_INDEX_SIZE);
1236}
1237
1238/**********************************************************************/
1241 void player_map_free(struct player *pplayer)
1242{
1243 if (!pplayer->server.private_map) {
1244 return;
1245 }
1246
1247 whole_map_iterate(&(wld.map), ptile) {
1248 player_tile_free(ptile, pplayer);
1249 } whole_map_iterate_end;
1250
1251 free(pplayer->server.private_map);
1252 pplayer->server.private_map = NULL;
1253
1254 dbv_free(&pplayer->tile_known);
1255}
1256
1257/**********************************************************************/
1262 void remove_player_from_maps(struct player *pplayer)
1263{
1264 /* only after removing borders! */
1265 conn_list_do_buffer(game.est_connections);
1266 whole_map_iterate(&(wld.map), ptile) {
1267 /* Clear all players' knowledge about the removed player, and free
1268 * data structures (including those in removed player's player map). */
1269 bool reality_changed = FALSE;
1270
1271 players_iterate(aplayer) {
1272 struct player_tile *aplrtile;
1273 bool changed = FALSE;
1274
1275 if (!aplayer->server.private_map) {
1276 continue;
1277 }
1278 aplrtile = map_get_player_tile(ptile, aplayer);
1279
1280 /* Free vision sites (cities) for removed and other players */
1281 if (aplrtile && aplrtile->site
1282 && vision_site_owner(aplrtile->site) == pplayer) {
1283 change_playertile_site(aplrtile, NULL);
1284 changed = TRUE;
1285 }
1286
1287 /* Remove references to player from others' maps */
1288 if (aplrtile->owner == pplayer) {
1289 aplrtile->owner = NULL;
1290 changed = TRUE;
1291 }
1292 if (aplrtile->extras_owner == pplayer) {
1293 aplrtile->extras_owner = NULL;
1294 changed = TRUE;
1295 }
1296
1297 /* Must ensure references to dying player are gone from clients
1298 * before player is destroyed */
1299 if (changed) {
1300 /* This will use player tile if fogged */
1301 send_tile_info(pplayer->connections, ptile, FALSE);
1302 }
1303 } players_iterate_end;
1304
1305 /* Clear removed player's knowledge */
1306 if (pplayer->tile_known.vec) {
1307 map_clear_known(ptile, pplayer);
1308 }
1309
1310 /* Free all claimed tiles. */
1311 if (tile_owner(ptile) == pplayer) {
1312 tile_set_owner(ptile, NULL, NULL);
1313 reality_changed = TRUE;
1314 }
1315 if (extra_owner(ptile) == pplayer) {
1316 ptile->extras_owner = NULL;
1317 reality_changed = TRUE;
1318 }
1319
1320 if (reality_changed) {
1321 /* Update anyone who can see the tile (e.g. global observers) */
1322 send_tile_info(NULL, ptile, FALSE);
1323 }
1324 } whole_map_iterate_end;
1325 conn_list_do_unbuffer(game.est_connections);
1326}
1327
1328/**********************************************************************/
1332 static void player_tile_init(struct tile *ptile, struct player *pplayer)
1333{
1334 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1335
1336 plrtile->terrain = T_UNKNOWN;
1337 plrtile->resource = NULL;
1338 plrtile->owner = NULL;
1339 plrtile->extras_owner = NULL;
1340 plrtile->site = NULL;
1341 dbv_init(&(plrtile->extras), extra_count());
1342 if (!game.server.last_updated_year) {
1343 plrtile->last_updated = game.info.turn;
1344 } else {
1345 plrtile->last_updated = game.info.year;
1346 }
1347
1348 plrtile->seen_count[V_MAIN] = !game.server.fogofwar_old;
1349 plrtile->seen_count[V_INVIS] = 0;
1350 plrtile->seen_count[V_SUBSURFACE] = 0;
1351 memcpy(plrtile->own_seen, plrtile->seen_count, sizeof(v_radius_t));
1352}
1353
1354/**********************************************************************/
1357 static void player_tile_free(struct tile *ptile, struct player *pplayer)
1358{
1359 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1360
1361 if (plrtile->site != NULL) {
1362 vision_site_destroy(plrtile->site);
1363 }
1364
1365 dbv_free(&(plrtile->extras));
1366}
1367
1368/**********************************************************************/
1371 struct vision_site *map_get_player_city(const struct tile *ptile,
1372 const struct player *pplayer)
1373{
1374 struct vision_site *psite = map_get_player_site(ptile, pplayer);
1375
1376 fc_assert_ret_val(psite == NULL || psite->location == ptile, NULL);
1377
1378 return psite;
1379}
1380
1381/**********************************************************************/
1386 struct player_tile *map_get_player_tile(const struct tile *ptile,
1387 const struct player *pplayer)
1388{
1389 fc_assert_ret_val(pplayer->server.private_map, NULL);
1390
1391 return pplayer->server.private_map + tile_index(ptile);
1392}
1393
1394/**********************************************************************/
1402 bool update_player_tile_knowledge(struct player *pplayer, struct tile *ptile)
1403{
1404 struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1405
1406 if (plrtile->terrain != ptile->terrain
1407 || !bv_match_dbv(&(plrtile->extras), ptile->extras.vec)
1408 || plrtile->resource != ptile->resource
1409 || plrtile->owner != tile_owner(ptile)
1410 || plrtile->extras_owner != extra_owner(ptile)) {
1411 plrtile->terrain = ptile->terrain;
1412 extra_type_iterate(pextra) {
1413 if (player_knows_extra_exist(pplayer, pextra, ptile)) {
1414 dbv_set(&(plrtile->extras), extra_number(pextra));
1415 } else {
1416 dbv_clr(&(plrtile->extras), extra_number(pextra));
1417 }
1418 } extra_type_iterate_end;
1419 if (ptile->resource != NULL
1420 && player_knows_extra_exist(pplayer, ptile->resource, ptile)) {
1421 plrtile->resource = ptile->resource;
1422 } else {
1423 plrtile->resource = NULL;
1424 }
1425 plrtile->owner = tile_owner(ptile);
1426 plrtile->extras_owner = extra_owner(ptile);
1427
1428 return TRUE;
1429 }
1430
1431 return FALSE;
1432}
1433
1434/**********************************************************************/
1443 void update_tile_knowledge(struct tile *ptile)
1444{
1445 if (server_state() == S_S_INITIAL) {
1446 return;
1447 }
1448
1449 /* Players */
1450 players_iterate(pplayer) {
1451 if (map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
1452 if (update_player_tile_knowledge(pplayer, ptile)) {
1453 send_tile_info(pplayer->connections, ptile, FALSE);
1454 }
1455 }
1456 } players_iterate_end;
1457
1458 /* Global observers */
1459 conn_list_iterate(game.est_connections, pconn) {
1460 struct player *pplayer = pconn->playing;
1461
1462 if (NULL == pplayer && pconn->observer) {
1463 send_tile_info(pconn->self, ptile, FALSE);
1464 }
1465 } conn_list_iterate_end;
1466}
1467
1468/**********************************************************************/
1471 void update_player_tile_last_seen(struct player *pplayer,
1472 struct tile *ptile)
1473{
1474 if (!game.server.last_updated_year) {
1475 map_get_player_tile(ptile, pplayer)->last_updated = game.info.turn;
1476 } else {
1477 map_get_player_tile(ptile, pplayer)->last_updated = game.info.year;
1478 }
1479}
1480
1481/**********************************************************************/
1489 static bool really_give_tile_info_from_player_to_player(struct player *pfrom,
1490 struct player *pdest,
1491 struct tile *ptile)
1492{
1493 if (!map_is_known_and_seen(ptile, pdest, V_MAIN)) {
1494 /* I can just hear people scream as they try to comprehend this if :).
1495 * Let me try in words:
1496 * 1) if the tile is seen by pfrom the info is sent to pdest
1497 * OR
1498 * 2) if the tile is known by pfrom AND (they have more recent info
1499 * OR it is not known by pdest)
1500 */
1501 if (map_is_known_and_seen(ptile, pfrom, V_MAIN)
1502 || (map_is_known(ptile, pfrom)
1503 && (((map_get_player_tile(ptile, pfrom)->last_updated
1504 > map_get_player_tile(ptile, pdest)->last_updated))
1505 || !map_is_known(ptile, pdest)))) {
1506 struct player_tile *from_tile, *dest_tile;
1507
1508 from_tile = map_get_player_tile(ptile, pfrom);
1509 dest_tile = map_get_player_tile(ptile, pdest);
1510 /* Update and send tile knowledge */
1511 map_set_known(ptile, pdest);
1512 dest_tile->terrain = from_tile->terrain;
1513 dbv_copy(&(dest_tile->extras), &(from_tile->extras));
1514 dest_tile->resource = from_tile->resource;
1515 dest_tile->owner = from_tile->owner;
1516 dest_tile->extras_owner = from_tile->extras_owner;
1517 dest_tile->last_updated = from_tile->last_updated;
1518 send_tile_info(pdest->connections, ptile, FALSE);
1519
1520 /* Update and send city knowledge */
1521 /* Remove outdated cities */
1522 if (dest_tile->site) {
1523 if (!from_tile->site) {
1524 /* As the city was gone on the newer from_tile
1525 it will be removed by this function */
1526 reality_check_city(pdest, ptile);
1527 } else { /* We have a dest_city. update */
1528 if (from_tile->site->identity
1529 != dest_tile->site->identity) {
1530 /* As the city was gone on the newer from_tile
1531 it will be removed by this function */
1532 reality_check_city(pdest, ptile);
1533 }
1534 }
1535 }
1536
1537 /* Set and send new city info */
1538 if (from_tile->site) {
1539 if (!dest_tile->site) {
1540 /* We cannot assign new vision site with change_playertile_site(),
1541 * since location is not yet set up for new site */
1542 dest_tile->site = vision_site_copy(from_tile->site);
1543 }
1544 /* Note that we don't care if receiver knows vision source city
1545 * or not. */
1546 send_city_info_at_tile(pdest, pdest->connections, NULL, ptile);
1547 }
1548
1549 city_map_update_tile_frozen(ptile);
1550
1551 return TRUE;
1552 }
1553 }
1554
1555 return FALSE;
1556}
1557
1558/**********************************************************************/
1562 static void really_give_map_from_player_to_player(struct player *pfrom,
1563 struct player *pdest)
1564{
1565 whole_map_iterate(&(wld.map), ptile) {
1566 really_give_tile_info_from_player_to_player(pfrom, pdest, ptile);
1567 } whole_map_iterate_end;
1568
1569 city_thaw_workers_queue();
1570 sync_cities();
1571}
1572
1573/**********************************************************************/
1582 static bool give_tile_info_from_player_to_player(struct player *pfrom,
1583 struct player *pdest,
1584 struct tile *ptile)
1585{
1586 bool updt = really_give_tile_info_from_player_to_player(pfrom, pdest, ptile);
1587
1588 players_iterate(pplayer2) {
1589 if (really_gives_vision(pdest, pplayer2)) {
1590 updt |= really_give_tile_info_from_player_to_player(pfrom, pplayer2, ptile);
1591 }
1592 } players_iterate_end;
1593
1594 return updt;
1595}
1596
1597/**********************************************************************/
1602 static void create_vision_dependencies(void)
1603{
1604 int added;
1605
1606 players_iterate(pplayer) {
1607 pplayer->server.really_gives_vision = pplayer->gives_shared_vision;
1608 } players_iterate_end;
1609
1610 /* In words: This terminates when it has run a round without adding
1611 a dependency. One loop only propagates dependencies one level deep,
1612 which is why we keep doing it as long as changes occur. */
1613 do {
1614 added = 0;
1615 players_iterate(pplayer) {
1616 players_iterate(pplayer2) {
1617 if (really_gives_vision(pplayer, pplayer2)
1618 && pplayer != pplayer2) {
1619 players_iterate(pplayer3) {
1620 if (really_gives_vision(pplayer2, pplayer3)
1621 && !really_gives_vision(pplayer, pplayer3)
1622 && pplayer != pplayer3) {
1623 BV_SET(pplayer->server.really_gives_vision, player_index(pplayer3));
1624 added++;
1625 }
1626 } players_iterate_end;
1627 }
1628 } players_iterate_end;
1629 } players_iterate_end;
1630 } while (added > 0);
1631}
1632
1633/**********************************************************************/
1636 void give_shared_vision(struct player *pfrom, struct player *pto)
1637{
1638 bv_player save_vision[player_slot_count()];
1639
1640 if (pfrom == pto) {
1641 return;
1642 }
1643
1644 if (gives_shared_vision(pfrom, pto)) {
1645 log_error("Trying to give shared vision from %s to %s, "
1646 "but that vision is already given!",
1647 player_name(pfrom), player_name(pto));
1648 return;
1649 }
1650
1651 players_iterate(pplayer) {
1652 save_vision[player_index(pplayer)] = pplayer->server.really_gives_vision;
1653 } players_iterate_end;
1654
1655 BV_SET(pfrom->gives_shared_vision, player_index(pto));
1656 create_vision_dependencies();
1657 log_debug("giving shared vision from %s to %s",
1658 player_name(pfrom), player_name(pto));
1659
1660 players_iterate(pplayer) {
1661 buffer_shared_vision(pplayer);
1662 players_iterate(pplayer2) {
1663 if (really_gives_vision(pplayer, pplayer2)
1664 && !BV_ISSET(save_vision[player_index(pplayer)],
1665 player_index(pplayer2))) {
1666 log_debug("really giving shared vision from %s to %s",
1667 player_name(pplayer), player_name(pplayer2));
1668 whole_map_iterate(&(wld.map), ptile) {
1669 const struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1670 const v_radius_t change =
1671 V_RADIUS(player_tile_own_seen(plrtile, V_MAIN),
1672 player_tile_own_seen(plrtile, V_INVIS),
1673 player_tile_own_seen(plrtile, V_SUBSURFACE));
1674
1675 if (0 < change[V_MAIN] || 0 < change[V_INVIS]) {
1676 map_change_seen(pplayer2, ptile, change,
1677 map_is_known(ptile, pplayer));
1678 }
1679 } whole_map_iterate_end;
1680
1681 /* Squares that are not seen, but which pfrom may have more recent
1682 knowledge of */
1683 really_give_map_from_player_to_player(pplayer, pplayer2);
1684 }
1685 } players_iterate_end;
1686 unbuffer_shared_vision(pplayer);
1687 } players_iterate_end;
1688
1689 if (S_S_RUNNING == server_state()) {
1690 send_player_info_c(pfrom, NULL);
1691 }
1692}
1693
1694/**********************************************************************/
1697 void remove_shared_vision(struct player *pfrom, struct player *pto)
1698{
1699 bv_player save_vision[player_slot_count()];
1700
1701 fc_assert_ret(pfrom != pto);
1702 if (!gives_shared_vision(pfrom, pto)) {
1703 log_error("Tried removing the shared vision from %s to %s, "
1704 "but it did not exist in the first place!",
1705 player_name(pfrom), player_name(pto));
1706 return;
1707 }
1708
1709 players_iterate(pplayer) {
1710 save_vision[player_index(pplayer)] = pplayer->server.really_gives_vision;
1711 } players_iterate_end;
1712
1713 log_debug("removing shared vision from %s to %s",
1714 player_name(pfrom), player_name(pto));
1715
1716 BV_CLR(pfrom->gives_shared_vision, player_index(pto));
1717 create_vision_dependencies();
1718
1719 players_iterate(pplayer) {
1720 buffer_shared_vision(pplayer);
1721 players_iterate(pplayer2) {
1722 if (!really_gives_vision(pplayer, pplayer2)
1723 && BV_ISSET(save_vision[player_index(pplayer)],
1724 player_index(pplayer2))) {
1725 log_debug("really removing shared vision from %s to %s",
1726 player_name(pplayer), player_name(pplayer2));
1727 whole_map_iterate(&(wld.map), ptile) {
1728 const struct player_tile *plrtile = map_get_player_tile(ptile, pplayer);
1729 const v_radius_t change =
1730 V_RADIUS(-player_tile_own_seen(plrtile, V_MAIN),
1731 -player_tile_own_seen(plrtile, V_INVIS),
1732 -player_tile_own_seen(plrtile, V_SUBSURFACE));
1733
1734 if (0 > change[V_MAIN] || 0 > change[V_INVIS]) {
1735 map_change_seen(pplayer2, ptile, change, FALSE);
1736 }
1737 } whole_map_iterate_end;
1738 }
1739 } players_iterate_end;
1740 unbuffer_shared_vision(pplayer);
1741 } players_iterate_end;
1742
1743 if (S_S_RUNNING == server_state()) {
1744 send_player_info_c(pfrom, NULL);
1745 }
1746}
1747
1748/**********************************************************************/
1751 void enable_fog_of_war_player(struct player *pplayer)
1752{
1753 const v_radius_t radius_sq = V_RADIUS(-1, 0, 0);
1754
1755 buffer_shared_vision(pplayer);
1756 whole_map_iterate(&(wld.map), ptile) {
1757 map_change_seen(pplayer, ptile, radius_sq, FALSE);
1758 } whole_map_iterate_end;
1759 unbuffer_shared_vision(pplayer);
1760}
1761
1762/**********************************************************************/
1765 void enable_fog_of_war(void)
1766{
1767 players_iterate(pplayer) {
1768 enable_fog_of_war_player(pplayer);
1769 } players_iterate_end;
1770}
1771
1772/**********************************************************************/
1775 void disable_fog_of_war_player(struct player *pplayer)
1776{
1777 const v_radius_t radius_sq = V_RADIUS(1, 0, 0);
1778
1779 buffer_shared_vision(pplayer);
1780 whole_map_iterate(&(wld.map), ptile) {
1781 map_change_seen(pplayer, ptile, radius_sq, FALSE);
1782 } whole_map_iterate_end;
1783 unbuffer_shared_vision(pplayer);
1784}
1785
1786/**********************************************************************/
1789 void disable_fog_of_war(void)
1790{
1791 players_iterate(pplayer) {
1792 disable_fog_of_war_player(pplayer);
1793 } players_iterate_end;
1794}
1795
1796/**********************************************************************/
1805 static void ocean_to_land_fix_rivers(struct tile *ptile)
1806{
1807 cardinal_adjc_iterate(&(wld.map), ptile, tile1) {
1808 bool ocean_near = FALSE;
1809
1810 cardinal_adjc_iterate(&(wld.map), tile1, tile2) {
1811 if (is_ocean_tile(tile2))
1812 ocean_near = TRUE;
1813 } cardinal_adjc_iterate_end;
1814
1815 if (!ocean_near) {
1816 /* If ruleset has several river types defined, this
1817 * may cause same tile to contain more than one river. */
1818 extra_type_by_cause_iterate(EC_ROAD, priver) {
1819 if (tile_has_extra(tile1, priver)
1820 && road_has_flag(extra_road_get(priver), RF_RIVER)) {
1821 tile_add_extra(ptile, priver);
1822 }
1823 } extra_type_by_cause_iterate_end;
1824 }
1825 } cardinal_adjc_iterate_end;
1826}
1827
1828/**********************************************************************/
1831 static void terrain_change_bounce_single_unit(struct unit *punit,
1832 struct tile *from)
1833{
1834 bool unit_alive = TRUE;
1835 struct player *owner = unit_owner(punit);
1836
1837 /* Look for a nearby safe tile */
1838 adjc_iterate(&(wld.map), from, ptile2) {
1839 if (can_unit_exist_at_tile(&(wld.map), punit, ptile2)
1840 && !is_non_allied_unit_tile(ptile2, owner,
1841 unit_has_type_flag(punit, UTYF_FLAGLESS))
1842 && !is_non_allied_city_tile(ptile2, owner)) {
1843 log_verbose("Moved %s %s due to changing terrain at (%d,%d).",
1844 nation_rule_name(nation_of_unit(punit)),
1845 unit_rule_name(punit), TILE_XY(unit_tile(punit)));
1846 notify_player(owner, unit_tile(punit),
1847 E_UNIT_RELOCATED, ftc_server,
1848 _("Moved your %s due to changing terrain."),
1849 unit_link(punit));
1850
1851 /* TODO: should a unit be able to bounce to a transport like is
1852 * done below? What if the unit can't legally enter the transport,
1853 * say because the transport is Unreachable and the unit doesn't
1854 * have it in its embarks field or because "Transport Embark"
1855 * isn't enabled? Kept like it was to preserve the old rules for
1856 * now. -- Sveinung */
1857 unit_alive = unit_move(punit, ptile2, 0,
1858 NULL, TRUE, FALSE, FALSE, FALSE, FALSE);
1859 if (unit_alive && punit->activity == ACTIVITY_SENTRY) {
1860 unit_activity_handling(punit, ACTIVITY_IDLE, ACTION_NONE);
1861 }
1862 break;
1863 }
1864 } adjc_iterate_end;
1865
1866 if (unit_alive && unit_tile(punit) == from) {
1867 /* If we get here we could not move punit. */
1868
1869 /* Try to bounce transported units. */
1870 if (0 < get_transporter_occupancy(punit)) {
1871 struct unit_list *pcargo_units;
1872
1873 pcargo_units = unit_transport_cargo(punit);
1874 unit_list_iterate_safe(pcargo_units, pcargo) {
1875 terrain_change_bounce_single_unit(pcargo, from);
1876 } unit_list_iterate_safe_end;
1877 }
1878 }
1879}
1880
1881/**********************************************************************/
1885 static void check_units_single_tile(struct tile *ptile)
1886{
1887 unit_list_iterate_safe(ptile->units, punit) {
1888 int id = punit->id;
1889
1890 /* Top-level transports only. Each handle their own cargo */
1891 if (!unit_transported(punit)
1892 && !can_unit_exist_at_tile(&(wld.map), punit, ptile)) {
1893 terrain_change_bounce_single_unit(punit, ptile);
1894
1895 if (unit_is_alive(id) && unit_tile(punit) == ptile) {
1896 log_verbose("Disbanded %s %s due to changing land "
1897 " to sea at (%d, %d).",
1898 nation_rule_name(nation_of_unit(punit)),
1899 unit_rule_name(punit), TILE_XY(unit_tile(punit)));
1900 notify_player(unit_owner(punit), unit_tile(punit),
1901 E_UNIT_LOST_MISC, ftc_server,
1902 _("Disbanded your %s due to changing terrain."),
1903 unit_tile_link(punit));
1904 wipe_unit(punit, ULR_NONNATIVE_TERR, NULL);
1905 }
1906 }
1907 } unit_list_iterate_safe_end;
1908}
1909
1910/**********************************************************************/
1915 void bounce_units_on_terrain_change(struct tile *ptile)
1916{
1917 /* Check this tile for direct effect on its units */
1918 check_units_single_tile(ptile);
1919 /* We have to check adjacent tiles too, in case units in cities are now
1920 * illegal (e.g., boat in a city that has become landlocked). */
1921 adjc_iterate(&(wld.map), ptile, ptile2) {
1922 check_units_single_tile(ptile2);
1923 } adjc_iterate_end;
1924}
1925
1926/**********************************************************************/
1930 bool need_to_reassign_continents(const struct terrain *oldter,
1931 const struct terrain *newter)
1932{
1933 bool old_is_ocean, new_is_ocean;
1934
1935 if (!oldter || !newter) {
1936 return FALSE;
1937 }
1938
1939 old_is_ocean = is_ocean(oldter);
1940 new_is_ocean = is_ocean(newter);
1941
1942 return (old_is_ocean && !new_is_ocean)
1943 || (!old_is_ocean && new_is_ocean);
1944}
1945
1946/**********************************************************************/
1949 void terrain_changed(struct tile *ptile)
1950{
1951 struct city *pcity = tile_city(ptile);
1952
1953 if (pcity != NULL) {
1954 /* Tile is city center and new terrain may support better extras. */
1955 upgrade_city_extras(pcity, NULL);
1956 }
1957
1958 bounce_units_on_terrain_change(ptile);
1959}
1960
1961/**********************************************************************/
1968 void fix_tile_on_terrain_change(struct tile *ptile,
1969 struct terrain *oldter,
1970 bool extend_rivers)
1971{
1972 if (is_ocean(oldter) && !is_ocean_tile(ptile)) {
1973 if (extend_rivers) {
1974 ocean_to_land_fix_rivers(ptile);
1975 }
1976 city_landlocked_sell_coastal_improvements(ptile);
1977 }
1978
1979 terrain_changed(ptile);
1980}
1981
1982/**********************************************************************/
1988 void check_terrain_change(struct tile *ptile, struct terrain *oldter)
1989{
1990 struct terrain *newter = tile_terrain(ptile);
1991 struct tile *claimer;
1992 bool cont_reassigned = FALSE;
1993
1994 /* Check if new terrain is a freshwater terrain next to non-freshwater.
1995 * In that case, the new terrain is *changed*. */
1996 if (is_ocean(newter) && terrain_has_flag(newter, TER_FRESHWATER)) {
1997 bool nonfresh = FALSE;
1998
1999 adjc_iterate(&(wld.map), ptile, atile) {
2000 if (is_ocean(tile_terrain(atile))
2001 && !terrain_has_flag(tile_terrain(atile), TER_FRESHWATER)) {
2002 nonfresh = TRUE;
2003 break;
2004 }
2005 } adjc_iterate_end;
2006 if (nonfresh) {
2007 /* Need to pick a new, non-freshwater ocean type for this tile.
2008 * We don't want e.g. Deep Ocean to be propagated to this tile
2009 * and then to a whole lake by the flooding below, so we pick
2010 * the shallowest non-fresh oceanic type.
2011 * Prefer terrain that matches the frozenness of the target. */
2012 newter = most_shallow_ocean(terrain_has_flag(newter, TER_FROZEN));
2013 tile_change_terrain(ptile, newter);
2014 }
2015 }
2016
2017 if (need_to_reassign_continents(oldter, newter)) {
2018 assign_continent_numbers();
2019 cont_reassigned = TRUE;
2020
2021 phase_players_iterate(pplayer) {
2022 if (is_adv_data_phase_open(pplayer)) {
2023 /* Player is using continent numbers that they would assume to remain accurate.
2024 * Force refresh:
2025 * 1) Close the phase, so that it can be opened
2026 * 2) Open the phase, recalculating
2027 */
2028 adv_data_phase_done(pplayer);
2029 adv_data_phase_init(pplayer, FALSE);
2030 }
2031 } phase_players_iterate_end;
2032 }
2033
2034 fix_tile_on_terrain_change(ptile, oldter, TRUE);
2035
2036 /* Check for saltwater filling freshwater lake */
2037 if (game.scenario.lake_flooding
2038 && is_ocean(newter) && !terrain_has_flag(newter, TER_FRESHWATER)) {
2039 adjc_iterate(&(wld.map), ptile, atile) {
2040 if (terrain_has_flag(tile_terrain(atile), TER_FRESHWATER)) {
2041 struct terrain *aold = tile_terrain(atile);
2042
2043 tile_change_terrain(atile,
2044 most_shallow_ocean(terrain_has_flag(aold,
2045 TER_FROZEN)));
2046
2047 /* Recursive, but as lakes are of limited size, this
2048 * won't recurse so much as to cause stack problems. */
2049 check_terrain_change(atile, aold);
2050 update_tile_knowledge(atile);
2051 }
2052 } adjc_iterate_end;
2053 }
2054
2055 if (cont_reassigned) {
2056 send_all_known_tiles(NULL);
2057 }
2058
2059 claimer = tile_claimer(ptile);
2060 if (claimer != NULL && is_ocean_tile(ptile)) {
2061 if (!is_claimable_ocean(ptile, claimer, tile_owner(ptile))) {
2062 map_clear_border(ptile);
2063 }
2064 }
2065
2066 sanity_check_tile(ptile);
2067}
2068
2069/**********************************************************************/
2080 static bool is_claimable_ocean(struct tile *ptile, struct tile *source,
2081 struct player *pplayer)
2082{
2083 Continent_id cont = tile_continent(ptile);
2084 Continent_id cont1 = tile_continent(source);
2085 Continent_id cont2;
2086 int ocean_tiles;
2087 bool other_continent;
2088
2089 if (get_ocean_size(-cont) <= MAXIMUM_CLAIMED_OCEAN_SIZE
2090 && get_lake_surrounders(cont) == cont1) {
2091 return TRUE;
2092 }
2093
2094 if (ptile == source) {
2095 /* Source itself is always claimable. */
2096 return TRUE;
2097 }
2098
2099 if (num_known_tech_with_flag(pplayer, TF_CLAIM_OCEAN) > 0
2100 || (cont1 < 0 && num_known_tech_with_flag(pplayer, TF_CLAIM_OCEAN_LIMITED) > 0)) {
2101 return TRUE;
2102 }
2103
2104 ocean_tiles = 0;
2105 other_continent = FALSE;
2106 adjc_iterate(&(wld.map), ptile, tile2) {
2107 cont2 = tile_continent(tile2);
2108 if (tile2 == source) {
2109 /* Water next to border source is always claimable */
2110 return TRUE;
2111 }
2112 if (cont2 == cont) {
2113 ocean_tiles++;
2114 } else if (cont1 <= 0) {
2115 /* First adjacent land (only if border source is not on land) */
2116 cont1 = cont2;
2117 } else if (cont2 != cont1) {
2118 /* This water has two land continents adjacent, or land adjacent
2119 * that is of a different continent from the border source */
2120 other_continent = TRUE;
2121 }
2122 } adjc_iterate_end;
2123 if (!other_continent && ocean_tiles <= 2) {
2124 return TRUE;
2125 } else {
2126 return FALSE;
2127 }
2128}
2129
2130/**********************************************************************/
2133 static void map_unit_homecity_enqueue(struct tile *ptile)
2134{
2135 unit_list_iterate(ptile->units, punit) {
2136 struct city *phome = game_city_by_number(punit->homecity);
2137
2138 if (NULL == phome) {
2139 continue;
2140 }
2141
2142 city_refresh_queue_add(phome);
2143 } unit_list_iterate_end;
2144}
2145
2146/**********************************************************************/
2149 static void map_claim_border_ownership(struct tile *ptile,
2150 struct player *powner,
2151 struct tile *psource)
2152{
2153 struct player *ploser = tile_owner(ptile);
2154
2155 if ((ploser != powner && ploser != NULL)
2156 && (BORDERS_SEE_INSIDE == game.info.borders
2157 || BORDERS_EXPAND == game.info.borders
2158 || ploser->server.border_vision)) {
2159 const v_radius_t radius_sq = V_RADIUS(-1, 0, 0);
2160
2161 shared_vision_change_seen(ploser, ptile, radius_sq, FALSE);
2162 }
2163
2164 if (powner != NULL
2165 && (BORDERS_SEE_INSIDE == game.info.borders
2166 || BORDERS_EXPAND == game.info.borders
2167 || powner->server.border_vision)) {
2168 const v_radius_t radius_sq = V_RADIUS(1, 0, 0);
2169
2170 shared_vision_change_seen(powner, ptile, radius_sq, TRUE);
2171 }
2172
2173 tile_set_owner(ptile, powner, psource);
2174
2175 /* Needed only when foggedborders enabled, but we do it unconditionally
2176 * in case foggedborders ever gets enabled later. Better to have correct
2177 * information in player map just in case. */
2178 update_tile_knowledge(ptile);
2179
2180 if (ploser != powner) {
2181 if (S_S_RUNNING == server_state() && game.info.happyborders != HB_DISABLED) {
2182 map_unit_homecity_enqueue(ptile);
2183 }
2184
2185 if (!city_map_update_tile_frozen(ptile)) {
2186 send_tile_info(NULL, ptile, FALSE);
2187 }
2188 }
2189}
2190
2191/**********************************************************************/
2194 void map_claim_ownership(struct tile *ptile, struct player *powner,
2195 struct tile *psource, bool claim_bases)
2196{
2197 map_claim_border_ownership(ptile, powner, psource);
2198
2199 if (claim_bases) {
2200 tile_claim_bases(ptile, powner);
2201 }
2202}
2203
2204/**********************************************************************/
2207 void tile_claim_bases(struct tile *ptile, struct player *powner)
2208{
2209 struct player *base_loser = extra_owner(ptile);
2210
2211 /* This MUST be before potentially recursive call to map_claim_base(),
2212 * so that the recursive call will get new owner == base_loser and
2213 * abort recursion. */
2214 ptile->extras_owner = powner;
2215
2216 extra_type_by_cause_iterate(EC_BASE, pextra) {
2217 map_claim_base(ptile, pextra, powner, base_loser);
2218 } extra_type_by_cause_iterate_end;
2219}
2220
2221/**********************************************************************/
2224 void map_clear_border(struct tile *ptile)
2225{
2226 int radius_sq = tile_border_source_radius_sq(ptile);
2227
2228 circle_dxyr_iterate(&(wld.map), ptile, radius_sq, dtile, dx, dy, dr) {
2229 struct tile *claimer = tile_claimer(dtile);
2230
2231 if (claimer == ptile) {
2232 map_claim_ownership(dtile, NULL, NULL, FALSE);
2233 }
2234 } circle_dxyr_iterate_end;
2235}
2236
2237/**********************************************************************/
2241 void map_update_border(struct tile *ptile, struct player *owner,
2242 int old_radius_sq, int new_radius_sq)
2243{
2244 if (old_radius_sq == new_radius_sq) {
2245 /* No change */
2246 return;
2247 }
2248
2249 if (BORDERS_DISABLED == game.info.borders) {
2250 return;
2251 }
2252
2253 if (old_radius_sq < new_radius_sq) {
2254 map_claim_border(ptile, owner, new_radius_sq);
2255 } else {
2256 circle_dxyr_iterate(&(wld.map), ptile, old_radius_sq, dtile, dx, dy, dr) {
2257 if (dr > new_radius_sq) {
2258 struct tile *claimer = tile_claimer(dtile);
2259
2260 if (claimer == ptile) {
2261 map_claim_ownership(dtile, NULL, NULL, FALSE);
2262 }
2263 }
2264 } circle_dxyr_iterate_end;
2265 }
2266}
2267
2268/**********************************************************************/
2273 void map_claim_border(struct tile *ptile, struct player *owner,
2274 int radius_sq)
2275{
2276 if (BORDERS_DISABLED == game.info.borders) {
2277 return;
2278 }
2279
2280 if (owner == NULL) {
2281 /* Clear the border instead of claiming. Code below this block
2282 * cannot handle NULL owner. */
2283 map_clear_border(ptile);
2284
2285 return;
2286 }
2287
2288 if (radius_sq < 0) {
2289 radius_sq = tile_border_source_radius_sq(ptile);
2290 }
2291
2292 circle_dxyr_iterate(&(wld.map), ptile, radius_sq, dtile, dx, dy, dr) {
2293 struct tile *dclaimer = tile_claimer(dtile);
2294
2295 if (dclaimer == ptile) {
2296 /* Already claimed by the ptile */
2297 continue;
2298 }
2299
2300 if (dr != 0 && is_border_source(dtile)) {
2301 /* Do not claim border sources other than self */
2302 /* Note that this is extremely important at the moment for
2303 * base claiming to work correctly in case there's two
2304 * fortresses near each other. There could be infinite
2305 * recursion in them claiming each other. */
2306 continue;
2307 }
2308
2309 if (!map_is_known(dtile, owner) && game.info.borders < BORDERS_EXPAND) {
2310 continue;
2311 }
2312
2313 /* Always claim source itself (distance, dr, to it 0) */
2314 if (dr != 0 && NULL != dclaimer && dclaimer != ptile) {
2315 struct city *ccity = tile_city(dclaimer);
2316 int strength_old, strength_new;
2317
2318 if (ccity != NULL) {
2319 /* Previously claimed by city */
2320 int city_x, city_y;
2321
2322 map_distance_vector(&city_x, &city_y, ccity->tile, dtile);
2323
2324 if (map_vector_to_sq_distance(city_x, city_y)
2325 <= city_map_radius_sq_get(ccity)
2326 + game.info.border_city_permanent_radius_sq) {
2327 /* Tile is within region permanently claimed by city */
2328 continue;
2329 }
2330 }
2331
2332 strength_old = tile_border_strength(dtile, dclaimer);
2333 strength_new = tile_border_strength(dtile, ptile);
2334
2335 if (strength_new <= strength_old) {
2336 /* Stronger shall prevail,
2337 * in case of equal strength older shall prevail */
2338 continue;
2339 }
2340 }
2341
2342 if (is_ocean_tile(dtile)) {
2343 /* Only certain water tiles are claimable */
2344 if (is_claimable_ocean(dtile, ptile, owner)) {
2345 map_claim_ownership(dtile, owner, ptile, dr == 0);
2346 }
2347 } else {
2348 /* Only land tiles on the same island as the border source
2349 * are claimable */
2350 if (tile_continent(dtile) == tile_continent(ptile)) {
2351 map_claim_ownership(dtile, owner, ptile, dr == 0);
2352 }
2353 }
2354 } circle_dxyr_iterate_end;
2355}
2356
2357/**********************************************************************/
2360 void map_calculate_borders(void)
2361{
2362 if (BORDERS_DISABLED == game.info.borders) {
2363 return;
2364 }
2365
2366 if (wld.map.tiles == NULL) {
2367 /* Map not yet initialized */
2368 return;
2369 }
2370
2371 log_verbose("map_calculate_borders()");
2372
2373 whole_map_iterate(&(wld.map), ptile) {
2374 if (is_border_source(ptile)) {
2375 map_claim_border(ptile, ptile->owner, -1);
2376 }
2377 } whole_map_iterate_end;
2378
2379 log_verbose("map_calculate_borders() workers");
2380 city_thaw_workers_queue();
2381 city_refresh_queue_processing();
2382}
2383
2384/**********************************************************************/
2387 void map_claim_base(struct tile *ptile, struct extra_type *pextra,
2388 struct player *powner, struct player *ploser)
2389{
2390 struct base_type *pbase;
2391 bv_player *could_see_unit = NULL;
2392 int units_num = 0;
2393 int ul_size;
2394
2395 if (!tile_has_extra(ptile, pextra)) {
2396 return;
2397 }
2398
2399 if (pextra->eus != EUS_NORMAL) {
2400 ul_size = unit_list_size(ptile->units);
2401 } else {
2402 ul_size = 0;
2403 }
2404
2405 int stored_units[ul_size + 1];
2406
2407 if (ul_size > 0) {
2408 int i;
2409
2410 could_see_unit = fc_malloc(sizeof(*could_see_unit) * ul_size);
2411
2412 unit_list_iterate(ptile->units, aunit) {
2413 stored_units[units_num++] = aunit->id;
2414 } unit_list_iterate_end;
2415
2416 fc_assert(units_num == ul_size);
2417
2418 for (i = 0; i < units_num; i++) {
2419 struct unit *aunit = game_unit_by_number(stored_units[i]);
2420
2421 BV_CLR_ALL(could_see_unit[i]);
2422 players_iterate(aplayer) {
2423 if (can_player_see_unit(aplayer, aunit)) {
2424 BV_SET(could_see_unit[i], player_index(aplayer));
2425 }
2426 } players_iterate_end;
2427 }
2428 }
2429
2430 pbase = extra_base_get(pextra);
2431
2432 fc_assert_ret(pbase != NULL);
2433
2434 /* Transfer base provided vision to new owner */
2435 if (powner != NULL) {
2436 const v_radius_t old_radius_sq = V_RADIUS(-1, -1, -1);
2437 const v_radius_t new_radius_sq = V_RADIUS(pbase->vision_main_sq,
2438 pbase->vision_invis_sq,
2439 pbase->vision_subs_sq);
2440
2441 map_vision_update(powner, ptile, old_radius_sq, new_radius_sq,
2442 game.server.vision_reveal_tiles);
2443 }
2444
2445 if (ploser != NULL) {
2446 const v_radius_t old_radius_sq = V_RADIUS(pbase->vision_main_sq,
2447 pbase->vision_invis_sq,
2448 pbase->vision_subs_sq);
2449 const v_radius_t new_radius_sq = V_RADIUS(-1, -1, -1);
2450
2451 map_vision_update(ploser, ptile, old_radius_sq, new_radius_sq,
2452 game.server.vision_reveal_tiles);
2453 }
2454
2455 if (BORDERS_DISABLED != game.info.borders
2456 && territory_claiming_base(pbase) && powner != ploser) {
2457 /* Clear borders from old owner. New owner may not know all those
2458 * tiles and thus does not claim them when borders mode is less
2459 * than EXPAND. */
2460 if (ploser != NULL) {
2461 /* Set this particular tile owner by NULL so in recursion
2462 * both loser and owner will be NULL. */
2463 map_claim_border_ownership(ptile, NULL, ptile);
2464 map_clear_border(ptile);
2465 }
2466
2467 /* We here first claim this tile ownership -> now on extra_owner()
2468 * will return new owner. Then we claim border, which will recursively
2469 * lead to this tile and base being claimed. But at that point
2470 * ploser == powner and above check will abort the recursion. */
2471 if (powner != NULL) {
2472 map_claim_border_ownership(ptile, powner, ptile);
2473 map_claim_border(ptile, powner, -1);
2474 }
2475 city_thaw_workers_queue();
2476 city_refresh_queue_processing();
2477 }
2478
2479 if (units_num > 0) {
2480 int i;
2481
2482 for (i = 0; i < units_num; i++) {
2483 struct unit *aunit = game_unit_by_number(stored_units[i]);
2484
2485 players_iterate(aplayer) {
2486 if (can_player_see_unit(aplayer, aunit)) {
2487 if (!BV_ISSET(could_see_unit[i], player_index(aplayer))) {
2488 send_unit_info(aplayer->connections, aunit);
2489 }
2490 } else {
2491 if (BV_ISSET(could_see_unit[i], player_index(aplayer))) {
2492 unit_goes_out_of_sight(aplayer, aunit);
2493 }
2494 }
2495 } players_iterate_end;
2496 }
2497
2498 free(could_see_unit);
2499 }
2500}
2501
2502/**********************************************************************/
2508 void vision_change_sight(struct vision *vision, const v_radius_t radius_sq)
2509{
2510 map_vision_update(vision->player, vision->tile, vision->radius_sq,
2511 radius_sq, vision->can_reveal_tiles);
2512 memcpy(vision->radius_sq, radius_sq, sizeof(v_radius_t));
2513}
2514
2515/**********************************************************************/
2520 void vision_clear_sight(struct vision *vision)
2521{
2522 const v_radius_t vision_radius_sq = V_RADIUS(-1, -1, -1);
2523
2524 vision_change_sight(vision, vision_radius_sq);
2525}
2526
2527/**********************************************************************/
2530 void create_extra(struct tile *ptile, struct extra_type *pextra,
2531 struct player *pplayer)
2532{
2533 bool extras_removed = FALSE;
2534
2535 extra_type_iterate(old_extra) {
2536 if (tile_has_extra(ptile, old_extra)
2537 && !can_extras_coexist(old_extra, pextra)) {
2538 destroy_extra(ptile, old_extra);
2539 extras_removed = TRUE;
2540 }
2541 } extra_type_iterate_end;
2542
2543 if (pextra->eus != EUS_NORMAL) {
2544 unit_list_iterate(ptile->units, aunit) {
2545 if (is_native_extra_to_utype(pextra, unit_type_get(aunit))) {
2546 players_iterate(aplayer) {
2547 if (!pplayers_allied(pplayer, aplayer)
2548 && can_player_see_unit(aplayer, aunit)) {
2549 unit_goes_out_of_sight(aplayer, aunit);
2550 }
2551 } players_iterate_end;
2552 }
2553 } unit_list_iterate_end;
2554 }
2555
2556 tile_add_extra(ptile, pextra);
2557
2558 /* Watchtower might become effective. */
2559 unit_list_refresh_vision(ptile->units);
2560
2561 if (pextra->data.base != NULL) {
2562 /* Claim bases on tile */
2563 if (pplayer) {
2564 struct player *old_owner = extra_owner(ptile);
2565
2566 /* Created base from NULL -> pplayer */
2567 map_claim_base(ptile, pextra, pplayer, NULL);
2568
2569 if (old_owner != pplayer) {
2570 /* Existing bases from old_owner -> pplayer */
2571 extra_type_by_cause_iterate(EC_BASE, oldbase) {
2572 if (oldbase != pextra) {
2573 map_claim_base(ptile, oldbase, pplayer, old_owner);
2574 }
2575 } extra_type_by_cause_iterate_end;
2576
2577 ptile->extras_owner = pplayer;
2578 }
2579 } else {
2580 /* Player who already owns bases on tile claims new base */
2581 map_claim_base(ptile, pextra, extra_owner(ptile), NULL);
2582 }
2583 }
2584
2585 if (extras_removed) {
2586 /* Maybe conflicting extra that was removed was the only thing
2587 * making tile native to some unit. */
2588 bounce_units_on_terrain_change(ptile);
2589 }
2590}
2591
2592/**********************************************************************/
2595 void destroy_extra(struct tile *ptile, struct extra_type *pextra)
2596{
2597 bv_player base_seen;
2598 bool real = tile_map_check(&(wld.map), ptile);
2599
2600 /* Remember what players were able to see the base. */
2601 if (real) {
2602 BV_CLR_ALL(base_seen);
2603 players_iterate(pplayer) {
2604 if (map_is_known_and_seen(ptile, pplayer, V_MAIN)) {
2605 BV_SET(base_seen, player_index(pplayer));
2606 }
2607 } players_iterate_end;
2608 }
2609
2610 if (real && is_extra_caused_by(pextra, EC_BASE)) {
2611 struct base_type *pbase = extra_base_get(pextra);
2612 struct player *owner = extra_owner(ptile);
2613
2614 if (territory_claiming_base(pbase)) {
2615 map_clear_border(ptile);
2616 }
2617
2618 if (NULL != owner
2619 && (0 <= pbase->vision_main_sq || 0 <= pbase->vision_invis_sq)) {
2620 /* Base provides vision, but no borders. */
2621 const v_radius_t old_radius_sq =
2622 V_RADIUS(0 <= pbase->vision_main_sq ? pbase->vision_main_sq : -1,
2623 0 <= pbase->vision_invis_sq ? pbase->vision_invis_sq : -1,
2624 0 <= pbase->vision_subs_sq ? pbase->vision_subs_sq : -1);
2625 const v_radius_t new_radius_sq = V_RADIUS(-1, -1, -1);
2626
2627 map_vision_update(owner, ptile, old_radius_sq, new_radius_sq,
2628 game.server.vision_reveal_tiles);
2629 }
2630 }
2631
2632 tile_remove_extra(ptile, pextra);
2633
2634 if (real) {
2635 /* Remove base from vision of players which were able to see the base. */
2636 players_iterate(pplayer) {
2637 if (BV_ISSET(base_seen, player_index(pplayer))
2638 && update_player_tile_knowledge(pplayer, ptile)) {
2639 send_tile_info(pplayer->connections, ptile, FALSE);
2640 }
2641 } players_iterate_end;
2642
2643 if (pextra->eus != EUS_NORMAL) {
2644 struct player *eowner = extra_owner(ptile);
2645
2646 unit_list_iterate(ptile->units, aunit) {
2647 if (is_native_extra_to_utype(pextra, unit_type_get(aunit))) {
2648 players_iterate(aplayer) {
2649 if (can_player_see_unit(aplayer, aunit)
2650 && !pplayers_allied(aplayer, eowner)) {
2651 send_unit_info(aplayer->connections, aunit);
2652 }
2653 } players_iterate_end;
2654 }
2655 } unit_list_iterate_end;
2656 }
2657 }
2658}
2659
2660/**********************************************************************/
2670 bool give_distorted_map(struct player *pfrom, struct player *pto,
2671 int prob, bool reveal_cities)
2672{
2673 bool updt = FALSE;
2674
2675 buffer_shared_vision(pto);
2676
2677 whole_map_iterate(&(wld.map), ptile) {
2678 if (fc_rand(100) < prob) {
2679 updt |= give_tile_info_from_player_to_player(pfrom, pto, ptile);
2680 } else if (reveal_cities && NULL != tile_city(ptile)) {
2681 updt|= give_tile_info_from_player_to_player(pfrom, pto, ptile);
2682 }
2683 } whole_map_iterate_end;
2684
2685 unbuffer_shared_vision(pto);
2686
2687 return updt;
2688}
2689
2690/**********************************************************************/
2698 void tile_change_side_effects(struct tile *ptile, bool refresh_city)
2699{
2700 struct city *pcity = ptile->worked;
2701
2702 /* Check the unit activities. */
2703 unit_activities_cancel_all_illegal_area(ptile);
2704
2705 if (pcity != NULL && !is_free_worked(pcity, ptile)
2706 && get_city_tile_output_bonus(pcity, ptile, NULL, EFT_TILE_WORKABLE) <= 0) {
2707 city_map_update_empty(pcity, ptile);
2708 pcity->specialists[DEFAULT_SPECIALIST]++;
2709
2710 if (refresh_city) {
2711 auto_arrange_workers(pcity);
2712 send_city_info(NULL, pcity);
2713 }
2714 }
2715}
ACTION_NONE
#define ACTION_NONE
Definition actions.h:55
is_adv_data_phase_open
bool is_adv_data_phase_open(struct player *pplayer)
Definition advdata.c:242
adv_data_phase_init
bool adv_data_phase_init(struct player *pplayer, bool is_new_phase)
Definition advdata.c:262
adv_data_phase_done
void adv_data_phase_done(struct player *pplayer)
Definition advdata.c:564
advdata.h
ai.h
CALL_FUNC_EACH_AI
#define CALL_FUNC_EACH_AI(_func,...)
Definition ai.h:387
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:3245
send_city_info
void send_city_info(struct player *dest, struct city *pcity)
Definition citytools.c:2344
update_dumb_city
bool update_dumb_city(struct player *pplayer, struct city *pcity)
Definition citytools.c:2744
sync_cities
void sync_cities(void)
Definition citytools.c:3319
city_map_update_tile_frozen
bool city_map_update_tile_frozen(struct tile *ptile)
Definition citytools.c:3302
remove_dumb_city
void remove_dumb_city(struct player *pplayer, struct tile *ptile)
Definition citytools.c:2836
city_landlocked_sell_coastal_improvements
void city_landlocked_sell_coastal_improvements(struct tile *ptile)
Definition citytools.c:3372
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:2396
city_thaw_workers_queue
void city_thaw_workers_queue(void)
Definition citytools.c:192
reality_check_city
void reality_check_city(struct player *pplayer, struct tile *ptile)
Definition citytools.c:2815
citytools.h
auto_arrange_workers
void auto_arrange_workers(struct city *pcity)
Definition cityturn.c:365
city_refresh_queue_add
void city_refresh_queue_add(struct city *pcity)
Definition cityturn.c:196
city_refresh_queue_processing
void city_refresh_queue_processing(void)
Definition cityturn.c:212
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:1301
MAX_EXTRA_TYPES
#define MAX_EXTRA_TYPES
Definition fc_types.h:50
Continent_id
signed short Continent_id
Definition fc_types.h:376
BORDERS_DISABLED
@ BORDERS_DISABLED
Definition fc_types.h:1047
BORDERS_SEE_INSIDE
@ BORDERS_SEE_INSIDE
Definition fc_types.h:1049
BORDERS_EXPAND
@ BORDERS_EXPAND
Definition fc_types.h:1050
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:1126
unit_tile_link
const char * unit_tile_link(const struct unit *punit)
Definition featured_text.c:1143
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:1026
rand_map_pos
struct tile * rand_map_pos(const struct civ_map *nmap)
Definition map.c:1102
map_vector_to_sq_distance
int map_vector_to_sq_distance(int dx, int dy)
Definition map.c:620
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:748
map_distance_vector
void map_distance_vector(int *dx, int *dy, const struct tile *tile0, const struct tile *tile1)
Definition map.c:1087
map.h
adjc_iterate_end
#define adjc_iterate_end
Definition map.h:419
circle_dxyr_iterate
#define circle_dxyr_iterate(nmap, center_tile, sq_radius, _tile, dx, dy, dr)
Definition map.h:395
cardinal_adjc_iterate_end
#define cardinal_adjc_iterate_end
Definition map.h:445
adjc_iterate
#define adjc_iterate(nmap, center_tile, itr_tile)
Definition map.h:414
circle_dxyr_iterate_end
#define circle_dxyr_iterate_end
Definition map.h:406
cardinal_adjc_iterate
#define cardinal_adjc_iterate(nmap, center_tile, itr_tile)
Definition map.h:441
circle_iterate
#define circle_iterate(nmap, center_tile, sq_radius, tile_itr)
Definition map.h:387
whole_map_iterate
#define whole_map_iterate(_map, _tile)
Definition map.h:531
MAP_TILE_OWNER_NULL
#define MAP_TILE_OWNER_NULL
Definition map.h:588
whole_map_iterate_end
#define whole_map_iterate_end
Definition map.h:540
circle_iterate_end
#define circle_iterate_end
Definition map.h:390
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:1225
terrain_change_bounce_single_unit
static void terrain_change_bounce_single_unit(struct unit *punit, struct tile *from)
Definition maphand.c:1831
update_player_tile_last_seen
void update_player_tile_last_seen(struct player *pplayer, struct tile *ptile)
Definition maphand.c:1471
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:674
vision_clear_sight
void vision_clear_sight(struct vision *vision)
Definition maphand.c:2520
map_claim_base
void map_claim_base(struct tile *ptile, struct extra_type *pextra, struct player *powner, struct player *ploser)
Definition maphand.c:2387
map_set_border_vision
void map_set_border_vision(struct player *pplayer, const bool is_enabled)
Definition maphand.c:747
map_claim_ownership
void map_claim_ownership(struct tile *ptile, struct player *powner, struct tile *psource, bool claim_bases)
Definition maphand.c:2194
player_tile_own_seen
static int player_tile_own_seen(const struct player_tile *plrtile, enum vision_layer vlayer)
Definition maphand.c:1140
map_is_known
bool map_is_known(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:901
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:916
send_map_info
void send_map_info(struct conn_list *dest)
Definition maphand.c:655
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:1489
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:2595
check_units_single_tile
static void check_units_single_tile(struct tile *ptile)
Definition maphand.c:1885
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:1562
disable_fog_of_war
void disable_fog_of_war(void)
Definition maphand.c:1789
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:646
map_know_and_see_all
void map_know_and_see_all(struct player *pplayer)
Definition maphand.c:1200
map_change_own_seen
static void map_change_own_seen(struct player *pplayer, struct tile *ptile, const v_radius_t change)
Definition maphand.c:1149
show_map_to_all
void show_map_to_all(void)
Definition maphand.c:1214
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:1402
map_get_seen
static int map_get_seen(const struct player *pplayer, const struct tile *ptile, enum vision_layer vlayer)
Definition maphand.c:941
ocean_to_land_fix_rivers
static void ocean_to_land_fix_rivers(struct tile *ptile)
Definition maphand.c:1805
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:1915
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:1697
need_to_reassign_continents
bool need_to_reassign_continents(const struct terrain *oldter, const struct terrain *newter)
Definition maphand.c:1930
is_claimable_ocean
static bool is_claimable_ocean(struct tile *ptile, struct tile *source, struct player *pplayer)
Definition maphand.c:2080
map_get_player_city
struct vision_site * map_get_player_city(const struct tile *ptile, const struct player *pplayer)
Definition maphand.c:1371
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:2207
disable_fog_of_war_player
void disable_fog_of_war_player(struct player *pplayer)
Definition maphand.c:1775
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:1765
send_tile_suppressed
static bool send_tile_suppressed
Definition maphand.c:65
create_vision_dependencies
static void create_vision_dependencies(void)
Definition maphand.c:1602
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:2530
map_update_border
void map_update_border(struct tile *ptile, struct player *owner, int old_radius_sq, int new_radius_sq)
Definition maphand.c:2241
map_set_known
void map_set_known(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1182
map_show_all
void map_show_all(struct player *pplayer)
Definition maphand.c:886
map_unit_homecity_enqueue
static void map_unit_homecity_enqueue(struct tile *ptile)
Definition maphand.c:2133
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:954
map_show_tile
void map_show_tile(struct player *src_player, struct tile *ptile)
Definition maphand.c:775
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:2698
player_tile_init
static void player_tile_init(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1332
terrain_changed
void terrain_changed(struct tile *ptile)
Definition maphand.c:1949
player_map_free
void player_map_free(struct player *pplayer)
Definition maphand.c:1241
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:2149
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:927
change_playertile_site
void change_playertile_site(struct player_tile *ptile, struct vision_site *new_site)
Definition maphand.c:1163
map_calculate_borders
void map_calculate_borders(void)
Definition maphand.c:2360
fix_tile_on_terrain_change
void fix_tile_on_terrain_change(struct tile *ptile, struct terrain *oldter, bool extend_rivers)
Definition maphand.c:1968
enable_fog_of_war_player
void enable_fog_of_war_player(struct player *pplayer)
Definition maphand.c:1751
map_show_circle
void map_show_circle(struct player *pplayer, struct tile *ptile, int radius_sq)
Definition maphand.c:871
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:692
map_claim_border
void map_claim_border(struct tile *ptile, struct player *owner, int radius_sq)
Definition maphand.c:2273
update_tile_knowledge
void update_tile_knowledge(struct tile *ptile)
Definition maphand.c:1443
remove_player_from_maps
void remove_player_from_maps(struct player *pplayer)
Definition maphand.c:1262
give_shared_vision
void give_shared_vision(struct player *pfrom, struct player *pto)
Definition maphand.c:1636
check_terrain_change
void check_terrain_change(struct tile *ptile, struct terrain *oldter)
Definition maphand.c:1988
give_distorted_map
bool give_distorted_map(struct player *pfrom, struct player *pto, int prob, bool reveal_cities)
Definition maphand.c:2670
map_hide_tile
void map_hide_tile(struct player *src_player, struct tile *ptile)
Definition maphand.c:827
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:1582
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:2224
map_clear_known
void map_clear_known(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1190
player_tile_free
static void player_tile_free(struct tile *ptile, struct player *pplayer)
Definition maphand.c:1357
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:1386
vision_change_sight
void vision_change_sight(struct vision *vision, const v_radius_t radius_sq)
Definition maphand.c:2508
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:318
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:10831
send_packet_tile_info
int send_packet_tile_info(struct connection *pc, const struct packet_tile_info *packet)
Definition packets_gen.c:4036
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:1409
gives_shared_vision
bool gives_shared_vision(const struct player *me, const struct player *them)
Definition player.c:1489
player.h
players_iterate_end
#define players_iterate_end
Definition player.h:539
players_iterate
#define players_iterate(_pplayer)
Definition player.h:534
send_player_info_c
void send_player_info_c(struct player *src, struct conn_list *dest)
Definition plrhand.c:1146
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:376
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:337
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:84
civ_map::north_latitude
int north_latitude
Definition map_types.h:80
civ_map::south_latitude
int south_latitude
Definition map_types.h:81
civ_map::altitude_info
bool altitude_info
Definition map_types.h:74
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:40
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:135
packet_game_info::happyborders
enum happyborders_type happyborders
Definition packets_gen.h:183
packet_game_info::turn
int turn
Definition packets_gen.h:247
packet_game_info::year
int year
Definition packets_gen.h:249
packet_game_info::border_city_permanent_radius_sq
int border_city_permanent_radius_sq
Definition packets_gen.h:134
packet_game_info::fogofwar
bool fogofwar
Definition packets_gen.h:156
packet_map_info
Definition packets_gen.h:273
packet_map_info::xsize
int xsize
Definition packets_gen.h:274
packet_scenario_info::lake_flooding
bool lake_flooding
Definition packets_gen.h:1620
packet_tile_info
Definition packets_gen.h:103
packet_tile_info::resource
Resource_type_id resource
Definition packets_gen.h:111
packet_tile_info::extras
bv_extras extras
Definition packets_gen.h:112
packet_tile_info::place_turn
int place_turn
Definition packets_gen.h:114
packet_tile_info::placing
int placing
Definition packets_gen.h:113
packet_tile_info::owner
int owner
Definition packets_gen.h:107
packet_tile_info::known
enum known_type known
Definition packets_gen.h:106
packet_tile_info::label
char label[MAX_LEN_MAP_LABEL]
Definition packets_gen.h:117
packet_tile_info::extras_owner
int extras_owner
Definition packets_gen.h:108
packet_tile_info::tile
int tile
Definition packets_gen.h:104
packet_tile_info::continent
Continent_id continent
Definition packets_gen.h:105
packet_tile_info::terrain
Terrain_type_id terrain
Definition packets_gen.h:110
packet_tile_info::worked
int worked
Definition packets_gen.h:109
packet_tile_info::altitude
int altitude
Definition packets_gen.h:115
packet_tile_info::spec_sprite
char spec_sprite[MAX_LEN_NAME]
Definition packets_gen.h:116
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:249
player::cities
struct city_list * cities
Definition player.h:281
player::tile_known
struct dbv tile_known
Definition player.h:310
player::connections
struct conn_list * connections
Definition player.h:298
player::private_map
struct player_tile * private_map
Definition player.h:324
player::border_vision
bool border_vision
Definition player.h:327
player::server
struct player::@70::@72 server
terrain
Definition terrain.h:75
terrain::cooler_wetter_result
struct terrain * cooler_wetter_result
Definition terrain.h:134
terrain::cooler_drier_result
struct terrain * cooler_drier_result
Definition terrain.h:134
terrain::warmer_wetter_result
struct terrain * warmer_wetter_result
Definition terrain.h:133
terrain::warmer_drier_result
struct terrain * warmer_drier_result
Definition terrain.h:133
tile
Definition tile.h:50
tile::spec_sprite
char * spec_sprite
Definition tile.h:67
tile::label
char * label
Definition tile.h:66
tile::altitude
int altitude
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:576
unit
Definition unit.h:140
unit::activity
enum unit_activity activity
Definition unit.h:159
unit::id
int id
Definition unit.h:147
unit::server
struct unit::@81::@84 server
unit::activity_target
struct extra_type * activity_target
Definition unit.h:167
unit::homecity
int homecity
Definition unit.h:148
unit::dying
bool dying
Definition unit.h:253
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:62
is_ocean
#define is_ocean(pterrain)
Definition terrain.h:194
is_ocean_tile
#define is_ocean_tile(ptile)
Definition terrain.h:196
T_NONE
#define T_NONE
Definition terrain.h:61
terrain_has_flag
#define terrain_has_flag(terr, flag)
Definition terrain.h:176
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:1067
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:101
tile_index
#define tile_index(_pt_)
Definition tile.h:89
tile_worked
#define tile_worked(_tile)
Definition tile.h:115
tile_resource
#define tile_resource(_tile)
Definition tile.h:103
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:111
TILE_XY
#define TILE_XY(ptile)
Definition tile.h:43
tile_continent
#define tile_continent(_tile)
Definition tile.h:93
tile_has_extra
#define tile_has_extra(ptile, pextra)
Definition tile.h:148
tile_owner
#define tile_owner(_tile)
Definition tile.h:97
get_transporter_occupancy
int get_transporter_occupancy(const struct unit *ptrans)
Definition unit.c:1816
unit_is_alive
bool unit_is_alive(int id)
Definition unit.c:2286
unit_transported
bool unit_transported(const struct unit *pcargo)
Definition unit.c:2469
unit_transport_cargo
struct unit_list * unit_transport_cargo(const struct unit *ptrans)
Definition unit.c:2495
unit.h
unit_tile
#define unit_tile(_pu)
Definition unit.h:397
unit_owner
#define unit_owner(_pu)
Definition unit.h:396
is_non_allied_unit_tile
static bool is_non_allied_unit_tile(const struct tile *ptile, const struct player *pplayer, bool everyone_non_allied)
Definition unit.h:433
unit_activity_handling
bool unit_activity_handling(struct unit *punit, enum unit_activity new_activity, enum gen_action trigger_action)
Definition unithand.c:6603
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:2863
send_unit_info
void send_unit_info(struct conn_list *dest, struct unit *punit)
Definition unittools.c:2876
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:2139
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:4068
unit_list_refresh_vision
void unit_list_refresh_vision(struct unit_list *punitlist)
Definition unittools.c:5011
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
unit_has_type_flag
bool unit_has_type_flag(const struct unit *punit, enum unit_type_flag_id flag)
Definition unittype.c:190
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
MAP_NATIVE_WIDTH
#define MAP_NATIVE_WIDTH
Definition world_object.h:55
MAP_INDEX_SIZE
#define MAP_INDEX_SIZE
Definition world_object.h:52
MAP_NATIVE_HEIGHT
#define MAP_NATIVE_HEIGHT
Definition world_object.h:56