nation.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  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
    /o)  (o/\ \_                General Public License along with Freeciv21.
    \_____/ /                     If not, see https://www.gnu.org/licenses/.
      \____/        ********************************************************/
 
// utility
#include "fcintl.h"
#include "name_translation.h"
#include "support.h"
 
// common
#include "connection.h"
#include "game.h"
#include "government.h"
#include "player.h"
#include "traits.h"
 
#include "nation.h"
 
// Nation set structure.
struct nation_set {
  struct name_translation name;
  char description[MAX_LEN_MSG];
};
 
std::vector<nation_type> nations;
static int num_nation_sets;
static struct nation_set nation_sets[MAX_NUM_NATION_SETS];
static int num_nation_groups;
static struct nation_group nation_groups[MAX_NUM_NATION_GROUPS];
 
#ifdef FREECIV_DEBUG
#define NATION_CHECK(pnation, action)                                       \
  fc_assert_action(nation_check(pnation), action)
 
static bool nation_check(const nation_type *pnation)
{
  if (0 == game.control.nation_count) {
    qCritical("Function called before nations setup.");
    return false;
  }
  if (nullptr == pnation) {
    qCritical("This function has nullptr nation argument.");
    return false;
  }
  if (pnation->item_number < 0
      || pnation->item_number >= game.control.nation_count
      || &nations[nation_index(pnation)] != pnation) {
    qCritical("This function has bad nation number %d (count %d).",
              pnation->item_number, game.control.nation_count);
    return false;
  }
  return true;
}
 
#else                                 // FREECIV_DEBUG
#define NATION_CHECK(pnation, action) // Do Nothing.
#endif                                // FREECIV_DEBUG
 
struct nation_type *nation_by_translated_plural(const char *name)
{
  for (auto &pnation : nations) {
    if (0 == strcmp(nation_plural_translation(&pnation), name)) {
      return &pnation;
    }
  } // iterate over nations - pnation
 
  return NO_NATION_SELECTED;
}
 
struct nation_type *nation_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  for (auto &pnation : nations) {
    if (0 == fc_strcasecmp(nation_rule_name(&pnation), qname)) {
      return &pnation;
    }
  } // iterate over nations - pnation
 
  return NO_NATION_SELECTED;
}
 
const char *nation_rule_name(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return "");
 
  return rule_name_get(&pnation->adjective);
}
 
const char *nation_adjective_translation(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return "");
  return name_translation_get(&pnation->adjective);
}
 
const char *nation_plural_translation(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return "");
  return name_translation_get(&pnation->noun_plural);
}
 
const char *nation_adjective_for_player(const struct player *pplayer)
{
  return nation_adjective_translation(nation_of_player(pplayer));
}
 
const char *nation_plural_for_player(const struct player *pplayer)
{
  return nation_plural_translation(nation_of_player(pplayer));
}
 
bool is_nation_pickable(const struct nation_type *nation)
{
  fc_assert_ret_val(!is_server(), false);
  return nation->client.is_pickable;
}
 
bool is_nation_playable(const struct nation_type *nation)
{
  NATION_CHECK(nation, return false);
  return nation->is_playable;
}
 
enum barbarian_type nation_barbarian_type(const struct nation_type *nation)
{
  NATION_CHECK(nation, return NOT_A_BARBARIAN);
  return nation->barb_type;
}
 
struct nation_leader {
  char *name;
  bool is_male;
};
 
const struct nation_leader_list *
nation_leaders(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return nullptr);
  return pnation->leaders;
}
 
struct nation_leader *nation_leader_new(struct nation_type *pnation,
                                        const char *name, bool is_male)
{
  NATION_CHECK(pnation, return nullptr);
  auto *pleader = new nation_leader;
  pleader->name = fc_strdup(name);
  pleader->is_male = is_male;
 
  nation_leader_list_append(pnation->leaders, pleader);
  return pleader;
}
 
static void nation_leader_destroy(struct nation_leader *pleader)
{
  delete[] pleader->name;
  delete pleader;
}
 
struct nation_leader *
nation_leader_by_name(const struct nation_type *pnation, const char *name)
{
  NATION_CHECK(pnation, return nullptr);
  nation_leader_list_iterate(pnation->leaders, pleader)
  {
    if (0 == fc_strcasecmp(name, pleader->name)) {
      return pleader;
    }
  }
  nation_leader_list_iterate_end;
  return nullptr;
}
 
const char *nation_leader_name(const struct nation_leader *pleader)
{
  fc_assert_ret_val(nullptr != pleader, nullptr);
  return pleader->name;
}
 
bool nation_leader_is_male(const struct nation_leader *pleader)
{
  fc_assert_ret_val(nullptr != pleader, true);
  return pleader->is_male;
}
 
const char *nation_legend_translation(const struct nation_type *pnation,
                                      const char *legend)
{
  if (pnation->translation_domain == nullptr) {
    return _(legend);
  }
 
  return DG_(pnation->translation_domain, legend);
}
 
struct nation_city {
  char *name;
  enum nation_city_preference river;
  enum nation_city_preference terrain[MAX_NUM_TERRAINS];
};
 
const struct nation_city_list *
nation_cities(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return nullptr);
  fc_assert_ret_val(is_server(), nullptr);
 
  return pnation->server.default_cities;
}
 
struct nation_city *nation_city_new(struct nation_type *pnation,
                                    const char *name)
{
  struct nation_city *pncity;
 
  NATION_CHECK(pnation, return nullptr);
  fc_assert_ret_val(is_server(), nullptr);
 
  fc_assert(0 == NCP_NONE);
  pncity = new nation_city{}; // Set NCP_NONE.
  pncity->name = fc_strdup(name);
 
  nation_city_list_append(pnation->server.default_cities, pncity);
  return pncity;
}
 
static void nation_city_destroy(struct nation_city *pncity)
{
  delete[] pncity->name;
  delete pncity;
}
 
enum nation_city_preference
nation_city_preference_revert(enum nation_city_preference prefer)
{
  switch (prefer) {
  case NCP_DISLIKE:
    return NCP_LIKE;
  case NCP_NONE:
    return NCP_NONE;
  case NCP_LIKE:
    return NCP_DISLIKE;
  }
 
  qCritical("%s(): Wrong nation_city_preference variant (%d).", __FUNCTION__,
            prefer);
  return NCP_NONE;
}
 
void nation_city_set_terrain_preference(struct nation_city *pncity,
                                        const struct terrain *pterrain,
                                        enum nation_city_preference prefer)
{
  fc_assert_ret(nullptr != pncity);
  fc_assert_ret(nullptr != pterrain);
  pncity->terrain[terrain_index(pterrain)] = prefer;
}
 
void nation_city_set_river_preference(struct nation_city *pncity,
                                      enum nation_city_preference prefer)
{
  fc_assert_ret(nullptr != pncity);
  pncity->river = prefer;
}
 
const char *nation_city_name(const struct nation_city *pncity)
{
  fc_assert_ret_val(nullptr != pncity, nullptr);
  return pncity->name;
}
 
enum nation_city_preference
nation_city_terrain_preference(const struct nation_city *pncity,
                               const struct terrain *pterrain)
{
  fc_assert_ret_val(nullptr != pncity, NCP_DISLIKE);
  fc_assert_ret_val(nullptr != pterrain, NCP_DISLIKE);
  return pncity->terrain[terrain_index(pterrain)];
}
 
enum nation_city_preference
nation_city_river_preference(const struct nation_city *pncity)
{
  fc_assert_ret_val(nullptr != pncity, NCP_DISLIKE);
  return pncity->river;
}
 
struct nation_type *nation_of_player(const struct player *pplayer)
{
  fc_assert_ret_val(nullptr != pplayer, nullptr);
  NATION_CHECK(pplayer->nation, return nullptr);
  return pplayer->nation;
}
 
struct nation_type *nation_of_city(const struct city *pcity)
{
  fc_assert_ret_val(pcity != nullptr, nullptr);
  return nation_of_player(city_owner(pcity));
}
 
struct nation_type *nation_of_unit(const struct unit *punit)
{
  fc_assert_ret_val(punit != nullptr, nullptr);
  return nation_of_player(unit_owner(punit));
}
 
struct nation_type *nation_by_number(const Nation_type_id nation)
{
  if (nation < 0 || nation >= game.control.nation_count) {
    return nullptr;
  }
  return &nations[nation];
}
 
Nation_type_id nation_index(const struct nation_type *pnation)
{
  fc_assert_ret_val(nullptr != pnation, 0);
  return pnation - &nations[0];
}
 
nation_type::nation_type()
{
  name_init(&adjective);
  name_init(&noun_plural);
 
  leaders = nation_leader_list_new_full(nation_leader_destroy);
  sets = nation_set_list_new();
  groups = nation_group_list_new();
 
  if (is_server()) {
    server.default_cities = nation_city_list_new_full(nation_city_destroy);
    server.civilwar_nations = nation_list_new();
    server.parent_nations = nation_list_new();
    server.conflicts_with = nation_list_new();
    server.rgb = nullptr;
    server.traits = new trait_limits[TRAIT_COUNT];
  } else {
    client.is_pickable = true;
  }
}
 
nation_type::~nation_type()
{
  delete[] legend;
  delete[] translation_domain;
  nation_leader_list_destroy(leaders);
  nation_set_list_destroy(sets);
  nation_group_list_destroy(groups);
 
  if (is_server()) {
    nation_city_list_destroy(server.default_cities);
    nation_list_destroy(server.civilwar_nations);
    nation_list_destroy(server.parent_nations);
    nation_list_destroy(server.conflicts_with);
    rgbcolor_destroy(server.rgb);
    delete[] server.traits;
  }
}
 
void nations_alloc(int num)
{
  game.control.nation_count = num;
  nations.resize(game.control.nation_count);
  int i = 0;
  for (auto &pnation : nations) {
    pnation.item_number = i++;
  } // iterate over nations - pnation
}
 
void nations_free()
{
  nations.clear();
  game.control.nation_count = 0;
}
 
struct government *
init_government_of_nation(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return game.default_government);
  if (pnation->init_government) {
    return pnation->init_government;
  } else {
    return game.default_government;
  }
}
 
struct nation_style *style_of_nation(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return 0);
  return pnation->style;
}
 
const struct rgbcolor *nation_color(const struct nation_type *pnation)
{
  NATION_CHECK(pnation, return nullptr);
  return pnation->server.rgb;
}
 
int nation_set_count() { return num_nation_sets; }
 
int nation_set_index(const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pset, 0);
  return pset - nation_sets;
}
 
int nation_set_number(const struct nation_set *pset)
{
  return nation_set_index(pset);
}
 
struct nation_set *nation_set_new(const char *set_name,
                                  const char *set_rule_name,
                                  const char *set_description)
{
  struct nation_set *pset;
 
  if (MAX_NUM_NATION_SETS <= num_nation_sets) {
    qCritical("Too many nation sets (%d is the maximum).",
              MAX_NUM_NATION_SETS);
    return nullptr;
  }
 
  // Print the name and truncate if needed.
  pset = nation_sets + num_nation_sets;
  names_set(&pset->name, nullptr, set_name, set_rule_name);
  (void) sz_loud_strlcpy(
      pset->description, set_description,
      "Nation set description \"%s\" too long; truncating.");
 
  if (nullptr != nation_set_by_rule_name(rule_name_get(&pset->name))) {
    qCritical("Duplicate nation set name %s.", rule_name_get(&pset->name));
    return nullptr;
  }
 
  if (nullptr != nation_group_by_rule_name(rule_name_get(&pset->name))) {
    qCritical("Nation set name %s is already used for a group.",
              rule_name_get(&pset->name));
    return nullptr;
  }
 
  num_nation_sets++;
 
  return pset;
}
 
struct nation_set *nation_set_by_number(int id)
{
  if (id < 0 || id >= num_nation_sets) {
    return nullptr;
  }
  return nation_sets + id;
}
 
struct nation_set *nation_set_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  nation_sets_iterate(pset)
  {
    if (0 == fc_strcasecmp(rule_name_get(&pset->name), qname)) {
      return pset;
    }
  }
  nation_sets_iterate_end;
 
  return nullptr;
}
 
const char *nation_set_untranslated_name(const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pset, nullptr);
  return untranslated_name(&pset->name);
}
 
const char *nation_set_rule_name(const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pset, nullptr);
 
  return rule_name_get(&pset->name);
}
 
const char *nation_set_name_translation(const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pset, nullptr);
  return name_translation_get(&pset->name);
}
 
const char *nation_set_description(const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pset, nullptr);
  return pset->description;
}
 
bool nation_is_in_set(const struct nation_type *pnation,
                      const struct nation_set *pset)
{
  fc_assert_ret_val(nullptr != pnation, false);
 
  nation_set_list_iterate(pnation->sets, aset)
  {
    if (aset == pset) {
      return true;
    }
  }
  nation_set_list_iterate_end;
  return false;
}
 
struct nation_set *nation_set_by_setting_value(const char *setting)
{
  struct nation_set *pset = nullptr;
 
  if (strlen(setting) > 0) {
    pset = nation_set_by_rule_name(setting);
  }
  if (pset == nullptr) {
    /* Either no nation set specified, or the specified one isn't in the
     * current ruleset. Default to the first nation set specified by
     * the ruleset. */
    pset = nation_set_by_number(0);
  }
  fc_assert(pset != nullptr);
 
  return pset;
}
 
struct nation_set_iter {
  struct iterator vtable;
  struct nation_set *p, *end;
};
#define NATION_SET_ITER(p) ((struct nation_set_iter *) (p))
 
size_t nation_set_iter_sizeof() { return sizeof(struct nation_set_iter); }
 
static void nation_set_iter_next(struct iterator *iter)
{
  NATION_SET_ITER(iter)->p++;
}
 
static void *nation_set_iter_get(const struct iterator *iter)
{
  return NATION_SET_ITER(iter)->p;
}
 
static bool nation_set_iter_valid(const struct iterator *iter)
{
  struct nation_set_iter *it = NATION_SET_ITER(iter);
  return it->p < it->end;
}
 
struct iterator *nation_set_iter_init(struct nation_set_iter *it)
{
  it->vtable.next = nation_set_iter_next;
  it->vtable.get = nation_set_iter_get;
  it->vtable.valid = nation_set_iter_valid;
  it->p = nation_sets;
  it->end = nation_sets + nation_set_count();
  return ITERATOR(it);
}
 
int nation_group_count() { return num_nation_groups; }
 
int nation_group_index(const struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pgroup, 0);
  return pgroup - nation_groups;
}
 
int nation_group_number(const struct nation_group *pgroup)
{
  return nation_group_index(pgroup);
}
 
struct nation_group *nation_group_new(const char *name)
{
  struct nation_group *pgroup;
 
  if (MAX_NUM_NATION_GROUPS <= num_nation_groups) {
    qCritical("Too many nation groups (%d is the maximum).",
              MAX_NUM_NATION_GROUPS);
    return nullptr;
  }
 
  // Print the name and truncate if needed.
  pgroup = nation_groups + num_nation_groups;
  name_set(&pgroup->name, nullptr, name);
  if (nullptr != nation_group_by_rule_name(rule_name_get(&pgroup->name))) {
    qCritical("Duplicate nation group name %s.",
              rule_name_get(&pgroup->name));
    return nullptr;
  }
 
  if (nullptr != nation_set_by_rule_name(rule_name_get(&pgroup->name))) {
    qCritical("Nation group name %s is already used for a set.",
              rule_name_get(&pgroup->name));
    return nullptr;
  }
 
  if (is_server()) {
    pgroup->server.match = 0;
  }
  num_nation_groups++;
 
  return pgroup;
}
 
struct nation_group *nation_group_by_number(int id)
{
  if (id < 0 || id >= num_nation_groups) {
    return nullptr;
  }
  return nation_groups + id;
}
 
struct nation_group *nation_group_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  nation_groups_iterate(pgroup)
  {
    if (0 == fc_strcasecmp(rule_name_get(&pgroup->name), qname)) {
      return pgroup;
    }
  }
  nation_groups_iterate_end;
 
  return nullptr;
}
 
void nation_group_set_hidden(struct nation_group *pgroup, bool hidden)
{
  fc_assert_ret(nullptr != pgroup);
  pgroup->hidden = hidden;
}
 
void nation_group_set_match(struct nation_group *pgroup, int match)
{
  fc_assert_ret(is_server());
  fc_assert_ret(nullptr != pgroup);
  pgroup->server.match = match;
}
 
bool is_nation_group_hidden(struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pgroup, true);
  return pgroup->hidden;
}
 
const char *nation_group_untranslated_name(const struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pgroup, nullptr);
  return untranslated_name(&pgroup->name);
}
 
const char *nation_group_rule_name(const struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pgroup, nullptr);
 
  return rule_name_get(&pgroup->name);
}
 
const char *nation_group_name_translation(const struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pgroup, nullptr);
  return name_translation_get(&pgroup->name);
}
 
bool nation_is_in_group(const struct nation_type *pnation,
                        const struct nation_group *pgroup)
{
  fc_assert_ret_val(nullptr != pnation, false);
 
  nation_group_list_iterate(pnation->groups, agroup)
  {
    if (agroup == pgroup) {
      return true;
    }
  }
  nation_group_list_iterate_end;
  return false;
}
 
struct nation_group_iter {
  struct iterator vtable;
  struct nation_group *p, *end;
};
#define NATION_GROUP_ITER(p) ((struct nation_group_iter *) (p))
 
size_t nation_group_iter_sizeof()
{
  return sizeof(struct nation_group_iter);
}
 
static void nation_group_iter_next(struct iterator *iter)
{
  NATION_GROUP_ITER(iter)->p++;
}
 
static void *nation_group_iter_get(const struct iterator *iter)
{
  return NATION_GROUP_ITER(iter)->p;
}
 
static bool nation_group_iter_valid(const struct iterator *iter)
{
  struct nation_group_iter *it = NATION_GROUP_ITER(iter);
  return it->p < it->end;
}
 
struct iterator *nation_group_iter_init(struct nation_group_iter *it)
{
  it->vtable.next = nation_group_iter_next;
  it->vtable.get = nation_group_iter_get;
  it->vtable.valid = nation_group_iter_valid;
  it->p = nation_groups;
  it->end = nation_groups + nation_group_count();
  return ITERATOR(it);
}
 
/*
   Initializes all nation set/group data.
 */
void nation_sets_groups_init() { num_nation_sets = num_nation_groups = 0; }
 
void nation_sets_groups_free() { num_nation_sets = num_nation_groups = 0; }
 
bool can_conn_edit_players_nation(const struct connection *pconn,
                                  const struct player *pplayer)
{
  return (can_conn_edit(pconn)
          || (game.info.is_new_game
              && ((!pconn->observer && pconn->playing == pplayer)
                  || pconn->access_level >= ALLOW_CTRL)));
}
 
int nations_match(const struct nation_type *pnation1,
                  const struct nation_type *pnation2, bool ignore_conflicts)
{
  bool in_conflict = false;
  int sum = 0;
 
  fc_assert_ret_val(is_server(), -1);
  NATION_CHECK(pnation1, return -1);
  NATION_CHECK(pnation2, return -1);
 
  if (!ignore_conflicts) {
    nation_list_iterate(pnation1->server.conflicts_with, pnation0)
    {
      if (pnation0 == pnation2) {
        in_conflict = true;
        sum = 1; // Be sure to returns something negative.
        break;
      }
    }
    nation_list_iterate_end;
 
    if (!in_conflict) {
      nation_list_iterate(pnation2->server.conflicts_with, pnation0)
      {
        if (pnation0 == pnation1) {
          in_conflict = true;
          sum = 1; // Be sure to returns something negative.
          break;
        }
      }
      nation_list_iterate_end;
    }
  }
 
  nation_group_list_iterate(pnation1->groups, pgroup)
  {
    if (nation_is_in_group(pnation2, pgroup)) {
      sum += pgroup->server.match;
    }
  }
  nation_group_list_iterate_end;
 
  return (in_conflict ? -sum : sum);
}