terrain.cpp

Go to the documentation of this file.

/*
 Copyright (c) 1996-2020 Freeciv21 and Freeciv contributors. This file is
 __    __          part of Freeciv21. Freeciv21 is free software: you can
/ \\..// \    redistribute it and/or modify it under the terms of the GNU
  ( oo )        General Public License  as published by the Free Software
   \__/         Foundation, either version 3 of the License,  or (at your
                      option) any later version. You should have received
    a copy of the GNU General Public License along with Freeciv21. If not,
                  see https://www.gnu.org/licenses/.
 */
 
// utility
#include "fcintl.h"
#include "log.h" // fc_assert
#include "rand.h"
#include "shared.h"
#include "support.h"
 
// common
#include "extras.h"
#include "game.h"
#include "map.h"
#include "rgbcolor.h"
#include "road.h"
 
#include "terrain.h"
 
static struct terrain civ_terrains[MAX_NUM_TERRAINS];
static struct user_flag user_terrain_flags[MAX_NUM_USER_TER_FLAGS];
 
void terrains_init()
{
  int i;
 
  for (i = 0; i < ARRAY_SIZE(civ_terrains); i++) {
    // Can't use terrain_by_number here because it does a bounds check.
    civ_terrains[i].item_number = i;
    civ_terrains[i].ruledit_disabled = false;
    civ_terrains[i].rgb = nullptr;
    civ_terrains[i].animal = nullptr;
  }
}
 
void terrains_free()
{
  terrain_type_iterate(pterrain)
  {
    delete pterrain->helptext;
    pterrain->helptext = nullptr;
    delete[] pterrain->resources;
    pterrain->resources = nullptr;
    if (pterrain->rgb != nullptr) {
      /* Server allocates this on ruleset loading, client when
       * ruleset packet is received. */
      rgbcolor_destroy(pterrain->rgb);
      pterrain->rgb = nullptr;
    }
  }
  terrain_type_iterate_end;
}
 
struct terrain *terrain_array_first()
{
  if (game.control.terrain_count > 0) {
    return civ_terrains;
  }
  return nullptr;
}
 
const struct terrain *terrain_array_last()
{
  if (game.control.terrain_count > 0) {
    return &civ_terrains[game.control.terrain_count - 1];
  }
  return nullptr;
}
 
Terrain_type_id terrain_count() { return game.control.terrain_count; }
 
char terrain_identifier(const struct terrain *pterrain)
{
  fc_assert_ret_val(pterrain, '\0');
  return pterrain->identifier;
}
 
Terrain_type_id terrain_index(const struct terrain *pterrain)
{
  fc_assert_ret_val(pterrain, 0);
  return pterrain - civ_terrains;
}
 
Terrain_type_id terrain_number(const struct terrain *pterrain)
{
  fc_assert_ret_val(pterrain, 0);
  return pterrain->item_number;
}
 
struct terrain *terrain_by_number(const Terrain_type_id type)
{
  if (type < 0 || type >= game.control.terrain_count) {
    // This isn't an error; some T_UNKNOWN callers depend on it.
    return nullptr;
  }
  return &civ_terrains[type];
}
 
struct terrain *terrain_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  terrain_type_iterate(pterrain)
  {
    if (0 == fc_strcasecmp(terrain_rule_name(pterrain), qname)) {
      return pterrain;
    }
  }
  terrain_type_iterate_end;
 
  return T_UNKNOWN;
}
 
struct terrain *terrain_by_translated_name(const char *name)
{
  terrain_type_iterate(pterrain)
  {
    if (0 == strcmp(terrain_name_translation(pterrain), name)) {
      return pterrain;
    }
  }
  terrain_type_iterate_end;
 
  return T_UNKNOWN;
}
 
const char *terrain_name_translation(const struct terrain *pterrain)
{
  return name_translation_get(&pterrain->name);
}
 
const char *terrain_rule_name(const struct terrain *pterrain)
{
  return rule_name_get(&pterrain->name);
}
 
bool terrain_has_resource(const struct terrain *pterrain,
                          const struct extra_type *presource)
{
  struct extra_type **r = pterrain->resources;
 
  while (nullptr != *r) {
    if (*r == presource) {
      return true;
    }
    r++;
  }
  return false;
}
 
struct resource_type *resource_type_init(struct extra_type *pextra)
{
  auto *presource = new resource_type;
 
  pextra->data.resource = presource;
 
  presource->self = pextra;
 
  return presource;
}
 
void resource_types_free()
{
  // Resource structure itself is freed as part of extras destruction.
}
 
#define variable_adjc_iterate(nmap, center_tile, _tile, card_only)          \
  {                                                                         \
    enum direction8 *_tile##_list;                                          \
    int _tile##_count;                                                      \
                                                                            \
    if (card_only) {                                                        \
      _tile##_list = wld.map.cardinal_dirs;                                 \
      _tile##_count = wld.map.num_cardinal_dirs;                            \
    } else {                                                                \
      _tile##_list = wld.map.valid_dirs;                                    \
      _tile##_count = wld.map.num_valid_dirs;                               \
    }                                                                       \
    adjc_dirlist_iterate(nmap, center_tile, _tile, _tile##_dir,             \
                         _tile##_list, _tile##_count)                       \
    {
 
#define variable_adjc_iterate_end                                           \
  }                                                                         \
  adjc_dirlist_iterate_end;                                                 \
  }
 
bool is_terrain_card_near(const struct tile *ptile,
                          const struct terrain *pterrain, bool check_self)
{
  if (!pterrain) {
    return false;
  }
 
  cardinal_adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    if (tile_terrain(adjc_tile) == pterrain) {
      return true;
    }
  }
  cardinal_adjc_iterate_end;
 
  return check_self && ptile->terrain == pterrain;
}
 
bool is_terrain_near_tile(const struct tile *ptile,
                          const struct terrain *pterrain, bool check_self)
{
  if (!pterrain) {
    return false;
  }
 
  adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    if (tile_terrain(adjc_tile) == pterrain) {
      return true;
    }
  }
  adjc_iterate_end;
 
  return check_self && ptile->terrain == pterrain;
}
 
int count_terrain_property_near_tile(const struct tile *ptile,
                                     bool cardinal_only, bool percentage,
                                     enum mapgen_terrain_property prop)
{
  int count = 0, total = 0;
 
  variable_adjc_iterate(&(wld.map), ptile, adjc_tile, cardinal_only)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (pterrain->property[prop] > 0) {
      count++;
    }
    total++;
  }
  variable_adjc_iterate_end;
 
  if (percentage) {
    count = count * 100 / std::max(1, total);
  }
  return count;
}
 
bool is_terrain_flag_card_near(const struct tile *ptile,
                               enum terrain_flag_id flag)
{
  cardinal_adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (T_UNKNOWN != pterrain && terrain_has_flag(pterrain, flag)) {
      return true;
    }
  }
  cardinal_adjc_iterate_end;
 
  return false;
}
 
bool is_terrain_flag_near_tile(const struct tile *ptile,
                               enum terrain_flag_id flag)
{
  adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (T_UNKNOWN != pterrain && terrain_has_flag(pterrain, flag)) {
      return true;
    }
  }
  adjc_iterate_end;
 
  return false;
}
 
int count_terrain_flag_near_tile(const struct tile *ptile,
                                 bool cardinal_only, bool percentage,
                                 enum terrain_flag_id flag)
{
  int count = 0, total = 0;
 
  variable_adjc_iterate(&(wld.map), ptile, adjc_tile, cardinal_only)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (T_UNKNOWN != pterrain && terrain_has_flag(pterrain, flag)) {
      count++;
    }
    total++;
  }
  variable_adjc_iterate_end;
 
  if (percentage) {
    count = count * 100 / std::max(1, total);
  }
  return count;
}
 
const char *get_infrastructure_text(bv_extras extras)
{
  static char s[256];
  char *p;
  int len;
 
  s[0] = '\0';
 
  extra_type_iterate(pextra)
  {
    if (pextra->category == ECAT_INFRA
        && BV_ISSET(extras, extra_index(pextra))) {
      bool hidden = false;
 
      extra_type_iterate(top)
      {
        int topi = extra_index(top);
 
        if (BV_ISSET(pextra->hidden_by, topi) && BV_ISSET(extras, topi)) {
          hidden = true;
          break;
        }
      }
      extra_type_iterate_end;
 
      if (!hidden) {
        cat_snprintf(s, sizeof(s), "%s/", extra_name_translation(pextra));
      }
    }
  }
  extra_type_iterate_end;
 
  len = qstrlen(s);
  p = s + len - 1;
  if (len > 0 && *p == '/') {
    *p = '\0';
  }
 
  return s;
}
 
struct extra_type *get_preferred_pillage(bv_extras extras)
{
  // Semi-arbitrary preference order reflecting previous behavior
  static const enum extra_cause prefs[] = {
      EC_IRRIGATION, EC_MINE,      EC_BASE,    EC_ROAD,     EC_HUT,
      EC_APPEARANCE, EC_POLLUTION, EC_FALLOUT, EC_RESOURCE, EC_NONE};
  int i;
 
  for (i = 0; i < ARRAY_SIZE(prefs); i++) {
    extra_type_by_cause_iterate_rev(prefs[i], pextra)
    {
      if (is_extra_removed_by(pextra, ERM_PILLAGE)
          && BV_ISSET(extras, extra_index(pextra))) {
        return pextra;
      }
    }
    extra_type_by_cause_iterate_rev_end;
  }
 
  return nullptr;
}
 
enum terrain_class terrain_type_terrain_class(const struct terrain *pterrain)
{
  return pterrain->tclass;
}
 
bool is_terrain_class_card_near(const struct tile *ptile,
                                enum terrain_class tclass)
{
  cardinal_adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (pterrain != T_UNKNOWN) {
      if (terrain_type_terrain_class(pterrain) == tclass) {
        return true;
      }
    }
  }
  cardinal_adjc_iterate_end;
 
  return false;
}
 
bool is_terrain_class_near_tile(const struct tile *ptile,
                                enum terrain_class tclass)
{
  adjc_iterate(&(wld.map), ptile, adjc_tile)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (pterrain != T_UNKNOWN) {
      if (terrain_type_terrain_class(pterrain) == tclass) {
        return true;
      }
    }
  }
  adjc_iterate_end;
 
  return false;
}
 
int count_terrain_class_near_tile(const struct tile *ptile,
                                  bool cardinal_only, bool percentage,
                                  enum terrain_class tclass)
{
  int count = 0, total = 0;
 
  variable_adjc_iterate(&(wld.map), ptile, adjc_tile, cardinal_only)
  {
    struct terrain *pterrain = tile_terrain(adjc_tile);
 
    if (T_UNKNOWN != pterrain
        && terrain_type_terrain_class(pterrain) == tclass) {
      count++;
    }
    total++;
  }
  variable_adjc_iterate_end;
 
  if (percentage) {
    count = count * 100 / std::max(1, total);
  }
 
  return count;
}
 
const char *terrain_class_name_translation(enum terrain_class tclass)
{
  if (!terrain_class_is_valid(tclass)) {
    return nullptr;
  }
 
  return _(terrain_class_name(tclass));
}
 
bool terrain_can_support_alteration(const struct terrain *pterrain,
                                    enum terrain_alteration alter)
{
  switch (alter) {
  case TA_CAN_IRRIGATE:
    return (pterrain == pterrain->irrigation_result);
  case TA_CAN_MINE:
    return (pterrain == pterrain->mining_result);
  case TA_CAN_ROAD:
    return (pterrain->road_time > 0);
  default:
    break;
  }
 
  fc_assert(false);
  return false;
}
 
int terrain_extra_build_time(const struct terrain *pterrain,
                             enum unit_activity activity,
                             const struct extra_type *tgt)
{
  int factor;
 
  if (tgt != nullptr && tgt->build_time != 0) {
    // Extra specific build time
    return tgt->build_time;
  }
 
  if (tgt == nullptr) {
    factor = 1;
  } else {
    factor = tgt->build_time_factor;
  }
 
  // Terrain and activity specific build time
  switch (activity) {
  case ACTIVITY_BASE:
    return pterrain->base_time * factor;
  case ACTIVITY_GEN_ROAD:
    return pterrain->road_time * factor;
  case ACTIVITY_IRRIGATE:
    return pterrain->irrigation_time * factor;
  case ACTIVITY_MINE:
    return pterrain->mining_time * factor;
  default:
    fc_assert(false);
    return 0;
  }
}
 
int terrain_extra_removal_time(const struct terrain *pterrain,
                               enum unit_activity activity,
                               const struct extra_type *tgt)
{
  int factor;
 
  if (tgt != nullptr && tgt->removal_time != 0) {
    // Extra specific removal time
    return tgt->removal_time;
  }
 
  if (tgt == nullptr) {
    factor = 1;
  } else {
    factor = tgt->removal_time_factor;
  }
 
  // Terrain and activity specific removal time
  switch (activity) {
  case ACTIVITY_POLLUTION:
    return pterrain->clean_pollution_time * factor;
  case ACTIVITY_FALLOUT:
    return pterrain->clean_fallout_time * factor;
  case ACTIVITY_PILLAGE:
    return pterrain->pillage_time * factor;
  default:
    fc_assert(false);
    return 0;
  }
}
 
void user_terrain_flags_init()
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_TER_FLAGS; i++) {
    user_flag_init(&user_terrain_flags[i]);
  }
}
 
void user_terrain_flags_free()
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_TER_FLAGS; i++) {
    user_flag_free(&user_terrain_flags[i]);
  }
}
 
void set_user_terrain_flag_name(enum terrain_flag_id id, const char *name,
                                const char *helptxt)
{
  int tfid = id - TER_USER_1;
 
  fc_assert_ret(id >= TER_USER_1 && id <= TER_USER_LAST);
 
  delete[] user_terrain_flags[tfid].name;
  user_terrain_flags[tfid].name = nullptr;
  if (name && name[0] != '\0') {
    user_terrain_flags[tfid].name = fc_strdup(name);
  }
 
  delete[] user_terrain_flags[tfid].helptxt;
  user_terrain_flags[tfid].helptxt = nullptr;
  if (helptxt && helptxt[0] != '\0') {
    user_terrain_flags[tfid].helptxt = fc_strdup(helptxt);
  }
}
 
const char *terrain_flag_id_name_cb(enum terrain_flag_id flag)
{
  if (flag < TER_USER_1 || flag > TER_USER_LAST) {
    return nullptr;
  }
 
  return user_terrain_flags[flag - TER_USER_1].name;
}
 
const char *terrain_flag_helptxt(enum terrain_flag_id id)
{
  fc_assert(id >= TER_USER_1 && id <= TER_USER_LAST);
 
  return user_terrain_flags[id - TER_USER_1].helptxt;
}