common/government.c

   1 /***********************************************************************
   2  Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
   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 /* utility */
  19 #include "fcintl.h"
  20 #include "log.h"
  21 #include "mem.h"
  22 #include "shared.h"
  23 #include "string_vector.h"
  24 #include "support.h"
  25
  26 /* common */
  27 #include "game.h"
  28 #include "player.h"
  29 #include "tech.h"
  30
  31 #include "government.h"
  32
  33 struct government *governments = NULL;
  34
  35 /****************************************************************************
  36   Returns the government that has the given (translated) name.
  37   Returns NULL if none match.
  38 ****************************************************************************/
  39 struct government *government_by_translated_name(const char *name)
  40 {
  41   governments_iterate(gov) {
  42     if (0 == strcmp(government_name_translation(gov), name)) {
  43       return gov;
  44     }
  45   } governments_iterate_end;
  46
  47   return NULL;
  48 }
  49
  50 /****************************************************************************
  51   Returns the government that has the given (untranslated) rule name.
  52   Returns NULL if none match.
  53 ****************************************************************************/
  54 struct government *government_by_rule_name(const char *name)
  55 {
  56   const char *qname = Qn_(name);
  57
  58   governments_iterate(gov) {
  59     if (0 == fc_strcasecmp(government_rule_name(gov), qname)) {
  60       return gov;
  61     }
  62   } governments_iterate_end;
  63
  64   return NULL;
  65 }
  66
  67 /**************************************************************************
  68   Return the number of governments.
  69 **************************************************************************/
  70 Government_type_id government_count(void)
  71 {
  72   return game.control.government_count;
  73 }
  74
  75 /**************************************************************************
  76   Return the government index.
  77
  78   Currently same as government_number(), paired with government_count()
  79   indicates use as an array index.
  80 **************************************************************************/
  81 Government_type_id government_index(const struct government *pgovern)
  82 {
  83   fc_assert_ret_val(NULL != pgovern, -1);
  84   return pgovern - governments;
  85 }
  86
  87 /**************************************************************************
  88   Return the government index.
  89 **************************************************************************/
  90 Government_type_id government_number(const struct government *pgovern)
  91 {
  92   fc_assert_ret_val(NULL != pgovern, -1);
  93   return pgovern->item_number;
  94 }
  95
  96 /****************************************************************************
  97   Return the government with the given index.
  98
  99   This function returns NULL for an out-of-range index (some callers
 100   rely on this).
 101 ****************************************************************************/
 102 struct government *government_by_number(const Government_type_id gov)
 103 {
 104   if (gov < 0 || gov >= game.control.government_count) {
 105     return NULL;
 106   }
 107   return &governments[gov];
 108 }
 109
 110 /****************************************************************************
 111   Return the government of a player.
 112 ****************************************************************************/
 113 struct government *government_of_player(const struct player *pplayer)
 114 {
 115   fc_assert_ret_val(NULL != pplayer, NULL);
 116   return pplayer->government;
 117 }
 118
 119 /****************************************************************************
 120   Return the government of the player who owns the city.
 121 ****************************************************************************/
 122 struct government *government_of_city(const struct city *pcity)
 123 {
 124   fc_assert_ret_val(NULL != pcity, NULL);
 125   return government_of_player(city_owner(pcity));
 126 }
 127
 128 /****************************************************************************
 129   Return the (untranslated) rule name of the government.
 130   You don't have to free the return pointer.
 131 ****************************************************************************/
 132 const char *government_rule_name(const struct government *pgovern)
 133 {
 134   fc_assert_ret_val(NULL != pgovern, NULL);
 135   return rule_name_get(&pgovern->name);
 136 }
 137
 138 /****************************************************************************
 139   Return the (translated) name of the given government.
 140   You don't have to free the return pointer.
 141 ****************************************************************************/
 142 const char *government_name_translation(const struct government *pgovern)
 143 {
 144   fc_assert_ret_val(NULL != pgovern, NULL);
 145
 146   return name_translation_get(&pgovern->name);
 147 }
 148
 149 /****************************************************************************
 150   Return the (translated) name of the given government of a player.
 151   You don't have to free the return pointer.
 152 ****************************************************************************/
 153 const char *government_name_for_player(const struct player *pplayer)
 154 {
 155   return government_name_translation(government_of_player(pplayer));
 156 }
 157
 158 /***************************************************************
 159   Can change to government if appropriate tech exists, and one of:
 160    - no required tech (required is A_NONE)
 161    - player has required tech
 162    - we have an appropriate wonder
 163   Returns FALSE if pplayer is NULL (used for observers).
 164 ***************************************************************/
 165 bool can_change_to_government(struct player *pplayer,
 166                               const struct government *gov)
 167 {
 168   fc_assert_ret_val(NULL != gov, FALSE);
 169
 170   if (!pplayer) {
 171     return FALSE;
 172   }
 173
 174   if (get_player_bonus(pplayer, EFT_ANY_GOVERNMENT) > 0) {
 175     /* Note, this may allow govs that are on someone else's "tech tree". */
 176     return TRUE;
 177   }
 178
 179   return are_reqs_active(pplayer, NULL, NULL, NULL, NULL, NULL, NULL,
 180                          NULL, NULL, NULL, &gov->reqs, RPT_CERTAIN);
 181 }
 182
 183
 184 /****************************************************************************
 185   Ruler titles.
 186 ****************************************************************************/
 187 struct ruler_title {
 188   const struct nation_type *pnation;
 189   struct name_translation male;
 190   struct name_translation female;
 191 };
 192
 193 /****************************************************************************
 194   Hash function.
 195 ****************************************************************************/
 196 static genhash_val_t nation_hash_val(const struct nation_type *pnation)
 197 {
 198   return NULL != pnation ? nation_number(pnation) : nation_count();
 199 }
 200
 201 /****************************************************************************
 202   Hash function.
 203 ****************************************************************************/
 204 static bool nation_hash_comp(const struct nation_type *pnation1,
 205                              const struct nation_type *pnation2)
 206 {
 207   return pnation1 == pnation2;
 208 }
 209
 210 /****************************************************************************
 211   Create a new ruler title.
 212 ****************************************************************************/
 213 static struct ruler_title *ruler_title_new(const struct nation_type *pnation,
 214                                            const char *domain,
 215                                            const char *ruler_male_title,
 216                                            const char *ruler_female_title)
 217 {
 218   struct ruler_title *pruler_title = fc_malloc(sizeof(*pruler_title));
 219
 220   pruler_title->pnation = pnation;
 221   name_set(&pruler_title->male, domain, ruler_male_title);
 222   name_set(&pruler_title->female, domain, ruler_female_title);
 223
 224   return pruler_title;
 225 }
 226
 227 /****************************************************************************
 228   Free a ruler title.
 229 ****************************************************************************/
 230 static void ruler_title_destroy(struct ruler_title *pruler_title)
 231 {
 232   free(pruler_title);
 233 }
 234
 235 /****************************************************************************
 236   Return TRUE if the ruler title is valid.
 237 ****************************************************************************/
 238 static bool ruler_title_check(const struct ruler_title *pruler_title)
 239 {
 240   bool ret = TRUE;
 241
 242   if (!formats_match(rule_name_get(&pruler_title->male), "%s")) {
 243     if (NULL != pruler_title->pnation) {
 244       log_error("\"%s\" male ruler title for nation \"%s\" (nb %d) "
 245                 "is not a format. It should match \"%%s\"",
 246                 rule_name_get(&pruler_title->male),
 247                 nation_rule_name(pruler_title->pnation),
 248                 nation_number(pruler_title->pnation));
 249     } else {
 250       log_error("\"%s\" male ruler title is not a format. "
 251                 "It should match \"%%s\"",
 252                 rule_name_get(&pruler_title->male));
 253     }
 254     ret = FALSE;
 255   }
 256
 257   if (!formats_match(rule_name_get(&pruler_title->female), "%s")) {
 258     if (NULL != pruler_title->pnation) {
 259       log_error("\"%s\" female ruler title for nation \"%s\" (nb %d) "
 260                 "is not a format. It should match \"%%s\"",
 261                 rule_name_get(&pruler_title->female),
 262                 nation_rule_name(pruler_title->pnation),
 263                 nation_number(pruler_title->pnation));
 264     } else {
 265       log_error("\"%s\" female ruler title is not a format. "
 266                 "It should match \"%%s\"",
 267                 rule_name_get(&pruler_title->female));
 268     }
 269     ret = FALSE;
 270   }
 271
 272   if (!formats_match(name_translation_get(&pruler_title->male), "%s")) {
 273     if (NULL != pruler_title->pnation) {
 274       log_error("Translation of \"%s\" male ruler title for nation \"%s\" "
 275                 "(nb %d) is not a format (\"%s\"). It should match \"%%s\"",
 276                 rule_name_get(&pruler_title->male),
 277                 nation_rule_name(pruler_title->pnation),
 278                 nation_number(pruler_title->pnation),
 279                 name_translation_get(&pruler_title->male));
 280     } else {
 281       log_error("Translation of \"%s\" male ruler title is not a format "
 282                 "(\"%s\"). It should match \"%%s\"",
 283                 rule_name_get(&pruler_title->male),
 284                 name_translation_get(&pruler_title->male));
 285     }
 286     ret = FALSE;
 287   }
 288
 289   if (!formats_match(name_translation_get(&pruler_title->female), "%s")) {
 290     if (NULL != pruler_title->pnation) {
 291       log_error("Translation of \"%s\" female ruler title for nation \"%s\" "
 292                 "(nb %d) is not a format (\"%s\"). It should match \"%%s\"",
 293                 rule_name_get(&pruler_title->female),
 294                 nation_rule_name(pruler_title->pnation),
 295                 nation_number(pruler_title->pnation),
 296                 name_translation_get(&pruler_title->female));
 297     } else {
 298       log_error("Translation of \"%s\" female ruler title is not a format "
 299                 "(\"%s\"). It should match \"%%s\"",
 300                 rule_name_get(&pruler_title->female),
 301                 name_translation_get(&pruler_title->female));
 302     }
 303     ret = FALSE;
 304   }
 305
 306   return ret;
 307 }
 308
 309 /****************************************************************************
 310   Returns all ruler titles for a government type.
 311 ****************************************************************************/
 312 const struct ruler_title_hash *
 313 government_ruler_titles(const struct government *pgovern)
 314 {
 315   fc_assert_ret_val(NULL != pgovern, NULL);
 316   return pgovern->ruler_titles;
 317 }
 318
 319 /****************************************************************************
 320   Add a new ruler title for the nation. Pass NULL for pnation for defining
 321   the default title.
 322 ****************************************************************************/
 323 struct ruler_title *
 324 government_ruler_title_new(struct government *pgovern,
 325                            const struct nation_type *pnation,
 326                            const char *ruler_male_title,
 327                            const char *ruler_female_title)
 328 {
 329   const char *domain = NULL;
 330   struct ruler_title *pruler_title;
 331
 332   if (pnation != NULL) {
 333     domain = pnation->translation_domain;
 334   }
 335   pruler_title =
 336     ruler_title_new(pnation, domain, ruler_male_title, ruler_female_title);
 337
 338   if (!ruler_title_check(pruler_title)) {
 339     ruler_title_destroy(pruler_title);
 340     return NULL;
 341   }
 342
 343   if (ruler_title_hash_replace(pgovern->ruler_titles,
 344                                pnation, pruler_title)) {
 345     if (NULL != pnation) {
 346       log_error("Ruler title for government \"%s\" (nb %d) and "
 347                 "nation \"%s\" (nb %d) was set twice.",
 348                 government_rule_name(pgovern), government_number(pgovern),
 349                 nation_rule_name(pnation), nation_number(pnation));
 350     } else {
 351       log_error("Default ruler title for government \"%s\" (nb %d) "
 352                 "was set twice.", government_rule_name(pgovern),
 353                 government_number(pgovern));
 354     }
 355   }
 356
 357   return pruler_title;
 358 }
 359
 360 /****************************************************************************
 361   Return the nation of the rule title. Returns NULL if this is default.
 362 ****************************************************************************/
 363 const struct nation_type *
 364 ruler_title_nation(const struct ruler_title *pruler_title)
 365 {
 366   return pruler_title->pnation;
 367 }
 368
 369 /****************************************************************************
 370   Return the male rule title name.
 371 ****************************************************************************/
 372 const char *
 373 ruler_title_male_untranslated_name(const struct ruler_title *pruler_title)
 374 {
 375   return untranslated_name(&pruler_title->male);
 376 }
 377
 378 /****************************************************************************
 379   Return the female rule title name.
 380 ****************************************************************************/
 381 const char *
 382 ruler_title_female_untranslated_name(const struct ruler_title *pruler_title)
 383 {
 384   return untranslated_name(&pruler_title->female);
 385 }
 386
 387 /****************************************************************************
 388   Return the ruler title of the player (translated).
 389 ****************************************************************************/
 390 const char *ruler_title_for_player(const struct player *pplayer,
 391                                    char *buf, size_t buf_len)
 392 {
 393   const struct government *pgovern = government_of_player(pplayer);
 394   const struct nation_type *pnation = nation_of_player(pplayer);
 395   struct ruler_title *pruler_title;
 396
 397   fc_assert_ret_val(NULL != buf, NULL);
 398   fc_assert_ret_val(0 < buf_len, NULL);
 399
 400   /* Try specific nation rule title. */
 401   if (!ruler_title_hash_lookup(pgovern->ruler_titles,
 402                                pnation, &pruler_title)
 403       /* Try default rule title. */
 404       && !ruler_title_hash_lookup(pgovern->ruler_titles,
 405                                   NULL, &pruler_title)) {
 406     log_error("Missing title for government \"%s\" (nb %d) "
 407               "nation \"%s\" (nb %d).",
 408               government_rule_name(pgovern), government_number(pgovern),
 409               nation_rule_name(pnation), nation_number(pnation));
 410     if (pplayer->is_male) {
 411       fc_snprintf(buf, buf_len, _("Mr. %s"), player_name(pplayer));
 412     } else {
 413       fc_snprintf(buf, buf_len, _("Ms. %s"), player_name(pplayer));
 414     }
 415   } else {
 416     fc_snprintf(buf, buf_len,
 417                 name_translation_get(pplayer->is_male
 418                                      ? &pruler_title->male
 419                                      : &pruler_title->female),
 420                 player_name(pplayer));
 421   }
 422
 423   return buf;
 424 }
 425
 426
 427 /****************************************************************************
 428   Government iterator.
 429 ****************************************************************************/
 430 struct government_iter {
 431   struct iterator vtable;
 432   struct government *p, *end;
 433 };
 434 #define GOVERNMENT_ITER(p) ((struct government_iter *) (p))
 435
 436 /****************************************************************************
 437   Implementation of iterator 'sizeof' function.
 438 ****************************************************************************/
 439 size_t government_iter_sizeof(void)
 440 {
 441   return sizeof(struct government_iter);
 442 }
 443
 444 /****************************************************************************
 445   Implementation of iterator 'next' function.
 446 ****************************************************************************/
 447 static void government_iter_next(struct iterator *iter)
 448 {
 449   GOVERNMENT_ITER(iter)->p++;
 450 }
 451
 452 /****************************************************************************
 453   Implementation of iterator 'get' function.
 454 ****************************************************************************/
 455 static void *government_iter_get(const struct iterator *iter)
 456 {
 457   return GOVERNMENT_ITER(iter)->p;
 458 }
 459
 460 /****************************************************************************
 461   Implementation of iterator 'valid' function.
 462 ****************************************************************************/
 463 static bool government_iter_valid(const struct iterator *iter)
 464 {
 465   struct government_iter *it = GOVERNMENT_ITER(iter);
 466   return it->p < it->end;
 467 }
 468
 469 /****************************************************************************
 470   Implementation of iterator 'init' function.
 471 ****************************************************************************/
 472 struct iterator *government_iter_init(struct government_iter *it)
 473 {
 474   it->vtable.next = government_iter_next;
 475   it->vtable.get = government_iter_get;
 476   it->vtable.valid = government_iter_valid;
 477   it->p = governments;
 478   it->end = governments + government_count();
 479   return ITERATOR(it);
 480 }
 481
 482
 483 /****************************************************************************
 484   Allocate resources associated with the given government.
 485 ****************************************************************************/
 486 static inline void government_init(struct government *pgovern)
 487 {
 488   memset(pgovern, 0, sizeof(*pgovern));
 489
 490   pgovern->item_number = pgovern - governments;
 491   pgovern->ruler_titles =
 492       ruler_title_hash_new_full(nation_hash_val, nation_hash_comp,
 493                                 NULL, NULL, NULL, ruler_title_destroy);
 494   requirement_vector_init(&pgovern->reqs);
 495   pgovern->changed_to_times = 0;
 496   pgovern->disabled = FALSE;
 497 }
 498
 499 /****************************************************************************
 500   De-allocate resources associated with the given government.
 501 ****************************************************************************/
 502 static inline void government_free(struct government *pgovern)
 503 {
 504   ruler_title_hash_destroy(pgovern->ruler_titles);
 505   pgovern->ruler_titles = NULL;
 506
 507   if (NULL != pgovern->helptext) {
 508     strvec_destroy(pgovern->helptext);
 509     pgovern->helptext = NULL;
 510   }
 511
 512   requirement_vector_free(&pgovern->reqs);
 513 }
 514
 515 /****************************************************************************
 516   Allocate the governments.
 517 ****************************************************************************/
 518 void governments_alloc(int num)
 519 {
 520   int i;
 521
 522   fc_assert(NULL == governments);
 523   governments = fc_malloc(sizeof(*governments) * num);
 524   game.control.government_count = num;
 525
 526   for (i = 0; i < game.control.government_count; i++) {
 527     government_init(governments + i);
 528   }
 529 }
 530
 531 /****************************************************************************
 532   De-allocate the currently allocated governments.
 533 ****************************************************************************/
 534 void governments_free(void)
 535 {
 536   int i;
 537
 538   if (NULL == governments) {
 539     return;
 540   }
 541
 542   for (i = 0; i < game.control.government_count; i++) {
 543     government_free(governments + i);
 544   }
 545
 546   free(governments);
 547   governments = NULL;
 548   game.control.government_count = 0;
 549 }
 550
 551 /****************************************************************************
 552   Is it possible to start a revolution without specifying the target
 553   government in the current game?
 554 ****************************************************************************/
 555 bool untargeted_revolution_allowed(void)
 556 {
 557   if (game.info.revolentype == REVOLEN_QUICKENING
 558       || game.info.revolentype == REVOLEN_RANDQUICK) {
 559     /* We need to know the target government at the onset of the revolution
 560      * in order to know how long anarchy will last. */
 561     return FALSE;
 562   }
 563   return TRUE;
 564 }