common/tile.c

   1 /**********************************************************************
   2  Freeciv - Copyright (C) 2005 - The Freeciv Project
   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 "log.h"
  21 #include "support.h"
  22
  23 /* common */
  24 #include "fc_interface.h"
  25 #include "game.h"
  26 #include "movement.h"
  27 #include "road.h"
  28 #include "unit.h"
  29 #include "unitlist.h"
  30
  31 #include "tile.h"
  32
  33 #ifndef tile_index
  34 /****************************************************************************
  35   Return the tile index.
  36 ****************************************************************************/
  37 int tile_index(const struct tile *ptile)
  38 {
  39   return ptile->index;
  40 }
  41 #endif
  42
  43 #ifndef tile_owner
  44 /****************************************************************************
  45   Return the player who owns this tile (or NULL if none).
  46 ****************************************************************************/
  47 struct player *tile_owner(const struct tile *ptile)
  48 {
  49   return ptile->owner;
  50 }
  51 #endif
  52
  53 #ifndef tile_claimer
  54 /****************************************************************************
  55   Return the player who owns this tile (or NULL if none).
  56 ****************************************************************************/
  57 struct tile *tile_claimer(const struct tile *ptile)
  58 {
  59   return ptile->claimer;
  60 }
  61 #endif
  62
  63 /****************************************************************************
  64   Set the owner of a tile (may be NULL).
  65 ****************************************************************************/
  66 void tile_set_owner(struct tile *ptile, struct player *pplayer,
  67                     struct tile *claimer)
  68 {
  69   if (BORDERS_DISABLED != game.info.borders) {
  70     ptile->owner = pplayer;
  71     ptile->claimer = claimer;
  72   }
  73 }
  74
  75 /****************************************************************************
  76   Return the city on this tile (or NULL), checking for city center.
  77 ****************************************************************************/
  78 struct city *tile_city(const struct tile *ptile)
  79 {
  80   struct city *pcity = ptile->worked;
  81
  82   if (NULL != pcity && is_city_center(pcity, ptile)) {
  83     return pcity;
  84   }
  85   return NULL;
  86 }
  87
  88 #ifndef tile_worked
  89 /****************************************************************************
  90   Return any city working the specified tile (or NULL).
  91 ****************************************************************************/
  92 struct city *tile_worked(const struct tile *ptile)
  93 {
  94   return ptile->worked;
  95 }
  96 #endif
  97
  98 /****************************************************************************
  99   Set the city/worker on the tile (may be NULL).
 100 ****************************************************************************/
 101 void tile_set_worked(struct tile *ptile, struct city *pcity)
 102 {
 103   ptile->worked = pcity;
 104 }
 105
 106 #ifndef tile_terrain
 107 /****************************************************************************
 108   Return the terrain at the specified tile.
 109 ****************************************************************************/
 110 struct terrain *tile_terrain(const struct tile *ptile)
 111 {
 112   return ptile->terrain;
 113 }
 114 #endif
 115
 116 /****************************************************************************
 117   Set the given terrain at the specified tile.
 118 ****************************************************************************/
 119 void tile_set_terrain(struct tile *ptile, struct terrain *pterrain)
 120 {
 121   /* The terrain change is valid if one of the following is TRUE:
 122    * - pterrain is NULL (= unknown terrain)
 123    * - ptile is a virtual tile
 124    * - pterrain does not has the flag TER_NO_CITIES
 125    * - there is no city on ptile.
 126    * This should be read as: The terrain change is INVALID if a terrain with
 127    * the flag TER_NO_CITIES is given for a real tile with a city (i.e. all
 128    * check evaluate to TRUE). */
 129   fc_assert_msg(NULL == pterrain
 130                 || tile_virtual_check(ptile)
 131                 || !terrain_has_flag(pterrain, TER_NO_CITIES)
 132                 || NULL == tile_city(ptile),
 133                 "At (%d, %d), the terrain \"%s\" (nb %d) doesn't "
 134                 "support cities, whereas \"%s\" (nb %d) is built there.",
 135                 TILE_XY(ptile), terrain_rule_name(pterrain),
 136                 terrain_number(pterrain), city_name(tile_city(ptile)),
 137                 tile_city(ptile)->id);
 138
 139   ptile->terrain = pterrain;
 140   if (NULL != pterrain
 141    && NULL != ptile->resource
 142    && terrain_has_resource(pterrain, ptile->resource)) {
 143     /* cannot use set_special() for internal values */
 144     BV_SET(ptile->special, S_RESOURCE_VALID);
 145   } else {
 146     BV_CLR(ptile->special, S_RESOURCE_VALID);
 147   }
 148 }
 149
 150 /****************************************************************************
 151   Return the specials of the tile.  See terrain.h.
 152
 153   Note that this returns a mask of _all_ the specials on the tile.  To
 154   check a specific special use tile_has_special.
 155 ****************************************************************************/
 156 bv_special tile_specials(const struct tile *ptile)
 157 {
 158   return ptile->special;
 159 }
 160
 161 /****************************************************************************
 162   Sets the tile's specials to those present in the given bit vector.
 163 ****************************************************************************/
 164 void tile_set_specials(struct tile *ptile, bv_special specials)
 165 {
 166   if (!ptile) {
 167     return;
 168   }
 169   ptile->special = specials;
 170 }
 171
 172 /****************************************************************************
 173   Returns TRUE iff the given tile has the given special.
 174 ****************************************************************************/
 175 bool tile_has_special(const struct tile *ptile,
 176                       enum tile_special_type special)
 177 {
 178   return contains_special(ptile->special, special);
 179 }
 180
 181 /****************************************************************************
 182   Returns TRUE iff the given tile has any specials.
 183 ****************************************************************************/
 184 bool tile_has_any_specials(const struct tile *ptile)
 185 {
 186   return contains_any_specials(ptile->special);
 187 }
 188
 189 /****************************************************************************
 190   Returns a bit vector of the bases present at the tile.
 191 ****************************************************************************/
 192 bv_bases tile_bases(const struct tile *ptile)
 193 {
 194   if (!ptile) {
 195     bv_bases empty;
 196     BV_CLR_ALL(empty);
 197     return empty;
 198   }
 199   return ptile->bases;
 200 }
 201
 202 /****************************************************************************
 203   Returns a bit vector of the roads present at the tile.
 204 ****************************************************************************/
 205 bv_roads tile_roads(const struct tile *ptile)
 206 {
 207   if (!ptile) {
 208     bv_roads empty;
 209     BV_CLR_ALL(empty);
 210     return empty;
 211   }
 212
 213   return ptile->roads;
 214 }
 215
 216 /****************************************************************************
 217   Set the bases on the tile to those present in the given bit vector.
 218 ****************************************************************************/
 219 void tile_set_bases(struct tile *ptile, bv_bases bases)
 220 {
 221   if (!ptile) {
 222     return;
 223   }
 224   ptile->bases = bases;
 225 }
 226
 227 /****************************************************************************
 228   Adds base to tile.
 229   FIXME: Should remove conflicting old base and return bool indicating that.
 230 ****************************************************************************/
 231 void tile_add_base(struct tile *ptile, const struct base_type *pbase)
 232 {
 233   BV_SET(ptile->bases, base_index(pbase));
 234 }
 235
 236 /****************************************************************************
 237   Removes base from tile if such exist
 238 ****************************************************************************/
 239 void tile_remove_base(struct tile *ptile, const struct base_type *pbase)
 240 {
 241   BV_CLR(ptile->bases, base_index(pbase));
 242 }
 243
 244 /****************************************************************************
 245   Check if tile contains base providing effect
 246 ****************************************************************************/
 247 bool tile_has_base_flag(const struct tile *ptile, enum base_flag_id flag)
 248 {
 249   base_type_iterate(pbase) {
 250     if (tile_has_base(ptile, pbase) && base_has_flag(pbase, flag)) {
 251       return TRUE;
 252     }
 253   } base_type_iterate_end;
 254
 255   return FALSE;
 256 }
 257
 258 /****************************************************************************
 259   Check if tile contains base providing effect for unit
 260 ****************************************************************************/
 261 bool tile_has_base_flag_for_unit(const struct tile *ptile,
 262                                  const struct unit_type *punittype,
 263                                  enum base_flag_id flag)
 264 {
 265   base_type_iterate(pbase) {
 266     if (tile_has_base(ptile, pbase)
 267         && base_has_flag_for_utype(pbase, flag, punittype)) {
 268       return TRUE;
 269     }
 270   } base_type_iterate_end;
 271
 272   return FALSE;
 273 }
 274
 275 /****************************************************************************
 276   Check if tile contains base providing effect for unit
 277 ****************************************************************************/
 278 bool tile_has_claimable_base(const struct tile *ptile,
 279                              const struct unit_type *punittype)
 280 {
 281   base_type_iterate(pbase) {
 282     if (tile_has_base(ptile, pbase)
 283         && territory_claiming_base(pbase)
 284         && is_native_base_to_uclass(pbase, utype_class(punittype))) {
 285       return TRUE;
 286     }
 287   } base_type_iterate_end;
 288
 289   return FALSE;
 290 }
 291
 292 /****************************************************************************
 293   Calculate defense bonus given for unit type by bases and roads
 294 ****************************************************************************/
 295 int tile_extras_defense_bonus(const struct tile *ptile,
 296                               const struct unit_type *punittype)
 297 {
 298   return tile_extras_class_defense_bonus(ptile, utype_class(punittype));
 299 }
 300
 301 /****************************************************************************
 302   Calculate defense bonus given for unit class by bases and roads
 303 ****************************************************************************/
 304 int tile_extras_class_defense_bonus(const struct tile *ptile,
 305                                     const struct unit_class *pclass)
 306 {
 307   int bonus = 0;
 308
 309   base_type_iterate(pbase) {
 310     if (tile_has_base(ptile, pbase)
 311         && is_native_base_to_uclass(pbase, pclass)) {
 312       bonus += pbase->defense_bonus;
 313     }
 314   } base_type_iterate_end;
 315
 316   road_type_iterate(proad) {
 317     if (tile_has_road(ptile, proad)
 318         && is_native_road_to_uclass(proad, pclass)) {
 319       bonus += proad->defense_bonus;
 320     }
 321   } road_type_iterate_end;
 322
 323   return bonus;
 324 }
 325
 326 /****************************************************************************
 327   Calculate output increment given by roads
 328 ****************************************************************************/
 329 int tile_roads_output_incr(const struct tile *ptile, enum output_type_id o)
 330 {
 331   int const_incr = 0;
 332   int incr = 0;
 333
 334   road_type_iterate(proad) {
 335     if (tile_has_road(ptile, proad)) {
 336       const_incr += proad->tile_incr_const[o];
 337       incr += proad->tile_incr[o];
 338     }
 339   } road_type_iterate_end;
 340
 341   return const_incr + incr * tile_terrain(ptile)->road_output_incr_pct[o] / 100;
 342 }
 343
 344 /****************************************************************************
 345   Calculate output bonus given by roads
 346 ****************************************************************************/
 347 int tile_roads_output_bonus(const struct tile *ptile, enum output_type_id o)
 348 {
 349   int bonus = 0;
 350
 351   road_type_iterate(proad) {
 352     if (tile_has_road(ptile, proad)) {
 353       bonus += proad->tile_bonus[o];
 354     }
 355   } road_type_iterate_end;
 356
 357   return bonus;
 358 }
 359
 360 /****************************************************************************
 361   Check if tile contains base native for unit
 362 ****************************************************************************/
 363 bool tile_has_native_base(const struct tile *ptile,
 364                           const struct unit_type *punittype)
 365 {
 366   base_type_iterate(pbase) {
 367     if (tile_has_base(ptile, pbase)
 368         && is_native_base_to_utype(pbase, punittype)) {
 369       return TRUE;
 370     }
 371   } base_type_iterate_end;
 372
 373   return FALSE;
 374 }
 375
 376 /****************************************************************************
 377   Add the given special or specials to the tile.
 378
 379   Note that this does not erase any existing specials already on the tile
 380   (see tile_clear_special or tile_clear_all_specials for that).  Also note
 381   the special to be set may be a mask, so you can set more than one
 382   special at a time (but this is not recommended).
 383 ****************************************************************************/
 384 void tile_set_special(struct tile *ptile, enum tile_special_type spe)
 385 {
 386   set_special(&ptile->special, spe);
 387 }
 388
 389 #ifndef tile_resource
 390 /****************************************************************************
 391   Return the resource at the specified tile.
 392 ****************************************************************************/
 393 const struct resource *tile_resource(const struct tile *ptile)
 394 {
 395   return ptile->resource;
 396 }
 397 #endif
 398
 399 /****************************************************************************
 400   Set the given resource at the specified tile.
 401 ****************************************************************************/
 402 void tile_set_resource(struct tile *ptile, struct resource *presource)
 403 {
 404   ptile->resource = presource;
 405   if (NULL != ptile->terrain
 406    && NULL != presource
 407    && terrain_has_resource(ptile->terrain, presource)) {
 408     /* cannot use set_special() for internal values */
 409     BV_SET(ptile->special, S_RESOURCE_VALID);
 410   } else {
 411     BV_CLR(ptile->special, S_RESOURCE_VALID);
 412   }
 413 }
 414
 415 /****************************************************************************
 416   Clear the given special or specials from the tile.
 417
 418   This function clears all the specials set in the 'spe' mask from the
 419   tile's set of specials.  All other specials are unaffected.
 420 ****************************************************************************/
 421 void tile_clear_special(struct tile *ptile, enum tile_special_type spe)
 422 {
 423   clear_special(&ptile->special, spe);
 424 }
 425
 426 /****************************************************************************
 427   Remove any and all specials from this tile.
 428 ****************************************************************************/
 429 void tile_clear_all_specials(struct tile *ptile)
 430 {
 431   clear_all_specials(&ptile->special);
 432 }
 433
 434 #ifndef tile_continent
 435 /****************************************************************************
 436   Return the continent ID of the tile.  Typically land has a positive
 437   continent number and ocean has a negative number; no tile should have
 438   a 0 continent number.
 439 ****************************************************************************/
 440 Continent_id tile_continent(const struct tile *ptile)
 441 {
 442   return ptile->continent;
 443 }
 444 #endif
 445
 446 /****************************************************************************
 447   Set the continent ID of the tile.  See tile_continent.
 448 ****************************************************************************/
 449 void tile_set_continent(struct tile *ptile, Continent_id val)
 450 {
 451   ptile->continent = val;
 452 }
 453
 454 /****************************************************************************
 455   Return a known_type enumeration value for the tile.
 456
 457   Note that the client only has known data about its own player.
 458 ****************************************************************************/
 459 enum known_type tile_get_known(const struct tile *ptile,
 460                                const struct player *pplayer)
 461 {
 462   if (!dbv_isset(&pplayer->tile_known, tile_index(ptile))) {
 463     return TILE_UNKNOWN;
 464   } else if (!fc_funcs->player_tile_vision_get(ptile, pplayer, V_MAIN)) {
 465     return TILE_KNOWN_UNSEEN;
 466   } else {
 467     return TILE_KNOWN_SEEN;
 468   }
 469 }
 470
 471 /****************************************************************************
 472   Time to complete the given activity on the given tile.
 473 ****************************************************************************/
 474 int tile_activity_time(enum unit_activity activity, const struct tile *ptile)
 475 {
 476   struct terrain *pterrain = tile_terrain(ptile);
 477
 478   /* Make sure nobody uses old activities */
 479   fc_assert_ret_val(activity != ACTIVITY_FORTRESS
 480                     && activity != ACTIVITY_AIRBASE, FC_INFINITY);
 481
 482   /* ACTIVITY_BASE not handled here */
 483   fc_assert_ret_val(activity != ACTIVITY_BASE, FC_INFINITY);
 484   fc_assert_ret_val(activity != ACTIVITY_GEN_ROAD, FC_INFINITY);
 485
 486   switch (activity) {
 487   case ACTIVITY_POLLUTION:
 488     return pterrain->clean_pollution_time * ACTIVITY_FACTOR;
 489   case ACTIVITY_MINE:
 490     return pterrain->mining_time * ACTIVITY_FACTOR;
 491   case ACTIVITY_IRRIGATE:
 492     return pterrain->irrigation_time * ACTIVITY_FACTOR;
 493   case ACTIVITY_TRANSFORM:
 494     return pterrain->transform_time * ACTIVITY_FACTOR;
 495   case ACTIVITY_FALLOUT:
 496     return pterrain->clean_fallout_time * ACTIVITY_FACTOR;
 497   default:
 498     return 0;
 499   }
 500 }
 501
 502 /****************************************************************************
 503   Time to complete the base building activity on the given tile.
 504 ****************************************************************************/
 505 int tile_activity_base_time(const struct tile *ptile,
 506                             Base_type_id base)
 507 {
 508   struct terrain *pterrain = tile_terrain(ptile);
 509
 510   return terrain_base_time(pterrain, base) * ACTIVITY_FACTOR;
 511 }
 512
 513 /****************************************************************************
 514   Time to complete the road building activity on the given tile.
 515 ****************************************************************************/
 516 int tile_activity_road_time(const struct tile *ptile,
 517                             Road_type_id road)
 518 {
 519   struct terrain *pterrain = tile_terrain(ptile);
 520
 521   return terrain_road_time(pterrain, road) * ACTIVITY_FACTOR;
 522 }
 523
 524 /****************************************************************************
 525   Clear all "dirtiness" (pollution and fallout) from the tile.
 526 ****************************************************************************/
 527 static void tile_clear_dirtiness(struct tile *ptile)
 528 {
 529   tile_clear_special(ptile, S_POLLUTION);
 530   tile_clear_special(ptile, S_FALLOUT);
 531 }
 532
 533 /****************************************************************************
 534   Change the terrain to the given type.  This does secondary tile updates to
 535   the tile (as will happen when mining/irrigation/transforming changes the
 536   tile's terrain).
 537 ****************************************************************************/
 538 void tile_change_terrain(struct tile *ptile, struct terrain *pterrain)
 539 {
 540   tile_set_terrain(ptile, pterrain);
 541
 542   if (is_ocean(pterrain)) {
 543     /* The code can't handle these specials in ocean. */
 544     tile_clear_special(ptile, S_HUT);
 545   }
 546
 547   if (terrain_has_flag(pterrain, TER_NO_POLLUTION)) {
 548     tile_clear_dirtiness(ptile);
 549   }
 550
 551   /* Clear mining/irrigation if resulting terrain type cannot support
 552    * that feature. */
 553   if (pterrain->mining_result != pterrain) {
 554     tile_clear_special(ptile, S_MINE);
 555   }
 556
 557   if (pterrain->irrigation_result != pterrain) {
 558     tile_clear_special(ptile, S_IRRIGATION);
 559     tile_clear_special(ptile, S_FARMLAND);
 560   }
 561
 562   /* Clear unsupported bases. */
 563   base_type_iterate(pbase) {
 564     if (tile_has_base(ptile, pbase)
 565         && !is_native_tile_to_base(pbase, ptile)) {
 566       if (fc_funcs->destroy_base != NULL) {
 567         /* Assume callback calls tile_remove_base() itself. */
 568         fc_funcs->destroy_base(ptile, pbase);
 569       } else {
 570         tile_remove_base(ptile, pbase);
 571       }
 572     }
 573   } base_type_iterate_end;
 574
 575   road_type_iterate(proad) {
 576     if (tile_has_road(ptile, proad)
 577         && !is_native_tile_to_road(proad, ptile)) {
 578       tile_remove_road(ptile, proad);
 579     }
 580   } road_type_iterate_end;
 581 }
 582
 583 /****************************************************************************
 584   Add the special to the tile.  This does secondary tile updates to
 585   the tile.
 586 ****************************************************************************/
 587 void tile_add_special(struct tile *ptile, enum tile_special_type special)
 588 {
 589   fc_assert_ret(special != S_OLD_FORTRESS && special != S_OLD_AIRBASE);
 590   fc_assert_ret(special != S_OLD_ROAD && special != S_OLD_RAILROAD && special != S_OLD_RIVER);
 591
 592   tile_set_special(ptile, special);
 593
 594   switch (special) {
 595   case S_FARMLAND:
 596     tile_add_special(ptile, S_IRRIGATION);
 597     /* Fall through to irrigation */
 598   case S_IRRIGATION:
 599     tile_clear_special(ptile, S_MINE);
 600     break;
 601   case S_MINE:
 602     tile_clear_special(ptile, S_IRRIGATION);
 603     tile_clear_special(ptile, S_FARMLAND);
 604     break;
 605
 606   case S_POLLUTION:
 607   case S_HUT:
 608   case S_FALLOUT:
 609   default:
 610     break;
 611   }
 612 }
 613
 614 /****************************************************************************
 615   Remove the special from the tile.  This does secondary tile updates to
 616   the tile.
 617 ****************************************************************************/
 618 void tile_remove_special(struct tile *ptile, enum tile_special_type special)
 619 {
 620   fc_assert_ret(special != S_OLD_FORTRESS && special != S_OLD_AIRBASE);
 621   fc_assert_ret(special != S_OLD_ROAD && special != S_OLD_RAILROAD && special != S_OLD_RIVER);
 622
 623   tile_clear_special(ptile, special);
 624
 625   switch (special) {
 626   case S_IRRIGATION:
 627     tile_clear_special(ptile, S_FARMLAND);
 628     break;
 629
 630   case S_MINE:
 631   case S_POLLUTION:
 632   case S_HUT:
 633   case S_FARMLAND:
 634   case S_FALLOUT:
 635   default:
 636     break;
 637   }
 638 }
 639
 640 /****************************************************************************
 641   Build irrigation on the tile.  This may change the specials of the tile
 642   or change the terrain type itself.
 643 ****************************************************************************/
 644 static void tile_irrigate(struct tile *ptile)
 645 {
 646   struct terrain *pterrain = tile_terrain(ptile);
 647
 648   if (pterrain == pterrain->irrigation_result) {
 649     if (tile_has_special(ptile, S_IRRIGATION)) {
 650       tile_add_special(ptile, S_FARMLAND);
 651     } else {
 652       tile_add_special(ptile, S_IRRIGATION);
 653     }
 654   } else if (pterrain->irrigation_result) {
 655     tile_change_terrain(ptile, pterrain->irrigation_result);
 656   }
 657 }
 658
 659 /****************************************************************************
 660   Build a mine on the tile.  This may change the specials of the tile
 661   or change the terrain type itself.
 662 ****************************************************************************/
 663 static void tile_mine(struct tile *ptile)
 664 {
 665   struct terrain *pterrain = tile_terrain(ptile);
 666
 667   if (pterrain == pterrain->mining_result) {
 668     tile_set_special(ptile, S_MINE);
 669     tile_clear_special(ptile, S_FARMLAND);
 670     tile_clear_special(ptile, S_IRRIGATION);
 671   } else if (pterrain->mining_result) {
 672     tile_change_terrain(ptile, pterrain->mining_result);
 673   }
 674 }
 675
 676 /****************************************************************************
 677   Transform (ACTIVITY_TRANSFORM) the tile.  This usually changes the tile's
 678   terrain type.
 679 ****************************************************************************/
 680 static void tile_transform(struct tile *ptile)
 681 {
 682   struct terrain *pterrain = tile_terrain(ptile);
 683
 684   if (pterrain->transform_result != T_NONE) {
 685     tile_change_terrain(ptile, pterrain->transform_result);
 686   }
 687 }
 688
 689 /****************************************************************************
 690   Apply an activity (Activity_type_id, e.g., ACTIVITY_TRANSFORM) to a tile.
 691   Return false if there was a error or if the activity is not implemented
 692   by this function.
 693 ****************************************************************************/
 694 bool tile_apply_activity(struct tile *ptile, Activity_type_id act)
 695 {
 696   /* FIXME: for irrigate, mine, and transform we always return TRUE
 697    * even if the activity fails. */
 698   switch(act) {
 699   case ACTIVITY_POLLUTION:
 700   case ACTIVITY_FALLOUT:
 701     tile_clear_dirtiness(ptile);
 702     return TRUE;
 703
 704   case ACTIVITY_MINE:
 705     tile_mine(ptile);
 706     return TRUE;
 707
 708   case ACTIVITY_IRRIGATE:
 709     tile_irrigate(ptile);
 710     return TRUE;
 711
 712   case ACTIVITY_TRANSFORM:
 713     tile_transform(ptile);
 714     return TRUE;
 715
 716   case ACTIVITY_OLD_ROAD:
 717   case ACTIVITY_OLD_RAILROAD:
 718   case ACTIVITY_FORTRESS:
 719   case ACTIVITY_AIRBASE:
 720     fc_assert(FALSE);
 721     return FALSE;
 722
 723   case ACTIVITY_PILLAGE:
 724   case ACTIVITY_BASE:
 725   case ACTIVITY_GEN_ROAD:
 726     /* do nothing  - not implemented */
 727     return FALSE;
 728
 729   case ACTIVITY_IDLE:
 730   case ACTIVITY_FORTIFIED:
 731   case ACTIVITY_SENTRY:
 732   case ACTIVITY_GOTO:
 733   case ACTIVITY_EXPLORE:
 734   case ACTIVITY_CONVERT:
 735   case ACTIVITY_UNKNOWN:
 736   case ACTIVITY_FORTIFYING:
 737   case ACTIVITY_PATROL_UNUSED:
 738   case ACTIVITY_LAST:
 739     /* do nothing - these activities have no effect
 740        on terrain type or tile specials */
 741     return FALSE;
 742   }
 743   fc_assert(FALSE);
 744   return FALSE;
 745 }
 746
 747 /****************************************************************************
 748   Add one entry about pollution situation to buffer.
 749   Return if there has been any pollution (even prior calling this)
 750 ****************************************************************************/
 751 static bool tile_info_pollution(char *buf, int bufsz,
 752                                 const struct tile *ptile,
 753                                 enum tile_special_type special,
 754                                 bool prevp, bool linebreak)
 755 {
 756   if (tile_has_special(ptile, special)) {
 757     if (!prevp) {
 758       if (linebreak) {
 759         fc_strlcat(buf, "\n[", bufsz);
 760       } else {
 761         fc_strlcat(buf, " [", bufsz);
 762       }
 763     } else {
 764       fc_strlcat(buf, "/", bufsz);
 765     }
 766
 767     fc_strlcat(buf, special_name_translation(special), bufsz);
 768
 769     return TRUE;
 770   }
 771
 772   return prevp;
 773 }
 774
 775 /****************************************************************************
 776   Return a (static) string with tile name describing terrain and specials.
 777   If include_nuisances is set, pollution and nuclear fallout will be
 778   ignored.
 779
 780   Examples:
 781     "Hills"
 782     "Hills (Coals)"
 783     "Hills (Coals) [Pollution]"
 784 ****************************************************************************/
 785 const char *tile_get_info_text(const struct tile *ptile,
 786                                bool include_nuisances, int linebreaks)
 787 {
 788   static char s[256];
 789   bool pollution;
 790   bool lb = FALSE;
 791   int bufsz = sizeof(s);
 792
 793   sz_strlcpy(s, terrain_name_translation(tile_terrain(ptile)));
 794   if (linebreaks & TILE_LB_TERRAIN_RIVER) {
 795     /* Linebreak needed before next text */
 796     lb = TRUE;
 797   }
 798
 799   road_type_iterate(proad) {
 800     if (tile_has_road(ptile, proad)
 801         && road_has_flag(proad, RF_NATURAL)) {
 802       if (lb) {
 803         sz_strlcat(s, "\n");
 804         lb = FALSE;
 805       } else {
 806         sz_strlcat(s, "/");
 807       }
 808       sz_strlcat(s, road_name_translation(proad));
 809     }
 810   } road_type_iterate_end;
 811   if (linebreaks & TILE_LB_RIVER_RESOURCE) {
 812     /* New linebreak requested */
 813     lb = TRUE;
 814   }
 815
 816   if (tile_resource_is_valid(ptile)) {
 817     if (lb) {
 818       sz_strlcat(s, "\n");
 819       lb = FALSE;
 820     } else {
 821       sz_strlcat(s, " ");
 822     }
 823     cat_snprintf(s, sizeof(s), "(%s)",
 824                  resource_name_translation(ptile->resource));
 825   }
 826   if (linebreaks & TILE_LB_RESOURCE_POLL) {
 827     /* New linebreak requested */
 828     lb = TRUE;
 829   }
 830
 831   if (include_nuisances) {
 832     pollution = FALSE;
 833     pollution = tile_info_pollution(s, bufsz, ptile, S_POLLUTION, pollution,
 834                                     lb);
 835     pollution = tile_info_pollution(s, bufsz, ptile, S_FALLOUT, pollution,
 836                                     lb);
 837     if (pollution) {
 838       sz_strlcat(s, "]");
 839     }
 840   }
 841
 842   return s;
 843 }
 844
 845 /****************************************************************************
 846   Returns TRUE if the given tile has a base of given type on it.
 847 ****************************************************************************/
 848 bool tile_has_base(const struct tile *ptile, const struct base_type *pbase)
 849 {
 850   return BV_ISSET(ptile->bases, base_index(pbase));
 851 }
 852
 853 /****************************************************************************
 854   Returns TRUE if the given tile has a base conflicting with the given one.
 855 ****************************************************************************/
 856 bool tile_has_conflicting_base(const struct tile *ptile, const struct base_type *pbase)
 857 {
 858   base_type_iterate(pconfl) {
 859     if (BV_ISSET(pbase->conflicts, base_index(pconfl))
 860         && tile_has_base(ptile, pconfl)) {
 861       return TRUE;
 862     }
 863   } base_type_iterate_end;
 864
 865   return FALSE;
 866 }
 867
 868 /****************************************************************************
 869   Returns TRUE if the given tile has any bases on it.
 870 ****************************************************************************/
 871 bool tile_has_any_bases(const struct tile *ptile)
 872 {
 873   if (!ptile) {
 874     return FALSE;
 875   }
 876   return BV_ISSET_ANY(ptile->bases);
 877 }
 878
 879 /****************************************************************************
 880   Returns TRUE if the given tile has a road of given type on it.
 881 ****************************************************************************/
 882 bool tile_has_road(const struct tile *ptile, const struct road_type *proad)
 883 {
 884   return BV_ISSET(ptile->roads, road_index(proad));
 885 }
 886
 887 /****************************************************************************
 888   Tile has any river type
 889 ****************************************************************************/
 890 bool tile_has_river(const struct tile *ptile)
 891 {
 892   road_type_iterate(priver) {
 893     if (tile_has_road(ptile, priver)
 894         && road_has_flag(priver, RF_RIVER)) {
 895       return TRUE;
 896     }
 897   } road_type_iterate_end;
 898
 899   return FALSE;
 900 }
 901
 902 /****************************************************************************
 903   Adds road to tile
 904 ****************************************************************************/
 905 void tile_add_road(struct tile *ptile, const struct road_type *proad)
 906 {
 907   if (proad != NULL) {
 908     BV_SET(ptile->roads, road_index(proad));
 909   }
 910 }
 911
 912 /****************************************************************************
 913   Removes road from tile if such exist
 914 ****************************************************************************/
 915 void tile_remove_road(struct tile *ptile, const struct road_type *proad)
 916 {
 917   if (proad != NULL) {
 918     BV_CLR(ptile->roads, road_index(proad));
 919   }
 920 }
 921
 922 /****************************************************************************
 923   Returns a virtual tile. If ptile is given, the properties of this tile are
 924   copied, else it is completely blank (except for the unit list
 925   vtile->units, which is created for you). Be sure to call tile_virtual_free
 926   on it when it is no longer needed.
 927 ****************************************************************************/
 928 struct tile *tile_virtual_new(const struct tile *ptile)
 929 {
 930   struct tile *vtile;
 931
 932   vtile = fc_calloc(1, sizeof(*vtile));
 933
 934   /* initialise some values */
 935   vtile->index = -1;
 936   vtile->continent = -1;
 937
 938   BV_CLR_ALL(vtile->special);
 939   BV_CLR_ALL(vtile->bases);
 940   BV_CLR_ALL(vtile->roads);
 941   vtile->resource = NULL;
 942   vtile->terrain = NULL;
 943   vtile->units = unit_list_new();
 944   vtile->worked = NULL;
 945   vtile->owner = NULL;
 946   vtile->claimer = NULL;
 947   vtile->spec_sprite = NULL;
 948
 949   if (ptile) {
 950     /* Used by is_city_center to give virtual tiles the output bonuses
 951      * they deserve. */
 952     vtile->index = tile_index(ptile);
 953
 954     /* Copy all but the unit list. */
 955     tile_special_type_iterate(spe) {
 956       if (BV_ISSET(ptile->special, spe)) {
 957         BV_SET(vtile->special, spe);
 958       }
 959     } tile_special_type_iterate_end;
 960
 961     if (BV_ISSET(ptile->special, S_RESOURCE_VALID)) {
 962       BV_SET(vtile->special, S_RESOURCE_VALID);
 963     }
 964
 965     base_type_iterate(pbase) {
 966       if (BV_ISSET(ptile->bases, base_number(pbase))) {
 967         BV_SET(vtile->bases, base_number(pbase));
 968       }
 969     } base_type_iterate_end;
 970
 971     road_type_iterate(proad) {
 972       if (tile_has_road(ptile, proad)) {
 973         tile_add_road(vtile, proad);
 974       }
 975     } road_type_iterate_end;
 976
 977     vtile->resource = ptile->resource;
 978     vtile->terrain = ptile->terrain;
 979     vtile->worked = ptile->worked;
 980     vtile->owner = ptile->owner;
 981     vtile->claimer = ptile->claimer;
 982     vtile->spec_sprite = NULL;
 983   }
 984
 985   return vtile;
 986 }
 987
 988 /****************************************************************************
 989   Frees all memory used by the virtual tile, including freeing virtual
 990   units in the tile's unit list and the virtual city on this tile if one
 991   exists.
 992
 993   NB: Do not call this on real tiles!
 994 ****************************************************************************/
 995 void tile_virtual_destroy(struct tile *vtile)
 996 {
 997   struct city *vcity;
 998
 999   if (!vtile) {
1000     return;
1001   }
1002
1003   if (vtile->units) {
1004     unit_list_iterate(vtile->units, vunit) {
1005       if (unit_is_virtual(vunit)) {
1006         unit_virtual_destroy(vunit);
1007       }
1008     } unit_list_iterate_end;
1009     unit_list_destroy(vtile->units);
1010     vtile->units = NULL;
1011   }
1012
1013   vcity = tile_city(vtile);
1014   if (vcity) {
1015     if (city_is_virtual(vcity)) {
1016       destroy_city_virtual(vcity);
1017     }
1018     tile_set_worked(vtile, NULL);
1019   }
1020
1021   free(vtile);
1022 }
1023
1024 /****************************************************************************
1025   Check if the given tile is a virtual one or not.
1026 ****************************************************************************/
1027 bool tile_virtual_check(struct tile *vtile)
1028 {
1029   int tindex;
1030
1031   if (!vtile || map_is_empty()) {
1032     return FALSE;
1033   }
1034
1035   tindex = tile_index(vtile);
1036   fc_assert_ret_val(0 <= tindex && tindex < map_num_tiles(), FALSE);
1037
1038   return (vtile != map.tiles + tindex);
1039 }
1040
1041 /****************************************************************************
1042   Returns key that should be used when storing tile to hash or when
1043   retrieving it from there.
1044 ****************************************************************************/
1045 void *tile_hash_key(const struct tile *ptile)
1046 {
1047   void *key = 0; /* Initialize whole sizeof(void *) */
1048
1049   key = FC_INT_TO_PTR(ptile->index);
1050
1051   return key;
1052 }
1053
1054 /****************************************************************************
1055   Sets label for tile. Returns whether label changed.
1056 ****************************************************************************/
1057 bool tile_set_label(struct tile *ptile, const char *label)
1058 {
1059   bool changed = FALSE;
1060
1061   /* Handle empty label as NULL label */
1062   if (label != NULL && label[0] == '\0') {
1063     label = NULL;
1064   }
1065
1066   if (ptile->label != NULL) {
1067     if (label == NULL) {
1068       changed = TRUE;
1069     } else if (strcmp(ptile->label, label)) {
1070       changed = TRUE;
1071     }
1072     FC_FREE(ptile->label);
1073     ptile->label = NULL;
1074   } else if (label != NULL) {
1075     changed = TRUE;
1076   }
1077
1078   if (label != NULL) {
1079     ptile->label = fc_strdup(label);
1080   }
1081
1082   return changed;
1083 }