government.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"
#include "string_vector.h"
#include "support.h"
 
/* common */
#include "game.h"
#include "nation.h"
#include "player.h"
#include "tech.h"
 
#include "government.h"
 
struct government *governments = nullptr;
 
static struct user_flag user_gov_flags[MAX_NUM_USER_GOVERNMENT_FLAGS];
 
/**********************************************************************/
struct government *government_by_translated_name(const char *name)
{
  governments_iterate(gov) {
    if (0 == strcmp(government_name_translation(gov), name)) {
      return gov;
    }
  } governments_iterate_end;
 
  return nullptr;
}
 
/**********************************************************************/
struct government *government_by_rule_name(const char *name)
{
  const char *qname = Qn_(name);
 
  governments_iterate(gov) {
    if (0 == fc_strcasecmp(government_rule_name(gov), qname)) {
      return gov;
    }
  } governments_iterate_end;
 
  return nullptr;
}
 
/**********************************************************************/
Government_type_id government_count(void)
{
  return game.control.government_count;
}
 
/**********************************************************************/
Government_type_id government_index(const struct government *pgovern)
{
  fc_assert_ret_val(pgovern != nullptr, -1);
 
  return pgovern - governments;
}
 
/**********************************************************************/
Government_type_id government_number(const struct government *pgovern)
{
  fc_assert_ret_val(pgovern != nullptr, -1);
 
  return pgovern->item_number;
}
 
/**********************************************************************/
struct government *government_by_number(const Government_type_id gov)
{
  if (gov < 0 || gov >= game.control.government_count) {
    return nullptr;
  }
 
  return &governments[gov];
}
 
/**********************************************************************/
struct government *government_of_player(const struct player *pplayer)
{
  fc_assert_ret_val(pplayer != nullptr, nullptr);
 
  return pplayer->government;
}
 
/**********************************************************************/
struct government *government_of_city(const struct city *pcity)
{
  fc_assert_ret_val(pcity != nullptr, nullptr);
 
  return government_of_player(city_owner(pcity));
}
 
/**********************************************************************/
const char *government_rule_name(const struct government *pgovern)
{
  fc_assert_ret_val(pgovern != nullptr, nullptr);
 
  return rule_name_get(&pgovern->name);
}
 
/**********************************************************************/
const char *government_name_translation(const struct government *pgovern)
{
  fc_assert_ret_val(pgovern != nullptr, nullptr);
 
  return name_translation_get(&pgovern->name);
}
 
/**********************************************************************/
const char *government_name_for_player(const struct player *pplayer)
{
  if (!pplayer->is_alive) {
    return "-";
  }
 
  return government_name_translation(government_of_player(pplayer));
}
 
/**********************************************************************/
bool can_change_to_government(struct player *pplayer,
                              const struct government *gov)
{
  fc_assert_ret_val(gov != nullptr, FALSE);
 
  if (!pplayer) {
    return FALSE;
  }
 
  if (get_player_bonus(pplayer, EFT_ANY_GOVERNMENT) > 0) {
    /* Note, this may allow govs that are on someone else's "tech tree". */
    return TRUE;
  }
 
  return are_reqs_active(&(const struct req_context) { .player = pplayer },
                         nullptr, &gov->reqs, RPT_CERTAIN);
}
 
 
/**************************************************************************
  Ruler titles.
**************************************************************************/
struct ruler_title {
  const struct nation_type *pnation;
  struct name_translation male;
  struct name_translation female;
};
 
/**********************************************************************/
static genhash_val_t nation_hash_val(const struct nation_type *pnation)
{
  return pnation != nullptr ? nation_number(pnation) : nation_count();
}
 
/**********************************************************************/
static bool nation_hash_comp(const struct nation_type *pnation1,
                             const struct nation_type *pnation2)
{
  return pnation1 == pnation2;
}
 
/**********************************************************************/
static struct ruler_title *ruler_title_new(const struct nation_type *pnation,
                                           const char *domain,
                                           const char *ruler_male_title,
                                           const char *ruler_female_title)
{
  struct ruler_title *pruler_title = fc_malloc(sizeof(*pruler_title));
 
  pruler_title->pnation = pnation;
  name_set(&pruler_title->male, domain, ruler_male_title);
  name_set(&pruler_title->female, domain, ruler_female_title);
 
  return pruler_title;
}
 
/**********************************************************************/
static void ruler_title_destroy(struct ruler_title *pruler_title)
{
  free(pruler_title);
}
 
/**********************************************************************/
static bool ruler_title_check(const struct ruler_title *pruler_title)
{
  bool ret = TRUE;
 
  if (!formats_match(rule_name_get(&pruler_title->male), "%s")) {
    if (pruler_title->pnation != nullptr) {
      log_error("\"%s\" male ruler title for nation \"%s\" (nb %d) "
                "is not a format. It should match \"%%s\"",
                rule_name_get(&pruler_title->male),
                nation_rule_name(pruler_title->pnation),
                nation_number(pruler_title->pnation));
    } else {
      log_error("\"%s\" male ruler title is not a format. "
                "It should match \"%%s\"",
                rule_name_get(&pruler_title->male));
    }
    ret = FALSE;
  }
 
  if (!formats_match(rule_name_get(&pruler_title->female), "%s")) {
    if (pruler_title->pnation != nullptr) {
      log_error("\"%s\" female ruler title for nation \"%s\" (nb %d) "
                "is not a format. It should match \"%%s\"",
                rule_name_get(&pruler_title->female),
                nation_rule_name(pruler_title->pnation),
                nation_number(pruler_title->pnation));
    } else {
      log_error("\"%s\" female ruler title is not a format. "
                "It should match \"%%s\"",
                rule_name_get(&pruler_title->female));
    }
    ret = FALSE;
  }
 
  if (!formats_match(name_translation_get(&pruler_title->male), "%s")) {
    if (pruler_title->pnation != nullptr) {
      log_error("Translation of \"%s\" male ruler title for nation \"%s\" "
                "(nb %d) is not a format (\"%s\"). It should match \"%%s\"",
                rule_name_get(&pruler_title->male),
                nation_rule_name(pruler_title->pnation),
                nation_number(pruler_title->pnation),
                name_translation_get(&pruler_title->male));
    } else {
      log_error("Translation of \"%s\" male ruler title is not a format "
                "(\"%s\"). It should match \"%%s\"",
                rule_name_get(&pruler_title->male),
                name_translation_get(&pruler_title->male));
    }
    ret = FALSE;
  }
 
  if (!formats_match(name_translation_get(&pruler_title->female), "%s")) {
    if (pruler_title->pnation != nullptr) {
      log_error("Translation of \"%s\" female ruler title for nation \"%s\" "
                "(nb %d) is not a format (\"%s\"). It should match \"%%s\"",
                rule_name_get(&pruler_title->female),
                nation_rule_name(pruler_title->pnation),
                nation_number(pruler_title->pnation),
                name_translation_get(&pruler_title->female));
    } else {
      log_error("Translation of \"%s\" female ruler title is not a format "
                "(\"%s\"). It should match \"%%s\"",
                rule_name_get(&pruler_title->female),
                name_translation_get(&pruler_title->female));
    }
    ret = FALSE;
  }
 
  return ret;
}
 
/**********************************************************************/
const struct ruler_title_hash *
government_ruler_titles(const struct government *pgovern)
{
  fc_assert_ret_val(pgovern != nullptr, nullptr);
 
  return pgovern->ruler_titles;
}
 
/**********************************************************************/
struct ruler_title *
government_ruler_title_new(struct government *pgovern,
                           const struct nation_type *pnation,
                           const char *ruler_male_title,
                           const char *ruler_female_title)
{
  const char *domain = nullptr;
  struct ruler_title *pruler_title;
 
  if (pnation != nullptr) {
    domain = pnation->translation_domain;
  }
  pruler_title =
    ruler_title_new(pnation, domain, ruler_male_title, ruler_female_title);
 
  if (!ruler_title_check(pruler_title)) {
    ruler_title_destroy(pruler_title);
    return nullptr;
  }
 
  if (ruler_title_hash_replace(pgovern->ruler_titles,
                               pnation, pruler_title)) {
    if (pnation != nullptr) {
      log_error("Ruler title for government \"%s\" (nb %d) and "
                "nation \"%s\" (nb %d) was set twice.",
                government_rule_name(pgovern), government_number(pgovern),
                nation_rule_name(pnation), nation_number(pnation));
    } else {
      log_error("Default ruler title for government \"%s\" (nb %d) "
                "was set twice.", government_rule_name(pgovern),
                government_number(pgovern));
    }
  }
 
  return pruler_title;
}
 
/**********************************************************************/
const struct nation_type *
ruler_title_nation(const struct ruler_title *pruler_title)
{
  return pruler_title->pnation;
}
 
/**********************************************************************/
const char *
ruler_title_male_untranslated_name(const struct ruler_title *pruler_title)
{
  return untranslated_name(&pruler_title->male);
}
 
/**********************************************************************/
const char *
ruler_title_female_untranslated_name(const struct ruler_title *pruler_title)
{
  return untranslated_name(&pruler_title->female);
}
 
/**********************************************************************/
const char *ruler_title_for_player(const struct player *pplayer,
                                   char *buf, size_t buf_len)
{
  const struct government *pgovern = government_of_player(pplayer);
  const struct nation_type *pnation = nation_of_player(pplayer);
  struct ruler_title *pruler_title;
 
  fc_assert_ret_val(buf != nullptr, nullptr);
  fc_assert_ret_val(0 < buf_len, nullptr);
 
  /* Try specific nation ruler title. */
  if (!ruler_title_hash_lookup(pgovern->ruler_titles,
                               pnation, &pruler_title)
      /* Try default ruler title. */
      && !ruler_title_hash_lookup(pgovern->ruler_titles,
                                  nullptr, &pruler_title)) {
    log_error("Missing title for government \"%s\" (nb %d) "
              "nation \"%s\" (nb %d).",
              government_rule_name(pgovern), government_number(pgovern),
              nation_rule_name(pnation), nation_number(pnation));
    default_title_for_player(pplayer, buf, buf_len);
  } else {
    fc_snprintf(buf, buf_len,
                name_translation_get(pplayer->is_male
                                     ? &pruler_title->male
                                     : &pruler_title->female),
                player_name(pplayer));
  }
 
  return buf;
}
 
/**********************************************************************/
const char *default_title_for_player(const struct player *pplayer,
                                     char *buf, size_t buf_len)
{
  if (pplayer->is_male) {
    fc_snprintf(buf, buf_len, _("Mr. %s"), player_name(pplayer));
  } else {
    fc_snprintf(buf, buf_len, _("Ms. %s"), player_name(pplayer));
  }
 
  return buf;
}
 
/**************************************************************************
  Government iterator.
**************************************************************************/
struct government_iter {
  struct iterator vtable;
  struct government *p, *end;
};
#define GOVERNMENT_ITER(p) ((struct government_iter *) (p))
 
/**********************************************************************/
size_t government_iter_sizeof(void)
{
  return sizeof(struct government_iter);
}
 
/**********************************************************************/
static void government_iter_next(struct iterator *iter)
{
  GOVERNMENT_ITER(iter)->p++;
}
 
/**********************************************************************/
static void *government_iter_get(const struct iterator *iter)
{
  return GOVERNMENT_ITER(iter)->p;
}
 
/**********************************************************************/
static bool government_iter_valid(const struct iterator *iter)
{
  struct government_iter *it = GOVERNMENT_ITER(iter);
  return it->p < it->end;
}
 
/**********************************************************************/
struct iterator *government_iter_init(struct government_iter *it)
{
  it->vtable.next = government_iter_next;
  it->vtable.get = government_iter_get;
  it->vtable.valid = government_iter_valid;
  it->p = governments;
  it->end = governments + government_count();
  return ITERATOR(it);
}
 
/**********************************************************************/
static inline void government_init(struct government *pgovern)
{
  memset(pgovern, 0, sizeof(*pgovern));
 
  pgovern->item_number = pgovern - governments;
  pgovern->ruler_titles
    = ruler_title_hash_new_full(nation_hash_val, nation_hash_comp,
                                nullptr, nullptr, nullptr, ruler_title_destroy);
  requirement_vector_init(&pgovern->reqs);
  pgovern->changed_to_times = 0;
  pgovern->ruledit_disabled = FALSE;
  pgovern->ruledit_dlg = nullptr;
}
 
/**********************************************************************/
static inline void government_free(struct government *pgovern)
{
  ruler_title_hash_destroy(pgovern->ruler_titles);
  pgovern->ruler_titles = nullptr;
 
  if (pgovern->helptext != nullptr) {
    strvec_destroy(pgovern->helptext);
    pgovern->helptext = nullptr;
  }
 
  requirement_vector_free(&pgovern->reqs);
}
 
/**********************************************************************/
void governments_alloc(int num)
{
  int i;
 
  fc_assert(governments == nullptr);
 
  governments = fc_malloc(sizeof(*governments) * num);
  game.control.government_count = num;
 
  for (i = 0; i < game.control.government_count; i++) {
    government_init(governments + i);
  }
}
 
/**********************************************************************/
void governments_free(void)
{
  int i;
 
  if (governments == nullptr) {
    return;
  }
 
  for (i = 0; i < game.control.government_count; i++) {
    government_free(governments + i);
  }
 
  free(governments);
  governments = nullptr;
  game.control.government_count = 0;
}
 
/**********************************************************************/
bool untargeted_revolution_allowed(void)
{
  if (game.info.revolentype == REVOLEN_QUICKENING
      || game.info.revolentype == REVOLEN_RANDQUICK) {
    /* We need to know the target government at the onset of the revolution
     * in order to know how long anarchy will last. */
    return FALSE;
  }
 
  return TRUE;
}
 
/**********************************************************************/
bool government_has_flag(const struct government *pgov,
                         enum gov_flag_id flag)
{
  fc_assert_ret_val(gov_flag_id_is_valid(flag), FALSE);
 
  return BV_ISSET(pgov->flags, flag);
}
 
 
/************************************************************************/
void user_gov_flags_init(void)
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_GOVERNMENT_FLAGS; i++) {
    user_flag_init(&user_gov_flags[i]);
  }
}
 
/************************************************************************/
void gov_flags_free(void)
{
  int i;
 
  for (i = 0; i < MAX_NUM_USER_GOVERNMENT_FLAGS; i++) {
    user_flag_free(&user_gov_flags[i]);
  }
}
 
/************************************************************************/
void set_user_gov_flag_name(enum gov_flag_id id, const char *name,
                            const char *helptxt)
{
  int gfid = id - GOVF_USER_FLAG_1;
 
  fc_assert_ret(id >= GOVF_USER_FLAG_1 && id <= GOVF_LAST_USER_FLAG);
 
  free(user_gov_flags[gfid].name);
  user_gov_flags[gfid].name = nullptr;
 
  if (name && name[0] != '\0') {
    user_gov_flags[gfid].name = fc_strdup(name);
  }
 
  free(user_gov_flags[gfid].helptxt);
  user_gov_flags[gfid].helptxt = nullptr;
 
  if (helptxt && helptxt[0] != '\0') {
    user_gov_flags[gfid].helptxt = fc_strdup(helptxt);
  }
}
 
/************************************************************************/
const char *gov_flag_id_name_cb(enum gov_flag_id flag)
{
  if (flag < GOVF_USER_FLAG_1 || flag > GOVF_LAST_USER_FLAG) {
    return nullptr;
  }
 
  return user_gov_flags[flag - GOVF_USER_FLAG_1].name;
}
 
/************************************************************************/
const char *gov_flag_helptxt(enum gov_flag_id id)
{
  fc_assert(id >= GOVF_USER_FLAG_1 && id <= GOVF_LAST_USER_FLAG);
 
  return user_gov_flags[id - GOVF_USER_FLAG_1].helptxt;
}