common/road.c

   1 /****************************************************************************
   2  Freeciv - Copyright (C) 2004 - The Freeciv Team
   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 /* common */
  19 #include "extras.h"
  20 #include "fc_types.h"
  21 #include "game.h"
  22 #include "map.h"
  23 #include "movement.h"
  24 #include "name_translation.h"
  25 #include "unittype.h"
  26
  27 #include "road.h"
  28
  29 /**************************************************************************
  30   Return the road id.
  31 **************************************************************************/
  32 Road_type_id road_number(const struct road_type *proad)
  33 {
  34   fc_assert_ret_val(NULL != proad, -1);
  35
  36   return proad->id;
  37 }
  38
  39 /**************************************************************************
  40   Return the road index.
  41
  42   Currently same as road_number(), paired with road_count()
  43   indicates use as an array index.
  44 **************************************************************************/
  45 Road_type_id road_index(const struct road_type *proad)
  46 {
  47   fc_assert_ret_val(NULL != proad, -1);
  48
  49   /* FIXME: */
  50   /* return proad - roads; */
  51   return road_number(proad);
  52 }
  53
  54 /**************************************************************************
  55   Return extra that road is.
  56 **************************************************************************/
  57 struct extra_type *road_extra_get(const struct road_type *proad)
  58 {
  59   return proad->self;
  60 }
  61
  62 /**************************************************************************
  63   Return the number of road_types.
  64 **************************************************************************/
  65 Road_type_id road_count(void)
  66 {
  67   return game.control.num_road_types;
  68 }
  69
  70 /****************************************************************************
  71   Return road type of given id.
  72 ****************************************************************************/
  73 struct road_type *road_by_number(Road_type_id id)
  74 {
  75   struct extra_type_list *roads;
  76
  77   roads = extra_type_list_by_cause(EC_ROAD);
  78
  79   if (roads == NULL || id < 0 || id >= extra_type_list_size(roads)) {
  80     return NULL;
  81   }
  82
  83   return extra_road_get(extra_type_list_get(roads, id));
  84 }
  85
  86 /****************************************************************************
  87   This function is passed to road_type_list_sort() to sort a list of roads
  88   in ascending move_cost (faster roads first).
  89 ****************************************************************************/
  90 int compare_road_move_cost(const struct extra_type *const *p,
  91                            const struct extra_type *const *q)
  92 {
  93   const struct road_type *proad = extra_road_get(*p);
  94   const struct road_type *qroad = extra_road_get(*q);
  95
  96   if (proad->move_cost > qroad->move_cost) {
  97     return -1; /* q is faster */
  98   } else if (proad->move_cost == qroad->move_cost) {
  99     return 0;
 100   } else {
 101     return 1; /* p is faster */
 102   }
 103 }
 104
 105 /****************************************************************************
 106   Initialize road_type structures.
 107 ****************************************************************************/
 108 void road_type_init(struct extra_type *pextra, int idx)
 109 {
 110   struct road_type *proad;
 111
 112   proad = fc_malloc(sizeof(*proad));
 113
 114   pextra->data.road = proad;
 115
 116   requirement_vector_init(&proad->first_reqs);
 117
 118   proad->id = idx;
 119   proad->integrators = NULL;
 120   proad->self = pextra;
 121 }
 122
 123
 124 /****************************************************************************
 125   Initialize the road integrators cache
 126 ****************************************************************************/
 127 void road_integrators_cache_init(void)
 128 {
 129   extra_type_by_cause_iterate(EC_ROAD, pextra) {
 130     struct road_type *proad = extra_road_get(pextra);
 131
 132     proad->integrators = extra_type_list_new();
 133     /* Roads always integrate with themselves. */
 134     extra_type_list_append(proad->integrators, pextra);
 135     extra_type_by_cause_iterate(EC_ROAD, oextra) {
 136       struct road_type *oroad = extra_road_get(oextra);
 137       if (BV_ISSET(proad->integrates, road_index(oroad))) {
 138         extra_type_list_append(proad->integrators, oextra);
 139       }
 140     } extra_type_by_cause_iterate_end;
 141     extra_type_list_unique(proad->integrators);
 142     extra_type_list_sort(proad->integrators, &compare_road_move_cost);
 143   } extra_type_by_cause_iterate_end;
 144 }
 145
 146 /****************************************************************************
 147   Free the memory associated with road types
 148 ****************************************************************************/
 149 void road_types_free(void)
 150 {
 151   extra_type_by_cause_iterate(EC_ROAD, pextra) {
 152     struct road_type *proad = extra_road_get(pextra);
 153
 154     requirement_vector_free(&proad->first_reqs);
 155
 156     if (proad->integrators != NULL) {
 157       extra_type_list_destroy(proad->integrators);
 158       proad->integrators = NULL;
 159     }
 160   } extra_type_by_cause_iterate_end;
 161 }
 162
 163 /****************************************************************************
 164   Return tile special that used to represent this road type.
 165 ****************************************************************************/
 166 enum road_compat road_compat_special(const struct road_type *proad)
 167 {
 168   return proad->compat;
 169 }
 170
 171 /****************************************************************************
 172   Return road type represented by given compatibility special, or NULL if
 173   special does not represent road type at all.
 174 ****************************************************************************/
 175 struct road_type *road_by_compat_special(enum road_compat compat)
 176 {
 177   if (compat == ROCO_NONE) {
 178     return NULL;
 179   }
 180
 181   extra_type_by_cause_iterate(EC_ROAD, pextra) {
 182     struct road_type *proad = extra_road_get(pextra);
 183     if (road_compat_special(proad) == compat) {
 184       return proad;
 185     }
 186   } extra_type_by_cause_iterate_end;
 187
 188   return NULL;
 189 }
 190
 191 /****************************************************************************
 192   Tells if road can build to tile if all other requirements are met.
 193 ****************************************************************************/
 194 bool road_can_be_built(const struct road_type *proad, const struct tile *ptile)
 195 {
 196
 197   if (!(road_extra_get(proad)->buildable)) {
 198     /* Road type not buildable. */
 199     return FALSE;
 200   }
 201
 202   if (tile_has_road(ptile, proad)) {
 203     /* Road exist already */
 204     return FALSE;
 205   }
 206
 207   if (tile_terrain(ptile)->road_time == 0) {
 208     return FALSE;
 209   }
 210
 211   return TRUE;
 212 }
 213
 214 /****************************************************************************
 215   Tells if player can build road to tile with suitable unit.
 216 ****************************************************************************/
 217 bool can_build_road_base(const struct road_type *proad,
 218                          const struct player *pplayer,
 219                          const struct tile *ptile)
 220 {
 221   if (!road_can_be_built(proad, ptile)) {
 222     return FALSE;
 223   }
 224
 225   if (road_has_flag(proad, RF_REQUIRES_BRIDGE)
 226       && !player_knows_techs_with_flag(pplayer, TF_BRIDGE)) {
 227     /* TODO: Cache list of road types with RF_PREVENTS_OTHER_ROADS
 228      *       after ruleset loading and use that list here instead
 229      *       of always iterating through all road types. */
 230     extra_type_by_cause_iterate(EC_ROAD, poextra) {
 231       struct road_type *old = extra_road_get(poextra);
 232
 233       if (road_has_flag(old, RF_PREVENTS_OTHER_ROADS)
 234           && tile_has_extra(ptile, poextra)) {
 235         return FALSE;
 236       }
 237     } extra_type_by_cause_iterate_end;
 238   }
 239
 240   return TRUE;
 241 }
 242
 243 /****************************************************************************
 244   Tells if player and optionally unit have road building requirements
 245   fulfilled.
 246 ****************************************************************************/
 247 static bool are_road_reqs_fulfilled(const struct road_type *proad,
 248                                     const struct player *pplayer,
 249                                     const struct unit *punit,
 250                                     const struct tile *ptile)
 251 {
 252   struct extra_type *pextra = road_extra_get(proad);
 253   const struct unit_type *utype;
 254
 255   if (punit == NULL) {
 256     utype = NULL;
 257   } else {
 258     utype = unit_type_get(punit);
 259   }
 260
 261   if (requirement_vector_size(&proad->first_reqs) > 0) {
 262     bool beginning = TRUE;
 263
 264     extra_type_list_iterate(proad->integrators, iroad) {
 265       adjc_iterate(ptile, adjc_tile) {
 266         if (tile_has_extra(adjc_tile, iroad)) {
 267           beginning = FALSE;
 268           break;
 269         }
 270       } adjc_iterate_end;
 271
 272       if (!beginning) {
 273         break;
 274       }
 275     } extra_type_list_iterate_end;
 276
 277     if (beginning) {
 278       if (!are_reqs_active(pplayer, tile_owner(ptile), NULL, NULL, ptile,
 279                            punit, utype, NULL, NULL,
 280                            &proad->first_reqs, RPT_POSSIBLE)) {
 281         return FALSE;
 282       }
 283     }
 284   }
 285
 286   return are_reqs_active(pplayer, tile_owner(ptile), NULL, NULL, ptile,
 287                          punit, utype, NULL, NULL, &pextra->reqs,
 288                          RPT_POSSIBLE);
 289 }
 290
 291 /****************************************************************************
 292   Tells if player can build road to tile with suitable unit.
 293 ****************************************************************************/
 294 bool player_can_build_road(const struct road_type *proad,
 295                            const struct player *pplayer,
 296                            const struct tile *ptile)
 297 {
 298   if (!can_build_road_base(proad, pplayer, ptile)) {
 299     return FALSE;
 300   }
 301
 302   return are_road_reqs_fulfilled(proad, pplayer, NULL, ptile);
 303 }
 304
 305 /****************************************************************************
 306   Tells if unit can build road on tile.
 307 ****************************************************************************/
 308 bool can_build_road(struct road_type *proad,
 309                     const struct unit *punit,
 310                     const struct tile *ptile)
 311 {
 312   struct player *pplayer = unit_owner(punit);
 313
 314   if (!can_build_road_base(proad, pplayer, ptile)) {
 315     return FALSE;
 316   }
 317
 318   return are_road_reqs_fulfilled(proad, pplayer, punit, ptile);
 319 }
 320
 321 /****************************************************************************
 322   Count tiles with specified road near the tile. Can be called with NULL
 323   road.
 324 ****************************************************************************/
 325 int count_road_near_tile(const struct tile *ptile, const struct road_type *proad)
 326 {
 327   int count = 0;
 328
 329   if (proad == NULL) {
 330     return 0;
 331   }
 332
 333   adjc_iterate(ptile, adjc_tile) {
 334     if (tile_has_road(adjc_tile, proad)) {
 335       count++;
 336     }
 337   } adjc_iterate_end;
 338
 339   return count;
 340 }
 341
 342 /****************************************************************************
 343   Count tiles with any river near the tile.
 344 ****************************************************************************/
 345 int count_river_near_tile(const struct tile *ptile,
 346                           const struct extra_type *priver)
 347 {
 348   int count = 0;
 349
 350   cardinal_adjc_iterate(ptile, adjc_tile) {
 351     if (priver == NULL && tile_has_river(adjc_tile)) {
 352       /* Some river */
 353       count++;
 354     } else if (priver != NULL && tile_has_extra(adjc_tile, priver)) {
 355       /* Specific river */
 356       count++;
 357     }
 358   } cardinal_adjc_iterate_end;
 359
 360   return count;
 361 }
 362
 363 /****************************************************************************
 364   Count tiles with river of specific type cardinally adjacent to the tile.
 365 ****************************************************************************/
 366 int count_river_type_tile_card(const struct tile *ptile,
 367                                const struct extra_type *priver,
 368                                bool percentage)
 369 {
 370   int count = 0;
 371   int total = 0;
 372
 373   fc_assert(priver != NULL);
 374
 375   cardinal_adjc_iterate(ptile, adjc_tile) {
 376     if (tile_has_extra(adjc_tile, priver)) {
 377       count++;
 378     }
 379     total++;
 380   } cardinal_adjc_iterate_end;
 381
 382   if (percentage) {
 383     count = count * 100 / total;
 384   }
 385   return count;
 386 }
 387
 388 /****************************************************************************
 389   Count tiles with river of specific type near the tile.
 390 ****************************************************************************/
 391 int count_river_type_near_tile(const struct tile *ptile,
 392                                const struct extra_type *priver,
 393                                bool percentage)
 394 {
 395   int count = 0;
 396   int total = 0;
 397
 398   fc_assert(priver != NULL);
 399
 400   adjc_iterate(ptile, adjc_tile) {
 401     if (tile_has_extra(adjc_tile, priver)) {
 402       count++;
 403     }
 404     total++;
 405   } adjc_iterate_end;
 406
 407   if (percentage) {
 408     count = count * 100 / total;
 409   }
 410   return count;
 411 }
 412
 413 /****************************************************************************
 414   Check if road provides effect
 415 ****************************************************************************/
 416 bool road_has_flag(const struct road_type *proad, enum road_flag_id flag)
 417 {
 418   return BV_ISSET(proad->flags, flag);
 419 }
 420
 421 /****************************************************************************
 422   Returns TRUE iff any cardinally adjacent tile contains a road with
 423   the given flag (does not check ptile itself).
 424 ****************************************************************************/
 425 bool is_road_flag_card_near(const struct tile *ptile, enum road_flag_id flag)
 426 {
 427   extra_type_by_cause_iterate(EC_ROAD, pextra) {
 428     if (road_has_flag(extra_road_get(pextra), flag)) {
 429       cardinal_adjc_iterate(ptile, adjc_tile) {
 430         if (tile_has_extra(adjc_tile, pextra)) {
 431           return TRUE;
 432         }
 433       } cardinal_adjc_iterate_end;
 434     }
 435   } extra_type_by_cause_iterate_end;
 436
 437   return FALSE;
 438 }
 439
 440 /****************************************************************************
 441   Returns TRUE iff any adjacent tile contains a road with the given flag
 442   (does not check ptile itself).
 443 ****************************************************************************/
 444 bool is_road_flag_near_tile(const struct tile *ptile, enum road_flag_id flag)
 445 {
 446   extra_type_by_cause_iterate(EC_ROAD, pextra) {
 447     if (road_has_flag(extra_road_get(pextra), flag)) {
 448       adjc_iterate(ptile, adjc_tile) {
 449         if (tile_has_extra(adjc_tile, pextra)) {
 450           return TRUE;
 451         }
 452       } adjc_iterate_end;
 453     }
 454   } extra_type_by_cause_iterate_end;
 455
 456   return FALSE;
 457 }
 458
 459 /****************************************************************************
 460   Is tile native to road?
 461 ****************************************************************************/
 462 bool is_native_tile_to_road(const struct road_type *proad,
 463                             const struct tile *ptile)
 464 {
 465   struct extra_type *pextra;
 466
 467   if (road_has_flag(proad, RF_RIVER)) {
 468     if (!terrain_has_flag(tile_terrain(ptile), TER_CAN_HAVE_RIVER)) {
 469       return FALSE;
 470     }
 471   } else if (tile_terrain(ptile)->road_time == 0) {
 472     return FALSE;
 473   }
 474
 475   pextra = road_extra_get(proad);
 476
 477   return are_reqs_active(NULL, NULL, NULL, NULL, ptile,
 478                          NULL, NULL, NULL, NULL,
 479                          &pextra->reqs, RPT_POSSIBLE);
 480 }
 481
 482 /****************************************************************************
 483   Is extra cardinal only road.
 484 ****************************************************************************/
 485 bool is_cardinal_only_road(const struct extra_type *pextra)
 486 {
 487   const struct road_type *proad;
 488
 489   if (!is_extra_caused_by(pextra, EC_ROAD)) {
 490     return FALSE;
 491   }
 492
 493   proad = extra_road_get(pextra);
 494
 495   return proad->move_mode == RMM_CARDINAL || proad->move_mode == RMM_RELAXED;
 496 }
 497
 498 /****************************************************************************
 499   Does road type provide move bonus
 500 ****************************************************************************/
 501 bool road_provides_move_bonus(const struct road_type *proad)
 502 {
 503   return proad->move_cost >= 0;
 504 }