improvement.c

Go to the documentation of this file.

/***********************************************************************
 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
***********************************************************************/
 
#ifdef HAVE_CONFIG_H
#include <fc_config.h>
#endif
 
/* utility */
#include "fcintl.h"
#include "log.h"
#include "mem.h"
#include "shared.h"     /* ARRAY_SIZE */
#include "string_vector.h"
#include "support.h"
 
/* common */
#include "game.h"
#include "map.h"
#include "tech.h"
#include "victory.h"
 
#include "improvement.h"
 
/**************************************************************************
All the city improvements:
Use improvement_by_number(id) to access the array.
The improvement_types array is now setup in:
   server/ruleset.c (for the server)
   client/packhand.c (for the client)
**************************************************************************/
static struct impr_type improvement_types[B_LAST];
 
static struct user_flag user_impr_flags[MAX_NUM_USER_BUILDING_FLAGS];
 
/**********************************************************************/
void improvements_init(void)
{
  int i;
 
  /* Can't use improvement_iterate() or improvement_by_number() here
   * because num_impr_types isn't known yet. */
  for (i = 0; i < ARRAY_SIZE(improvement_types); i++) {
    struct impr_type *p = &improvement_types[i];
 
    p->item_number = i;
    requirement_vector_init(&p->reqs);
    requirement_vector_init(&p->obsolete_by);
    p->ruledit_disabled = FALSE;
    p->ruledit_dlg = NULL;
  }
}
 
/**********************************************************************/
static void improvement_free(struct impr_type *p)
{
  if (NULL != p->helptext) {
    strvec_destroy(p->helptext);
    p->helptext = NULL;
  }
 
  requirement_vector_free(&p->reqs);
  requirement_vector_free(&p->obsolete_by);
}
 
/**********************************************************************/
void improvements_free(void)
{
  improvement_iterate(p) {
    improvement_free(p);
  } improvement_iterate_end;
}
 
/**********************************************************************/
void improvement_feature_cache_init(void)
{
  improvement_iterate(pimprove) {
    pimprove->allows_units = FALSE;
    unit_type_iterate(putype) {
      if (requirement_needs_improvement(pimprove, &putype->build_reqs)) {
        pimprove->allows_units = TRUE;
        break;
      }
    } unit_type_iterate_end;
 
    pimprove->allows_extras = FALSE;
    extra_type_iterate(pextra) {
      if (requirement_needs_improvement(pimprove, &pextra->reqs)) {
        pimprove->allows_extras = TRUE;
        break;
      }
    } extra_type_iterate_end;
 
    pimprove->prevents_disaster = FALSE;
    disaster_type_iterate(pdis) {
      if (!requirement_fulfilled_by_improvement(pimprove, &pdis->reqs)) {
        pimprove->prevents_disaster = TRUE;
        break;
      }
    } disaster_type_iterate_end;
 
    pimprove->protects_vs_actions = FALSE;
    action_enablers_iterate(act) {
      if (!requirement_fulfilled_by_improvement(pimprove,
                                                &act->target_reqs)) {
        pimprove->protects_vs_actions = TRUE;
        break;
      }
    } action_enablers_iterate_end;
 
    pimprove->allows_actions = FALSE;
    action_enablers_iterate(act) {
      if (requirement_needs_improvement(pimprove, &act->actor_reqs)) {
        pimprove->allows_actions = TRUE;
        break;
      }
    } action_enablers_iterate_end;
 
  } improvement_iterate_end;
}
 
/**********************************************************************/
struct impr_type *improvement_array_first(void)
{
  if (game.control.num_impr_types > 0) {
    return improvement_types;
  }
  return NULL;
}
 
/**********************************************************************/
const struct impr_type *improvement_array_last(void)
{
  if (game.control.num_impr_types > 0) {
    return &improvement_types[game.control.num_impr_types - 1];
  }
  return NULL;
}
 
/**********************************************************************/
Impr_type_id improvement_count(void)
{
  return game.control.num_impr_types;
}
 
/**********************************************************************/
Impr_type_id improvement_index(const struct impr_type *pimprove)
{
  fc_assert_ret_val(NULL != pimprove, -1);
  return pimprove - improvement_types;
}
 
/**********************************************************************/
Impr_type_id improvement_number(const struct impr_type *pimprove)
{
  fc_assert_ret_val(NULL != pimprove, -1);
  return pimprove->item_number;
}
 
/**********************************************************************/
struct impr_type *improvement_by_number(const Impr_type_id id)
{
  if (id < 0 || id >= improvement_count()) {
    return NULL;
  }
  return &improvement_types[id];
}
 
/**********************************************************************/
const struct impr_type *valid_improvement(const struct impr_type *pimprove)
{
  if (NULL == pimprove) {
    return NULL;
  }
 
  if (!victory_enabled(VC_SPACERACE)
      && (building_has_effect(pimprove, EFT_SS_STRUCTURAL)
          || building_has_effect(pimprove, EFT_SS_COMPONENT)
          || building_has_effect(pimprove, EFT_SS_MODULE))) {
    /* This assumes that space parts don't have any other effects. */
    return NULL;
  }
 
  return pimprove;
}
 
/**********************************************************************/
const struct impr_type *valid_improvement_by_number(const Impr_type_id id)
{
  return valid_improvement(improvement_by_number(id));
}
 
/**********************************************************************/
const char *improvement_name_translation(const struct impr_type *pimprove)
{
  return name_translation_get(&pimprove->name);
}
 
/**********************************************************************/
const char *improvement_rule_name(const struct impr_type *pimprove)
{
  return rule_name_get(&pimprove->name);
}
 
/**********************************************************************/
int impr_base_build_shield_cost(const struct impr_type *pimprove)
{
  int base = pimprove->build_cost;
 
  return MAX(base * game.info.shieldbox / 100, 1);
}
 
/**********************************************************************/
int impr_estimate_build_shield_cost(const struct player *pplayer,
                                    const struct tile *ptile,
                                    const struct impr_type *pimprove)
{
  int base = pimprove->build_cost
    * (100 +
       get_target_bonus_effects(NULL,
                                &(const struct req_context) {
                                  .player = pplayer,
                                  .building = pimprove,
                                  .tile = ptile,
                                },
                                NULL,
                                EFT_IMPR_BUILD_COST_PCT)) / 100;
 
  return MAX(base * game.info.shieldbox / 100, 1);
}
 
/**********************************************************************/
int impr_build_shield_cost(const struct city *pcity,
                           const struct impr_type *pimprove)
{
  int base = pimprove->build_cost
    * (100 + get_building_bonus(pcity, pimprove, EFT_IMPR_BUILD_COST_PCT)) / 100;
 
  return MAX(base * game.info.shieldbox / 100, 1);
}
 
/**********************************************************************/
int impr_buy_gold_cost(const struct city *pcity,
                       const struct impr_type *pimprove, int shields_in_stock)
{
  int cost = 0;
  const int missing = impr_build_shield_cost(pcity, pimprove) - shields_in_stock;
 
  if (is_convert_improvement(pimprove)) {
    /* Can't buy coinage-like improvements. */
    return 0;
  }
 
  if (missing > 0) {
    cost = 2 * missing;
  }
 
  if (shields_in_stock == 0) {
    cost *= 2;
  }
 
  cost = cost
    * (100 + get_building_bonus(pcity, pimprove, EFT_IMPR_BUY_COST_PCT)) / 100;
 
  return cost;
}
 
/**********************************************************************/
int impr_sell_gold(const struct impr_type *pimprove)
{
  return MAX(pimprove->build_cost * game.info.shieldbox / 100, 1);
}
 
/**********************************************************************/
bool is_wonder(const struct impr_type *pimprove)
{
  return (is_great_wonder(pimprove) || is_small_wonder(pimprove));
}
 
/**********************************************************************/
struct impr_type *improvement_by_translated_name(const char *name)
{
  improvement_iterate(pimprove) {
    if (0 == strcmp(improvement_name_translation(pimprove), name)) {
      return pimprove;
    }
  } improvement_iterate_end;
 
  return NULL;
}
 
/**********************************************************************/
struct impr_type *improvement_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  improvement_iterate(pimprove) {
    if (0 == fc_strcasecmp(improvement_rule_name(pimprove), qname)) {
      return pimprove;
    }
  } improvement_iterate_end;
 
  return NULL;
}
 
/**********************************************************************/
bool improvement_has_flag(const struct impr_type *pimprove,
                          enum impr_flag_id flag)
{
  fc_assert_ret_val(impr_flag_id_is_valid(flag), FALSE);
  return BV_ISSET(pimprove->flags, flag);
}
 
/**********************************************************************/
bool is_improvement_visible(const struct impr_type *pimprove)
{
  return (is_wonder(pimprove)
          || improvement_has_flag(pimprove, IF_VISIBLE_BY_OTHERS));
}
 
/**********************************************************************/
bool can_improvement_go_obsolete(const struct impr_type *pimprove)
{
  return requirement_vector_size(&pimprove->obsolete_by) > 0;
}
 
/**********************************************************************/
bool improvement_obsolete(const struct player *pplayer,
                          const struct impr_type *pimprove,
                          const struct city *pcity)
{
  const struct req_context context = {
    .player = pplayer,
    .city = pcity,
    .tile = pcity ? city_tile(pcity) : NULL,
    .building = pimprove,
  };
 
  requirement_vector_iterate(&pimprove->obsolete_by, preq) {
    if (is_req_active(&context, NULL, preq, RPT_CERTAIN)) {
      return TRUE;
    }
  } requirement_vector_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool impr_provides_buildable_units(const struct city *pcity,
                                          const struct impr_type *pimprove)
{
  const struct civ_map *nmap = &(wld.map);
 
  /* Fast check */
  if (!pimprove->allows_units) {
    return FALSE;
  }
 
  unit_type_iterate(ut) {
    if (requirement_needs_improvement(pimprove, &ut->build_reqs)
        && can_city_build_unit_now(nmap, pcity, ut)) {
      return TRUE;
    }
  } unit_type_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool impr_provides_buildable_extras(const struct city *pcity,
                                           const struct impr_type *pimprove)
{
  const struct civ_map *nmap = &(wld.map);
 
  /* Fast check */
  if (!pimprove->allows_extras) {
    return FALSE;
  }
 
  extra_type_iterate(pextra) {
    if (requirement_needs_improvement(pimprove, &pextra->reqs)) {
      city_tile_iterate(nmap, city_map_radius_sq_get(pcity),
                        city_tile(pcity), ptile) {
        if (player_can_build_extra(pextra, city_owner(pcity), ptile)) {
          return TRUE;
        }
      } city_tile_iterate_end;
    }
  } extra_type_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool impr_prevents_disaster(const struct city *pcity,
                                   const struct impr_type *pimprove)
{
  /* Fast check */
  if (!pimprove->prevents_disaster) {
    return FALSE;
  }
 
  disaster_type_iterate(pdis) {
    if (!requirement_fulfilled_by_improvement(pimprove, &pdis->reqs)
        && !can_disaster_happen(pdis, pcity)) {
      return TRUE;
    }
  } disaster_type_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool impr_protects_vs_actions(const struct city *pcity,
                                     const struct impr_type *pimprove)
{
  /* Fast check */
  if (!pimprove->protects_vs_actions) {
    return FALSE;
  }
 
  action_enablers_iterate(enabler) {
    if (!requirement_fulfilled_by_improvement(pimprove, &enabler->target_reqs)
        && !is_action_possible_on_city(enabler_get_action_id(enabler),
                                       NULL, pcity)) {
      return TRUE;
    }
  } action_enablers_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool impr_allows_actions(const struct city *pcity,
                                const struct impr_type *pimprove)
{
  const struct civ_map *nmap = &(wld.map);
 
  /* Fast check */
  if (!pimprove->allows_actions) {
    return FALSE;
  }
 
  action_enablers_iterate(enabler) {
    if (requirement_needs_improvement(pimprove, &enabler->actor_reqs)) {
      action_id act = enabler_get_action_id(enabler);
 
      switch (action_id_get_actor_kind(act)) {
      case AAK_UNIT:
        unit_type_iterate(ut) {
          if (!utype_can_do_action(ut, act)) {
            /* Not relevant */
            continue;
          }
 
          if (utype_player_already_has_this(city_owner(pcity), ut)) {
            /* The player has a unit that may use the building */
            return TRUE;
          }
 
          if (can_city_build_unit_now(nmap, pcity, ut)) {
            /* This city can build a unit that uses the building */
            return TRUE;
          }
        } unit_type_iterate_end;
        break;
      case AAK_CITY:
      case AAK_PLAYER:
        /* No traceable limitations */
        return TRUE;
      case AAK_COUNT:
        fc_assert(action_id_get_actor_kind(act) != AAK_COUNT);
        break;
      }
    }
  } action_enablers_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
static bool improvement_has_side_effects(const struct city *pcity,
                                         const struct impr_type *pimprove)
{
    return (impr_provides_buildable_units(pcity, pimprove)
            || impr_provides_buildable_extras(pcity, pimprove)
            || impr_prevents_disaster(pcity, pimprove)
            || impr_allows_actions(pcity, pimprove)
            || impr_protects_vs_actions(pcity, pimprove));
}
 
/**********************************************************************/
static bool improvement_has_effects(const struct city *pcity,
                                    const struct impr_type *pimprove)
{
  struct universal source = { .kind = VUT_IMPROVEMENT,
                              .value = { .building = pimprove } };
  struct effect_list *plist = get_req_source_effects(&source);
 
  if (!plist || improvement_obsolete(city_owner(pcity), pimprove, pcity)) {
    return FALSE;
  }
 
  effect_list_iterate(plist, peffect) {
    if (0 != get_potential_improvement_bonus(pimprove, pcity,
                                             peffect->type, RPT_CERTAIN, TRUE)) {
      return TRUE;
    }
  } effect_list_iterate_end;
 
  return FALSE;
}
 
/**********************************************************************/
bool is_improvement_productive(const struct city *pcity,
                               const struct impr_type *pimprove)
{
    return (!improvement_obsolete(city_owner(pcity), pimprove, pcity)
            && (improvement_has_flag(pimprove, IF_GOLD)
                || improvement_has_flag(pimprove, IF_INFRA)
                || improvement_has_side_effects(pcity, pimprove)
                || improvement_has_effects(pcity, pimprove)));
}
 
/**********************************************************************/
bool is_improvement_redundant(const struct city *pcity,
                              const struct impr_type *pimprove)
{
  /* A capitalization production is never redundant. */
  if (improvement_has_flag(pimprove, IF_GOLD)) {
    return FALSE;
  }
  if (improvement_has_flag(pimprove, IF_INFRA)) {
    return FALSE;
  }
 
  /* If an improvement has side effects, don't claim it's redundant. */
  if (improvement_has_side_effects(pcity, pimprove)) {
    return FALSE;
  }
 
  /* Otherwise, it's redundant if its effects are available by other means,
   * or if it's an obsolete wonder (great or small). */
  return is_building_replaced(pcity, pimprove, RPT_CERTAIN)
    || improvement_obsolete(city_owner(pcity), pimprove, pcity);
}
 
/**********************************************************************/
bool can_player_build_improvement_direct(const struct player *p,
                                         const struct impr_type *pimprove)
{
  const struct req_context context = { .player = p };
 
  bool space_part = FALSE;
 
  if (!valid_improvement(pimprove)) {
    return FALSE;
  }
 
  requirement_vector_iterate(&pimprove->reqs, preq) {
    if (preq->range >= REQ_RANGE_PLAYER
        && !is_req_active(&context, NULL, preq, RPT_CERTAIN)) {
      return FALSE;
    }
  } requirement_vector_iterate_end;
 
  /* Check for space part construction.  This assumes that space parts have
   * no other effects. */
  if (building_has_effect(pimprove, EFT_SS_STRUCTURAL)) {
    space_part = TRUE;
    if (p->spaceship.structurals >= NUM_SS_STRUCTURALS) {
      return FALSE;
    }
  }
  if (building_has_effect(pimprove, EFT_SS_COMPONENT)) {
    space_part = TRUE;
    if (p->spaceship.components >= NUM_SS_COMPONENTS) {
      return FALSE;
    }
  }
  if (building_has_effect(pimprove, EFT_SS_MODULE)) {
    space_part = TRUE;
    if (p->spaceship.modules >= NUM_SS_MODULES) {
      return FALSE;
    }
  }
  if (space_part
      && (get_player_bonus(p, EFT_ENABLE_SPACE) <= 0
          || p->spaceship.state >= SSHIP_LAUNCHED)) {
    return FALSE;
  }
 
  if (is_great_wonder(pimprove)) {
    /* Can't build wonder if already built */
    if (!great_wonder_is_available(pimprove)) {
      return FALSE;
    }
  }
 
  return TRUE;
}
 
/**********************************************************************/
bool can_player_build_improvement_now(const struct player *p,
                                      struct impr_type *pimprove)
{
  if (!can_player_build_improvement_direct(p, pimprove)) {
    return FALSE;
  }
  if (improvement_obsolete(p, pimprove, NULL)) {
    return FALSE;
  }
  return TRUE;
}
 
/**********************************************************************/
bool can_player_build_improvement_later(const struct player *p,
                                        const struct impr_type *pimprove)
{
  const struct req_context context = { .player = p };
 
  if (!valid_improvement(pimprove)) {
    return FALSE;
  }
  if (improvement_obsolete(p, pimprove, NULL)) {
    return FALSE;
  }
  if (is_great_wonder(pimprove) && !great_wonder_is_available(pimprove)) {
    /* Can't build wonder if already built */
    return FALSE;
  }
 
  /* Check for requirements that aren't met and that are unchanging (so
   * they can never be met). */
  requirement_vector_iterate(&pimprove->reqs, preq) {
    if (preq->range >= REQ_RANGE_PLAYER
        && is_req_preventing(&context, NULL, preq, RPT_POSSIBLE)) {
      return FALSE;
    }
  } requirement_vector_iterate_end;
  /* FIXME: should check some "unchanging" reqs here - like if there's
   * a nation requirement, we can go ahead and check it now. */
 
  return TRUE;
}
 
/**********************************************************************/
bool is_great_wonder(const struct impr_type *pimprove)
{
  return (pimprove->genus == IG_GREAT_WONDER);
}
 
/**********************************************************************/
bool is_small_wonder(const struct impr_type *pimprove)
{
  return (pimprove->genus == IG_SMALL_WONDER);
}
 
/**********************************************************************/
bool is_improvement(const struct impr_type *pimprove)
{
  return (pimprove->genus == IG_IMPROVEMENT);
}
 
/**********************************************************************/
bool is_special_improvement(const struct impr_type *pimprove)
{
  /* TODO: Find either a new term for traditional "special" improvements
   * (maybe "project"?), or a new umbrella term for all improvements that
   * can't be present in the city as a finished building (including special
   * and convert improvements). */
  return (pimprove->genus == IG_SPECIAL)
      || is_convert_improvement(pimprove);
}
 
/**********************************************************************/
bool is_convert_improvement(const struct impr_type *pimprove)
{
  return (pimprove->genus == IG_CONVERT);
}
 
/**********************************************************************/
void wonder_built(const struct city *pcity, const struct impr_type *pimprove)
{
  struct player *pplayer;
  int windex = improvement_number(pimprove);
 
  fc_assert_ret(NULL != pcity);
  fc_assert_ret(is_wonder(pimprove));
 
  pplayer = city_owner(pcity);
  pplayer->wonders[windex] = pcity->id;
 
  if (is_great_wonder(pimprove)) {
    game.info.great_wonder_owners[windex] = player_number(pplayer);
  }
}
 
/**********************************************************************/
void wonder_destroyed(const struct city *pcity,
                      const struct impr_type *pimprove)
{
  struct player *pplayer;
  int windex = improvement_number(pimprove);
 
  fc_assert_ret(NULL != pcity);
  fc_assert_ret(is_wonder(pimprove));
 
  pplayer = city_owner(pcity);
  fc_assert_ret(pplayer->wonders[windex] == pcity->id);
  pplayer->wonders[windex] = WONDER_LOST;
 
  if (is_great_wonder(pimprove)) {
    fc_assert_ret(game.info.great_wonder_owners[windex]
                   == player_number(pplayer));
    game.info.great_wonder_owners[windex] = WONDER_DESTROYED;
  }
}
 
/**********************************************************************/
bool wonder_is_lost(const struct player *pplayer,
                    const struct impr_type *pimprove)
{
  fc_assert_ret_val(NULL != pplayer, FALSE);
  fc_assert_ret_val(is_wonder(pimprove), FALSE);
 
  return pplayer->wonders[improvement_index(pimprove)] == WONDER_LOST;
}
 
/**********************************************************************/
bool wonder_is_built(const struct player *pplayer,
                     const struct impr_type *pimprove)
{
  fc_assert_ret_val(NULL != pplayer, FALSE);
  fc_assert_ret_val(is_wonder(pimprove), FALSE);
 
  return WONDER_BUILT(pplayer->wonders[improvement_index(pimprove)]);
}
 
/**********************************************************************/
struct city *city_from_wonder(const struct player *pplayer,
                              const struct impr_type *pimprove)
{
  int idx = improvement_index(pimprove);
  int city_id;
 
  if (idx < 0) {
    return NULL;
  }
 
  city_id = pplayer->wonders[idx];
 
  fc_assert_ret_val(NULL != pplayer, NULL);
  fc_assert_ret_val(is_wonder(pimprove), NULL);
 
  if (!WONDER_BUILT(city_id)) {
    return NULL;
  }
 
#ifdef FREECIV_DEBUG
  if (is_server()) {
    /* On client side, this info is not always known. */
    struct city *pcity = player_city_by_number(pplayer, city_id);
 
    if (NULL == pcity) {
      log_error("Player %s (nb %d) has outdated wonder info for "
                "%s (nb %d), it points to city nb %d.",
                player_name(pplayer), player_number(pplayer),
                improvement_rule_name(pimprove),
                improvement_number(pimprove), city_id);
    } else if (!city_has_building(pcity, pimprove)) {
      log_error("Player %s (nb %d) has outdated wonder info for "
                "%s (nb %d), the city %s (nb %d) doesn't have this wonder.",
                player_name(pplayer), player_number(pplayer),
                improvement_rule_name(pimprove),
                improvement_number(pimprove), city_name_get(pcity), pcity->id);
      return NULL;
    }
 
    return pcity;
  }
#endif /* FREECIV_DEBUG */
 
  return player_city_by_number(pplayer, city_id);
}
 
/**********************************************************************/
bool wonder_visible_to_player(const struct impr_type *wonder,
                              const struct player *pplayer,
                              const struct player *owner,
                              enum fc_tristate embassy)
{
  if (pplayer == owner) {
    /* Can see all own wonders,
     * even improvements if that matters. */
    return TRUE;
  }
 
  if (is_great_wonder(wonder)) {
    return TRUE;
  }
 
  if (is_small_wonder(wonder)) {
    switch (game.info.small_wonder_visibility) {
    case WV_ALWAYS:
      return TRUE;
    case WV_NEVER:
      return FALSE;
    case WV_EMBASSY:
      return embassy == TRI_YES
        || (embassy == TRI_MAYBE && team_has_embassy(pplayer->team, owner));
    }
 
    fc_assert(FALSE);
 
    return FALSE;
  }
 
  /* Now a wonder, but regular improvement */
  return FALSE;
}
 
/**********************************************************************/
bool great_wonder_is_built(const struct impr_type *pimprove)
{
  fc_assert_ret_val(is_great_wonder(pimprove), FALSE);
 
  return WONDER_OWNED(game.info.great_wonder_owners
                      [improvement_index(pimprove)]);
}
 
/**********************************************************************/
bool great_wonder_is_destroyed(const struct impr_type *pimprove)
{
  fc_assert_ret_val(is_great_wonder(pimprove), FALSE);
 
  return (WONDER_DESTROYED
          == game.info.great_wonder_owners[improvement_index(pimprove)]);
}
 
/**********************************************************************/
bool great_wonder_is_available(const struct impr_type *pimprove)
{
  fc_assert_ret_val(is_great_wonder(pimprove), FALSE);
 
  return (WONDER_NOT_OWNED
          == game.info.great_wonder_owners[improvement_index(pimprove)]);
}
 
/**********************************************************************/
struct city *city_from_great_wonder(const struct impr_type *pimprove)
{
  int player_id = game.info.great_wonder_owners[improvement_index(pimprove)];
 
  fc_assert_ret_val(is_great_wonder(pimprove), NULL);
 
  if (WONDER_OWNED(player_id)) {
#ifdef FREECIV_DEBUG
    const struct player *pplayer = player_by_number(player_id);
    struct city *pcity = city_from_wonder(pplayer, pimprove);
 
    if (is_server() && NULL == pcity) {
      log_error("Game has outdated wonder info for %s (nb %d), "
                "the player %s (nb %d) doesn't have this wonder.",
                improvement_rule_name(pimprove),
                improvement_number(pimprove),
                player_name(pplayer), player_number(pplayer));
    }
 
    return pcity;
#else
    return city_from_wonder(player_by_number(player_id), pimprove);
#endif /* FREECIV_DEBUG */
  } else {
    return NULL;
  }
}
 
/**********************************************************************/
struct player *great_wonder_owner(const struct impr_type *pimprove)
{
  int player_id = game.info.great_wonder_owners[improvement_index(pimprove)];
 
  fc_assert_ret_val(is_great_wonder(pimprove), NULL);
 
  if (WONDER_OWNED(player_id)) {
    return player_by_number(player_id);
  } else {
    return NULL;
  }
}
 
/**********************************************************************/
bool small_wonder_is_built(const struct player *pplayer,
                           const struct impr_type *pimprove)
{
  fc_assert_ret_val(is_small_wonder(pimprove), FALSE);
 
  return (NULL != pplayer
          && wonder_is_built(pplayer, pimprove));
}
 
/**********************************************************************/
struct city *city_from_small_wonder(const struct player *pplayer,
                                    const struct impr_type *pimprove)
{
  fc_assert_ret_val(is_small_wonder(pimprove), NULL);
 
  if (NULL == pplayer) {
    return NULL; /* Used in some places in the client. */
  } else {
    return city_from_wonder(pplayer, pimprove);
  }
}
 
/**********************************************************************/
bool can_sell_building(const struct impr_type *pimprove)
{
  return (valid_improvement(pimprove)
          && is_building_sellable(pimprove));
}
 
/**********************************************************************/
bool can_city_sell_building(const struct city *pcity,
                            const struct impr_type *pimprove)
{
  return (city_has_building(pcity, pimprove)
          && is_building_sellable(pimprove));
}
 
/**********************************************************************/
bool is_building_sellable(const struct impr_type *pimprove)
{
  return is_improvement(pimprove);
}
 
/**********************************************************************/
enum test_result test_player_sell_building_now(struct player *pplayer,
                                               struct city *pcity,
                                               const struct impr_type *pimprove)
{
  /* Check if player can sell anything from this city */
  if (pcity->owner != pplayer) {
    return TR_OTHER_FAILURE;
  }
 
  if (pcity->did_sell) {
    return TR_ALREADY_SOLD;
  }
 
  /* Check if particular building can be solt */
  if (pimprove != NULL 
      && !can_city_sell_building(pcity, pimprove)) {
    return TR_OTHER_FAILURE;
  }
 
  return TR_SUCCESS;
}
 
/**********************************************************************/
const struct impr_type *improvement_replacement(const struct impr_type *pimprove)
{
  requirement_vector_iterate(&pimprove->obsolete_by, pobs) {
    if (pobs->source.kind == VUT_IMPROVEMENT && pobs->present) {
      return pobs->source.value.building;
    }
  } requirement_vector_iterate_end;
 
  return NULL;
}
 
/************************************************************************/
void user_impr_flags_init(void)
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_BUILDING_FLAGS; i++) {
    user_flag_init(&user_impr_flags[i]);
  }
}
 
/************************************************************************/
void impr_flags_free(void)
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_BUILDING_FLAGS; i++) {
    user_flag_free(&user_impr_flags[i]);
  }
}
 
/************************************************************************/
void set_user_impr_flag_name(enum impr_flag_id id, const char *name,
                              const char *helptxt)
{
  int bfid = id - IF_USER_FLAG_1;
 
  fc_assert_ret(id >= IF_USER_FLAG_1 && id <= IF_LAST_USER_FLAG);
 
  if (user_impr_flags[bfid].name != NULL) {
    FC_FREE(user_impr_flags[bfid].name);
    user_impr_flags[bfid].name = NULL;
  }
 
  if (name && name[0] != '\0') {
    user_impr_flags[bfid].name = fc_strdup(name);
  }
 
  if (user_impr_flags[bfid].helptxt != NULL) {
    free(user_impr_flags[bfid].helptxt);
    user_impr_flags[bfid].helptxt = NULL;
  }
 
  if (helptxt && helptxt[0] != '\0') {
    user_impr_flags[bfid].helptxt = fc_strdup(helptxt);
  }
}
 
/************************************************************************/
const char *impr_flag_id_name_cb(enum impr_flag_id flag)
{
  if (flag < IF_USER_FLAG_1 || flag > IF_LAST_USER_FLAG) {
    return NULL;
  }
 
  return user_impr_flags[flag - IF_USER_FLAG_1].name;
}
 
/************************************************************************/
const char *impr_flag_helptxt(enum impr_flag_id id)
{
  fc_assert(id >= IF_USER_FLAG_1 && id <= IF_LAST_USER_FLAG);
 
  return user_impr_flags[id - IF_USER_FLAG_1].helptxt;
}