common/nation.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 /***********************************************************************
  15    Functions for handling the nations.
  16 ************************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <fc_config.h>
  20 #endif
  21
  22 /* utility */
  23 #include "fcintl.h"
  24 #include "log.h"
  25 #include "mem.h"
  26 #include "support.h"
  27
  28 /* common */
  29 #include "connection.h"
  30 #include "game.h"
  31 #include "government.h"
  32 #include "player.h"
  33 #include "tech.h"
  34 #include "traits.h"
  35
  36 #include "nation.h"
  37
  38
  39 /* Nation set structure. */
  40 struct nation_set {
  41   struct name_translation name;
  42   char description[MAX_LEN_MSG];
  43 };
  44
  45 static struct nation_type *nations = NULL;
  46
  47 static int num_nation_sets;
  48 static struct nation_set nation_sets[MAX_NUM_NATION_SETS];
  49 static int num_nation_groups;
  50 static struct nation_group nation_groups[MAX_NUM_NATION_GROUPS];
  51
  52 /****************************************************************************
  53   Runs action if the nation is not valid.
  54 ****************************************************************************/
  55 #ifdef FREECIV_DEBUG
  56 #define NATION_CHECK(pnation, action)                                       \
  57     fc_assert_action(nation_check(pnation,                                  \
  58                                   log_do_output_for_level(LOG_ERROR),       \
  59                                   __FILE__, __FUNCTION__, __FC_LINE__),     \
  60                                   action)
  61
  62 /****************************************************************************
  63   Returns TRUE if the nation is valid, else, print an error message and
  64   returns FALSE.
  65 ****************************************************************************/
  66 static inline bool nation_check(const struct nation_type *pnation,
  67                                 bool do_output, const char *file,
  68                                 const char *function, int line)
  69 {
  70   if (0 == nation_count()) {
  71     if (do_output) {
  72       do_log(file, function, line, TRUE, LOG_ERROR,
  73              "Function called before nations setup.");
  74     }
  75     return FALSE;
  76   }
  77   if (NULL == pnation) {
  78     if (do_output) {
  79       do_log(file, function, line, TRUE, LOG_ERROR,
  80              "This function has NULL nation argument.");
  81     }
  82     return FALSE;
  83   }
  84   if (pnation->item_number < 0
  85       || pnation->item_number >= nation_count()
  86       || &nations[nation_index(pnation)] != pnation) {
  87     if (do_output) {
  88       do_log(file, function, line, TRUE, LOG_ERROR,
  89              "This function has bad nation number %d (count %d).",
  90              pnation->item_number, nation_count());
  91     }
  92     return FALSE;
  93   }
  94   return TRUE;
  95 }
  96
  97 #else  /* FREECIV_DEBUG */
  98 #define NATION_CHECK(pnation, action) /* Do Nothing. */
  99 #endif /* FREECIV_DEBUG */
 100
 101 /****************************************************************************
 102   Returns the nation that has the given (translated) plural noun.
 103   Returns NO_NATION_SELECTED if none match.
 104 ****************************************************************************/
 105 struct nation_type *nation_by_translated_plural(const char *name)
 106 {
 107   nations_iterate(pnation) {
 108     if (0 == strcmp(nation_plural_translation(pnation), name)) {
 109       return pnation;
 110     }
 111   } nations_iterate_end;
 112
 113   return NO_NATION_SELECTED;
 114 }
 115
 116 /****************************************************************************
 117   Returns the nation that has the given (untranslated) rule name (adjective).
 118   Returns NO_NATION_SELECTED if none match.
 119 ****************************************************************************/
 120 struct nation_type *nation_by_rule_name(const char *name)
 121 {
 122   const char *qname = Qn_(name);
 123
 124   nations_iterate(pnation) {
 125     if (0 == fc_strcasecmp(nation_rule_name(pnation), qname)) {
 126       return pnation;
 127     }
 128   } nations_iterate_end;
 129
 130   return NO_NATION_SELECTED;
 131 }
 132
 133 /****************************************************************************
 134   Return the (untranslated) rule name of the nation (adjective form).
 135   You don't have to free the return pointer.
 136 ****************************************************************************/
 137 const char *nation_rule_name(const struct nation_type *pnation)
 138 {
 139   NATION_CHECK(pnation, return "");
 140
 141   return rule_name_get(&pnation->adjective);
 142 }
 143
 144 /****************************************************************************
 145   Return the (translated) adjective for the given nation.
 146   You don't have to free the return pointer.
 147 ****************************************************************************/
 148 const char *nation_adjective_translation(const struct nation_type *pnation)
 149 {
 150   NATION_CHECK(pnation, return "");
 151   return name_translation_get(&pnation->adjective);
 152 }
 153
 154 /****************************************************************************
 155   Return the (translated) plural noun of the given nation.
 156   You don't have to free the return pointer.
 157 ****************************************************************************/
 158 const char *nation_plural_translation(const struct nation_type *pnation)
 159 {
 160   NATION_CHECK(pnation, return "");
 161   return name_translation_get(&pnation->noun_plural);
 162 }
 163
 164 /****************************************************************************
 165   Return the (translated) adjective for the given nation of a player.
 166   You don't have to free the return pointer.
 167 ****************************************************************************/
 168 const char *nation_adjective_for_player(const struct player *pplayer)
 169 {
 170   return nation_adjective_translation(nation_of_player(pplayer));
 171 }
 172
 173 /****************************************************************************
 174   Return the (translated) plural noun of the given nation of a player.
 175   You don't have to free the return pointer.
 176 ****************************************************************************/
 177 const char *nation_plural_for_player(const struct player *pplayer)
 178 {
 179   return nation_plural_translation(nation_of_player(pplayer));
 180 }
 181
 182 /****************************************************************************
 183   Return whether a nation is "pickable" -- whether players can select it
 184   at game start.
 185   (Client only function -- on the server, use client_can_pick_nation().)
 186 ****************************************************************************/
 187 bool is_nation_pickable(const struct nation_type *nation)
 188 {
 189   fc_assert_ret_val(!is_server(), FALSE);
 190   return nation->client.is_pickable;
 191 }
 192
 193 /****************************************************************************
 194   Return whether a nation is "playable"; i.e., whether a human player can
 195   choose this nation.  Barbarian and observer nations are not playable.
 196
 197   This does not check whether a nation is "used" or "available".
 198 ****************************************************************************/
 199 bool is_nation_playable(const struct nation_type *nation)
 200 {
 201   NATION_CHECK(nation, return FALSE);
 202   return nation->is_playable;
 203 }
 204
 205 /****************************************************************************
 206   Returns which kind of barbarians can use this nation.
 207
 208   This does not check whether a nation is "used" or "available".
 209 ****************************************************************************/
 210 enum barbarian_type nation_barbarian_type(const struct nation_type *nation)
 211 {
 212   NATION_CHECK(nation, return NOT_A_BARBARIAN);
 213   return nation->barb_type;
 214 }
 215
 216
 217 /****************************************************************************
 218   Nation leader.
 219 ****************************************************************************/
 220 struct nation_leader {
 221   char *name;
 222   bool is_male;
 223 };
 224
 225 /****************************************************************************
 226   Returns the list the nation leader names.
 227 ****************************************************************************/
 228 const struct nation_leader_list *
 229 nation_leaders(const struct nation_type *pnation)
 230 {
 231   NATION_CHECK(pnation, return NULL);
 232   return pnation->leaders;
 233 }
 234
 235 /****************************************************************************
 236   Create a new leader for the nation.
 237 ****************************************************************************/
 238 struct nation_leader *nation_leader_new(struct nation_type *pnation,
 239                                         const char *name, bool is_male)
 240 {
 241   struct nation_leader *pleader;
 242
 243   NATION_CHECK(pnation, return NULL);
 244   pleader = fc_malloc(sizeof(*pleader));
 245   pleader->name = fc_strdup(name);
 246   pleader->is_male = is_male;
 247
 248   nation_leader_list_append(pnation->leaders, pleader);
 249   return pleader;
 250 }
 251
 252 /****************************************************************************
 253   Destroy a nation leader created with nation_leader_new().
 254 ****************************************************************************/
 255 static void nation_leader_destroy(struct nation_leader *pleader)
 256 {
 257   free(pleader->name);
 258   free(pleader);
 259 }
 260
 261 /****************************************************************************
 262   Returns the nation leader structure which match 'name' or NULL if not
 263   found.
 264 ****************************************************************************/
 265 struct nation_leader *
 266 nation_leader_by_name(const struct nation_type *pnation, const char *name)
 267 {
 268   NATION_CHECK(pnation, return NULL);
 269   nation_leader_list_iterate(pnation->leaders, pleader) {
 270     if (0 == fc_strcasecmp(name, pleader->name)) {
 271       return pleader;
 272     }
 273   } nation_leader_list_iterate_end;
 274   return NULL;
 275 }
 276
 277 /****************************************************************************
 278   Return the name of the nation leader.
 279 ****************************************************************************/
 280 const char *nation_leader_name(const struct nation_leader *pleader)
 281 {
 282   fc_assert_ret_val(NULL != pleader, NULL);
 283   return pleader->name;
 284 }
 285
 286 /****************************************************************************
 287   Return the sex of the nation leader.
 288 ****************************************************************************/
 289 bool nation_leader_is_male(const struct nation_leader *pleader)
 290 {
 291   fc_assert_ret_val(NULL != pleader, TRUE);
 292   return pleader->is_male;
 293 }
 294
 295 /****************************************************************************
 296   Return translated version of nation legend.
 297 ****************************************************************************/
 298 const char *nation_legend_translation(const struct nation_type *pnation,
 299                                       const char *legend)
 300 {
 301   if (pnation->translation_domain == NULL) {
 302     return _(legend);
 303   }
 304
 305   return DG_(pnation->translation_domain, legend);
 306 }
 307
 308 /****************************************************************************
 309   Nation default cities. The nation_city structure holds information about
 310   a default choice for the city name. The 'name' field is, of course, just
 311   the name for the city. The 'river' and 'terrain' fields are entries
 312   recording whether the terrain is present near the city - we give higher
 313   priority to cities which have matching terrain. In the case of a river we
 314   only care if the city is _on_ the river, for other terrain features we
 315   give the bonus if the city is close to the terrain.
 316
 317   This is controlled through the nation's ruleset like this:
 318     cities = "Washington (ocean, river, swamp)", "New York (!mountains)"
 319 ****************************************************************************/
 320 struct nation_city {
 321   char *name;
 322   enum nation_city_preference river;
 323   enum nation_city_preference terrain[MAX_NUM_TERRAINS];
 324 };
 325
 326 /****************************************************************************
 327   Return the default cities of the nation (server only function).
 328 ****************************************************************************/
 329 const struct nation_city_list *
 330 nation_cities(const struct nation_type *pnation)
 331 {
 332   NATION_CHECK(pnation, return NULL);
 333   fc_assert_ret_val(is_server(), NULL);
 334
 335   return pnation->server.default_cities;
 336 }
 337
 338 /****************************************************************************
 339   Create a new default city for the nation (server only function).
 340 ****************************************************************************/
 341 struct nation_city *nation_city_new(struct nation_type *pnation,
 342                                     const char *name)
 343 {
 344   struct nation_city *pncity;
 345
 346   NATION_CHECK(pnation, return NULL);
 347   fc_assert_ret_val(is_server(), NULL);
 348
 349   fc_assert(0 == NCP_NONE);
 350   pncity = fc_calloc(1, sizeof(*pncity));       /* Set NCP_NONE. */
 351   pncity->name = fc_strdup(name);
 352
 353   nation_city_list_append(pnation->server.default_cities, pncity);
 354   return pncity;
 355 }
 356
 357 /****************************************************************************
 358   Destroy a default nation city created with nation_city_new().
 359 ****************************************************************************/
 360 static void nation_city_destroy(struct nation_city *pncity)
 361 {
 362   free(pncity->name);
 363   free(pncity);
 364 }
 365
 366 /****************************************************************************
 367   Reverts the nation city preference.
 368 ****************************************************************************/
 369 enum nation_city_preference
 370 nation_city_preference_revert(enum nation_city_preference prefer)
 371 {
 372   switch (prefer) {
 373   case NCP_DISLIKE:
 374     return NCP_LIKE;
 375   case NCP_NONE:
 376     return NCP_NONE;
 377   case NCP_LIKE:
 378     return NCP_DISLIKE;
 379   }
 380
 381   log_error("%s(): Wrong nation_city_preference variant (%d).",
 382             __FUNCTION__, prefer);
 383   return NCP_NONE;
 384 }
 385
 386 /****************************************************************************
 387   Set the default nation city preference for the terrain.
 388 ****************************************************************************/
 389 void nation_city_set_terrain_preference(struct nation_city *pncity,
 390                                         const struct terrain *pterrain,
 391                                         enum nation_city_preference prefer)
 392 {
 393   fc_assert_ret(NULL != pncity);
 394   fc_assert_ret(NULL != pterrain);
 395   pncity->terrain[terrain_index(pterrain)] = prefer;
 396 }
 397
 398 /****************************************************************************
 399   Set the default nation city preference about rivers.
 400 ****************************************************************************/
 401 void nation_city_set_river_preference(struct nation_city *pncity,
 402                                       enum nation_city_preference prefer)
 403 {
 404   fc_assert_ret(NULL != pncity);
 405   pncity->river = prefer;
 406 }
 407
 408 /****************************************************************************
 409   Return the name of the default nation city.
 410 ****************************************************************************/
 411 const char *nation_city_name(const struct nation_city *pncity)
 412 {
 413   fc_assert_ret_val(NULL != pncity, NULL);
 414   return pncity->name;
 415 }
 416
 417 /****************************************************************************
 418   Return the default nation city preference for the terrain.
 419 ****************************************************************************/
 420 enum nation_city_preference
 421 nation_city_terrain_preference(const struct nation_city *pncity,
 422                                const struct terrain *pterrain)
 423 {
 424   fc_assert_ret_val(NULL != pncity, NCP_DISLIKE);
 425   fc_assert_ret_val(NULL != pterrain, NCP_DISLIKE);
 426   return pncity->terrain[terrain_index(pterrain)];
 427 }
 428
 429 /****************************************************************************
 430   Return the default nation city preference for rivers.
 431 ****************************************************************************/
 432 enum nation_city_preference
 433 nation_city_river_preference(const struct nation_city *pncity)
 434 {
 435   fc_assert_ret_val(NULL != pncity, NCP_DISLIKE);
 436   return pncity->river;
 437 }
 438
 439
 440 /****************************************************************************
 441   Return the nation of a player.
 442 ****************************************************************************/
 443 struct nation_type *nation_of_player(const struct player *pplayer)
 444 {
 445   fc_assert_ret_val(NULL != pplayer, NULL);
 446   NATION_CHECK(pplayer->nation, return NULL);
 447   return pplayer->nation;
 448 }
 449
 450 /****************************************************************************
 451   Return the nation of the player who owns the city.
 452 ****************************************************************************/
 453 struct nation_type *nation_of_city(const struct city *pcity)
 454 {
 455   fc_assert_ret_val(pcity != NULL, NULL);
 456   return nation_of_player(city_owner(pcity));
 457 }
 458
 459 /****************************************************************************
 460   Return the nation of the player who owns the unit.
 461 ****************************************************************************/
 462 struct nation_type *nation_of_unit(const struct unit *punit)
 463 {
 464   fc_assert_ret_val(punit != NULL, NULL);
 465   return nation_of_player(unit_owner(punit));
 466 }
 467
 468 /****************************************************************************
 469   Return the nation with the given index.
 470
 471   This function returns NULL for an out-of-range index (some callers
 472   rely on this).
 473 ****************************************************************************/
 474 struct nation_type *nation_by_number(const Nation_type_id nation)
 475 {
 476   if (nation < 0 || nation >= game.control.nation_count) {
 477     return NULL;
 478   }
 479   return nations + nation;
 480 }
 481
 482 /**************************************************************************
 483   Return the nation index.
 484 **************************************************************************/
 485 Nation_type_id nation_number(const struct nation_type *pnation)
 486 {
 487   fc_assert_ret_val(NULL != pnation, -1);
 488   return pnation->item_number;
 489 }
 490
 491 /**************************************************************************
 492   Return the nation index.
 493
 494   Currently same as nation_number(), paired with nation_count()
 495   indicates use as an array index.
 496 **************************************************************************/
 497 Nation_type_id nation_index(const struct nation_type *pnation)
 498 {
 499   fc_assert_ret_val(NULL != pnation, -1);
 500   return pnation - nations;
 501 }
 502
 503 /****************************************************************************
 504   Return the number of nations.
 505 ****************************************************************************/
 506 Nation_type_id nation_count(void)
 507 {
 508   return game.control.nation_count;
 509 }
 510
 511
 512 /****************************************************************************
 513   Nation iterator.
 514 ****************************************************************************/
 515 struct nation_iter {
 516   struct iterator vtable;
 517   struct nation_type *p, *end;
 518 };
 519 #define NATION_ITER(p) ((struct nation_iter *)(p))
 520
 521 /****************************************************************************
 522   Implementation of iterator 'sizeof' function.
 523 ****************************************************************************/
 524 size_t nation_iter_sizeof(void)
 525 {
 526   return sizeof(struct nation_iter);
 527 }
 528
 529 /****************************************************************************
 530   Implementation of iterator 'next' function.
 531 ****************************************************************************/
 532 static void nation_iter_next(struct iterator *iter)
 533 {
 534   NATION_ITER(iter)->p++;
 535 }
 536
 537 /****************************************************************************
 538   Implementation of iterator 'get' function.
 539 ****************************************************************************/
 540 static void *nation_iter_get(const struct iterator *iter)
 541 {
 542   return NATION_ITER(iter)->p;
 543 }
 544
 545 /****************************************************************************
 546   Implementation of iterator 'valid' function.
 547 ****************************************************************************/
 548 static bool nation_iter_valid(const struct iterator *iter)
 549 {
 550   struct nation_iter *it = NATION_ITER(iter);
 551   return it->p < it->end;
 552 }
 553
 554 /****************************************************************************
 555   Implementation of iterator 'init' function.
 556 ****************************************************************************/
 557 struct iterator *nation_iter_init(struct nation_iter *it)
 558 {
 559   it->vtable.next = nation_iter_next;
 560   it->vtable.get = nation_iter_get;
 561   it->vtable.valid = nation_iter_valid;
 562   it->p = nations;
 563   it->end = nations + nation_count();
 564   return ITERATOR(it);
 565 }
 566
 567 /****************************************************************************
 568   Allocate resources associated with the given nation.
 569 ****************************************************************************/
 570 static void nation_init(struct nation_type *pnation)
 571 {
 572   memset(pnation, 0, sizeof(*pnation));
 573
 574   pnation->item_number = pnation - nations;
 575   pnation->translation_domain = NULL;
 576   pnation->leaders = nation_leader_list_new_full(nation_leader_destroy);
 577   pnation->sets = nation_set_list_new();
 578   pnation->groups = nation_group_list_new();
 579
 580   if (is_server()) {
 581     pnation->server.default_cities =
 582         nation_city_list_new_full(nation_city_destroy);
 583     pnation->server.civilwar_nations = nation_list_new();
 584     pnation->server.parent_nations = nation_list_new();
 585     pnation->server.conflicts_with = nation_list_new();
 586     /* server.rgb starts out NULL */
 587     pnation->server.traits = fc_calloc(TRAIT_COUNT,
 588                                        sizeof(*pnation->server.traits));
 589   }
 590 }
 591
 592 /****************************************************************************
 593   De-allocate resources associated with the given nation.
 594 ****************************************************************************/
 595 static void nation_free(struct nation_type *pnation)
 596 {
 597   free(pnation->legend);
 598   FC_FREE(pnation->translation_domain);
 599   nation_leader_list_destroy(pnation->leaders);
 600   nation_set_list_destroy(pnation->sets);
 601   nation_group_list_destroy(pnation->groups);
 602
 603   if (is_server()) {
 604     nation_city_list_destroy(pnation->server.default_cities);
 605     nation_list_destroy(pnation->server.civilwar_nations);
 606     nation_list_destroy(pnation->server.parent_nations);
 607     nation_list_destroy(pnation->server.conflicts_with);
 608     rgbcolor_destroy(pnation->server.rgb);
 609     FC_FREE(pnation->server.traits);
 610   }
 611
 612   memset(pnation, 0, sizeof(*pnation));
 613 }
 614
 615 /****************************************************************************
 616   Allocate space for the given number of nations.
 617 ****************************************************************************/
 618 void nations_alloc(int num)
 619 {
 620   int i;
 621
 622   nations = fc_malloc(sizeof(*nations) * num);
 623   game.control.nation_count = num;
 624
 625   for (i = 0; i < num; i++) {
 626     nation_init(nations + i);
 627   }
 628 }
 629
 630 /****************************************************************************
 631   De-allocate the currently allocated nations.
 632 ****************************************************************************/
 633 void nations_free(void)
 634 {
 635   int i;
 636
 637   if (NULL == nations) {
 638     return;
 639   }
 640
 641   for (i = 0; i < game.control.nation_count; i++) {
 642     nation_free(nations + i);
 643   }
 644
 645   free(nations);
 646   nations = NULL;
 647   game.control.nation_count = 0;
 648 }
 649
 650 /****************************************************************************
 651   Returns initial government type for this nation.
 652   Always returns non-NULL -- nation-specific government or failing that
 653   ruleset default government.
 654 ****************************************************************************/
 655 struct government *init_government_of_nation(const struct nation_type *pnation)
 656 {
 657   NATION_CHECK(pnation, return game.default_government);
 658   if (pnation->init_government) {
 659     return pnation->init_government;
 660   } else {
 661     return game.default_government;
 662   }
 663 }
 664
 665 /****************************************************************************
 666   Returns nation's style.
 667 ****************************************************************************/
 668 struct nation_style *style_of_nation(const struct nation_type *pnation)
 669 {
 670   NATION_CHECK(pnation, return 0);
 671   return pnation->style;
 672 }
 673
 674 /****************************************************************************
 675   Returns nation's player color preference, or NULL if none.
 676   Server only function.
 677 ****************************************************************************/
 678 const struct rgbcolor *nation_color(const struct nation_type *pnation)
 679 {
 680   NATION_CHECK(pnation, return NULL);
 681   return pnation->server.rgb;
 682 }
 683
 684 /****************************************************************************
 685   Return the number of nation sets.
 686 ****************************************************************************/
 687 int nation_set_count(void)
 688 {
 689   return num_nation_sets;
 690 }
 691
 692 /****************************************************************************
 693   Return the nation set index.
 694 ****************************************************************************/
 695 int nation_set_index(const struct nation_set *pset)
 696 {
 697   fc_assert_ret_val(NULL != pset, -1);
 698   return pset - nation_sets;
 699 }
 700
 701 /****************************************************************************
 702   Return the nation set index.
 703 ****************************************************************************/
 704 int nation_set_number(const struct nation_set *pset)
 705 {
 706   return nation_set_index(pset);
 707 }
 708
 709 /****************************************************************************
 710   Add new set into the array of nation sets.
 711 ****************************************************************************/
 712 struct nation_set *nation_set_new(const char *set_name,
 713                                   const char *set_rule_name,
 714                                   const char *set_description)
 715 {
 716   struct nation_set *pset;
 717
 718   if (MAX_NUM_NATION_SETS <= num_nation_sets) {
 719     log_error("Too many nation sets (%d is the maximum).",
 720               MAX_NUM_NATION_SETS);
 721     return NULL;
 722   }
 723
 724   /* Print the name and truncate if needed. */
 725   pset = nation_sets + num_nation_sets;
 726   names_set(&pset->name, NULL, set_name, set_rule_name);
 727   (void) sz_loud_strlcpy(pset->description, set_description,
 728                          "Nation set description \"%s\" too long; truncating.");
 729
 730   if (NULL != nation_set_by_rule_name(rule_name_get(&pset->name))) {
 731     log_error("Duplicate nation set name %s.", rule_name_get(&pset->name));
 732     return NULL;
 733   }
 734
 735   if (NULL != nation_group_by_rule_name(rule_name_get(&pset->name))) {
 736     log_error("Nation set name %s is already used for a group.",
 737               rule_name_get(&pset->name));
 738     return NULL;
 739   }
 740
 741   num_nation_sets++;
 742
 743   return pset;
 744 }
 745
 746 /****************************************************************************
 747   Return the nation set with the given index.
 748
 749   This function returns NULL for an out-of-range index (some callers
 750   rely on this).
 751 ****************************************************************************/
 752 struct nation_set *nation_set_by_number(int id)
 753 {
 754   if (id < 0 || id >= num_nation_sets) {
 755     return NULL;
 756   }
 757   return nation_sets + id;
 758 }
 759
 760 /****************************************************************************
 761   Return the nation set that has the given (untranslated) rule name.
 762   Returns NULL if no set is found.
 763 ****************************************************************************/
 764 struct nation_set *nation_set_by_rule_name(const char *name)
 765 {
 766   const char *qname = Qn_(name);
 767
 768   nation_sets_iterate(pset) {
 769     if (0 == fc_strcasecmp(rule_name_get(&pset->name), qname)) {
 770       return pset;
 771     }
 772   } nation_sets_iterate_end;
 773
 774   return NULL;
 775 }
 776
 777 /****************************************************************************
 778   Return the untranslated name of a nation set (including qualifier, if any).
 779   You usually want nation_set_rule_name() instead.
 780   You don't have to free the return pointer.
 781 ****************************************************************************/
 782 const char *nation_set_untranslated_name(const struct nation_set *pset)
 783 {
 784   fc_assert_ret_val(NULL != pset, NULL);
 785   return untranslated_name(&pset->name);
 786 }
 787
 788 /****************************************************************************
 789   Return the (untranslated) rule name of a nation set.
 790   You don't have to free the return pointer.
 791 ****************************************************************************/
 792 const char *nation_set_rule_name(const struct nation_set *pset)
 793 {
 794   fc_assert_ret_val(NULL != pset, NULL);
 795
 796   return rule_name_get(&pset->name);
 797 }
 798
 799 /****************************************************************************
 800   Return the translated name of a nation set.
 801   You don't have to free the return pointer.
 802 ****************************************************************************/
 803 const char *nation_set_name_translation(const struct nation_set *pset)
 804 {
 805   fc_assert_ret_val(NULL != pset, NULL);
 806   return name_translation_get(&pset->name);
 807 }
 808
 809 /****************************************************************************
 810   Return the (untranslated) user description of a nation set.
 811   You don't have to free the return pointer.
 812 ****************************************************************************/
 813 const char *nation_set_description(const struct nation_set *pset)
 814 {
 815   fc_assert_ret_val(NULL != pset, NULL);
 816   return pset->description;
 817 }
 818
 819 /****************************************************************************
 820   Check if the given nation is in a given set
 821 ****************************************************************************/
 822 bool nation_is_in_set(const struct nation_type *pnation,
 823                       const struct nation_set *pset)
 824 {
 825   fc_assert_ret_val(NULL != pnation, FALSE);
 826
 827   nation_set_list_iterate(pnation->sets, aset) {
 828     if (aset == pset) {
 829       return TRUE;
 830     }
 831   } nation_set_list_iterate_end;
 832   return FALSE;
 833 }
 834
 835 /****************************************************************************
 836   Returns the nation set that would be selected by the given value of the
 837   'nationset' server setting.
 838   This differs from nation_set_by_rule_name() for the empty string, where
 839   the first (ruleset default) nationset will be used; and similarly for
 840   a nationset not matched in the ruleset.
 841   The knowledge of the interpretation of this setting encapsulated here is
 842   required on both server and client.
 843 ****************************************************************************/
 844 struct nation_set *nation_set_by_setting_value(const char *setting)
 845 {
 846   struct nation_set *pset = NULL;
 847
 848   if (strlen(setting) > 0) {
 849     pset = nation_set_by_rule_name(setting);
 850   }
 851   if (pset == NULL) {
 852     /* Either no nation set specified, or the specified one isn't in the
 853      * current ruleset. Default to the first nation set specified by
 854      * the ruleset. */
 855     pset = nation_set_by_number(0);
 856   }
 857   fc_assert(pset != NULL);
 858
 859   return pset;
 860 }
 861
 862 /****************************************************************************
 863   Nation set iterator.
 864 ****************************************************************************/
 865 struct nation_set_iter {
 866   struct iterator vtable;
 867   struct nation_set *p, *end;
 868 };
 869 #define NATION_SET_ITER(p) ((struct nation_set_iter *)(p))
 870
 871 /****************************************************************************
 872   Implementation of iterator 'sizeof' function.
 873 ****************************************************************************/
 874 size_t nation_set_iter_sizeof(void)
 875 {
 876   return sizeof(struct nation_set_iter);
 877 }
 878
 879 /****************************************************************************
 880   Implementation of iterator 'next' function.
 881 ****************************************************************************/
 882 static void nation_set_iter_next(struct iterator *iter)
 883 {
 884   NATION_SET_ITER(iter)->p++;
 885 }
 886
 887 /****************************************************************************
 888   Implementation of iterator 'get' function.
 889 ****************************************************************************/
 890 static void *nation_set_iter_get(const struct iterator *iter)
 891 {
 892   return NATION_SET_ITER(iter)->p;
 893 }
 894
 895 /****************************************************************************
 896   Implementation of iterator 'valid' function.
 897 ****************************************************************************/
 898 static bool nation_set_iter_valid(const struct iterator *iter)
 899 {
 900   struct nation_set_iter *it = NATION_SET_ITER(iter);
 901   return it->p < it->end;
 902 }
 903
 904 /****************************************************************************
 905   Implementation of iterator 'init' function.
 906 ****************************************************************************/
 907 struct iterator *nation_set_iter_init(struct nation_set_iter *it)
 908 {
 909   it->vtable.next = nation_set_iter_next;
 910   it->vtable.get = nation_set_iter_get;
 911   it->vtable.valid = nation_set_iter_valid;
 912   it->p = nation_sets;
 913   it->end = nation_sets + nation_set_count();
 914   return ITERATOR(it);
 915 }
 916
 917 /****************************************************************************
 918   Return the number of nation groups.
 919 ****************************************************************************/
 920 int nation_group_count(void)
 921 {
 922   return num_nation_groups;
 923 }
 924
 925 /****************************************************************************
 926   Return the nation group index.
 927 ****************************************************************************/
 928 int nation_group_index(const struct nation_group *pgroup)
 929 {
 930   fc_assert_ret_val(NULL != pgroup, -1);
 931   return pgroup - nation_groups;
 932 }
 933
 934 /****************************************************************************
 935   Return the nation group index.
 936 ****************************************************************************/
 937 int nation_group_number(const struct nation_group *pgroup)
 938 {
 939   return nation_group_index(pgroup);
 940 }
 941
 942 /****************************************************************************
 943   Add new group into the array of groups.
 944 ****************************************************************************/
 945 struct nation_group *nation_group_new(const char *name)
 946 {
 947   struct nation_group *pgroup;
 948
 949   if (MAX_NUM_NATION_GROUPS <= num_nation_groups) {
 950     log_error("Too many nation groups (%d is the maximum).",
 951               MAX_NUM_NATION_GROUPS);
 952     return NULL;
 953   }
 954
 955   /* Print the name and truncate if needed. */
 956   pgroup = nation_groups + num_nation_groups;
 957   name_set(&pgroup->name, NULL, name);
 958   if (NULL != nation_group_by_rule_name(rule_name_get(&pgroup->name))) {
 959     log_error("Duplicate nation group name %s.", rule_name_get(&pgroup->name));
 960     return NULL;
 961   }
 962
 963   if (NULL != nation_set_by_rule_name(rule_name_get(&pgroup->name))) {
 964     log_error("Nation group name %s is already used for a set.",
 965               rule_name_get(&pgroup->name));
 966     return NULL;
 967   }
 968
 969   if (is_server()) {
 970     pgroup->server.match = 0;
 971   }
 972   num_nation_groups++;
 973
 974   return pgroup;
 975 }
 976
 977 /****************************************************************************
 978   Return the nation group with the given index.
 979
 980   This function returns NULL for an out-of-range index (some callers
 981   rely on this).
 982 ****************************************************************************/
 983 struct nation_group *nation_group_by_number(int id)
 984 {
 985   if (id < 0 || id >= num_nation_groups) {
 986     return NULL;
 987   }
 988   return nation_groups + id;
 989 }
 990
 991 /****************************************************************************
 992   Return the nation group that has the given (untranslated) rule name.
 993   Returns NULL if no group is found.
 994 ****************************************************************************/
 995 struct nation_group *nation_group_by_rule_name(const char *name)
 996 {
 997   const char *qname = Qn_(name);
 998
 999   nation_groups_iterate(pgroup) {
1000     if (0 == fc_strcasecmp(rule_name_get(&pgroup->name), qname)) {
1001       return pgroup;
1002     }
1003   } nation_groups_iterate_end;
1004
1005   return NULL;
1006 }
1007
1008 /****************************************************************************
1009   Set whether this group should appear in the nation selection UI.
1010 ****************************************************************************/
1011 void nation_group_set_hidden(struct nation_group *pgroup, bool hidden)
1012 {
1013   fc_assert_ret(NULL != pgroup);
1014   pgroup->hidden = hidden;
1015 }
1016
1017 /****************************************************************************
1018   Set how much the AI will try to select a nation in the same group.
1019   Server only function.
1020 ****************************************************************************/
1021 void nation_group_set_match(struct nation_group *pgroup, int match)
1022 {
1023   fc_assert_ret(is_server());
1024   fc_assert_ret(NULL != pgroup);
1025   pgroup->server.match = match;
1026 }
1027
1028 /****************************************************************************
1029   Return whether this group should appear in the nation selection UI.
1030 ****************************************************************************/
1031 bool is_nation_group_hidden(struct nation_group *pgroup)
1032 {
1033   fc_assert_ret_val(NULL != pgroup, TRUE);
1034   return pgroup->hidden;
1035 }
1036
1037 /****************************************************************************
1038   Return the untranslated name of a nation group (including qualifier,
1039   if any).
1040   You usually want nation_group_rule_name() instead.
1041   You don't have to free the return pointer.
1042 ****************************************************************************/
1043 const char *nation_group_untranslated_name(const struct nation_group *pgroup)
1044 {
1045   fc_assert_ret_val(NULL != pgroup, NULL);
1046   return untranslated_name(&pgroup->name);
1047 }
1048
1049 /****************************************************************************
1050   Return the (untranslated) rule name of a nation group.
1051   You don't have to free the return pointer.
1052 ****************************************************************************/
1053 const char *nation_group_rule_name(const struct nation_group *pgroup)
1054 {
1055   fc_assert_ret_val(NULL != pgroup, NULL);
1056
1057   return rule_name_get(&pgroup->name);
1058 }
1059
1060 /****************************************************************************
1061   Return the translated name of a nation group.
1062   You don't have to free the return pointer.
1063 ****************************************************************************/
1064 const char *nation_group_name_translation(const struct nation_group *pgroup)
1065 {
1066   fc_assert_ret_val(NULL != pgroup, NULL);
1067   return name_translation_get(&pgroup->name);
1068 }
1069
1070 /****************************************************************************
1071   Check if the given nation is in a given group
1072 ****************************************************************************/
1073 bool nation_is_in_group(const struct nation_type *pnation,
1074                         const struct nation_group *pgroup)
1075 {
1076   fc_assert_ret_val(NULL != pnation, FALSE);
1077
1078   nation_group_list_iterate(pnation->groups, agroup) {
1079     if (agroup == pgroup) {
1080       return TRUE;
1081     }
1082   } nation_group_list_iterate_end;
1083   return FALSE;
1084 }
1085
1086 /****************************************************************************
1087   Nation group iterator.
1088 ****************************************************************************/
1089 struct nation_group_iter {
1090   struct iterator vtable;
1091   struct nation_group *p, *end;
1092 };
1093 #define NATION_GROUP_ITER(p) ((struct nation_group_iter *)(p))
1094
1095 /****************************************************************************
1096   Implementation of iterator 'sizeof' function.
1097 ****************************************************************************/
1098 size_t nation_group_iter_sizeof(void)
1099 {
1100   return sizeof(struct nation_group_iter);
1101 }
1102
1103 /****************************************************************************
1104   Implementation of iterator 'next' function.
1105 ****************************************************************************/
1106 static void nation_group_iter_next(struct iterator *iter)
1107 {
1108   NATION_GROUP_ITER(iter)->p++;
1109 }
1110
1111 /****************************************************************************
1112   Implementation of iterator 'get' function.
1113 ****************************************************************************/
1114 static void *nation_group_iter_get(const struct iterator *iter)
1115 {
1116   return NATION_GROUP_ITER(iter)->p;
1117 }
1118
1119 /****************************************************************************
1120   Implementation of iterator 'valid' function.
1121 ****************************************************************************/
1122 static bool nation_group_iter_valid(const struct iterator *iter)
1123 {
1124   struct nation_group_iter *it = NATION_GROUP_ITER(iter);
1125   return it->p < it->end;
1126 }
1127
1128 /****************************************************************************
1129   Implementation of iterator 'init' function.
1130 ****************************************************************************/
1131 struct iterator *nation_group_iter_init(struct nation_group_iter *it)
1132 {
1133   it->vtable.next = nation_group_iter_next;
1134   it->vtable.get = nation_group_iter_get;
1135   it->vtable.valid = nation_group_iter_valid;
1136   it->p = nation_groups;
1137   it->end = nation_groups + nation_group_count();
1138   return ITERATOR(it);
1139 }
1140
1141 /****************************************************************************
1142   Initializes all nation set/group data.
1143 ****************************************************************************/
1144 void nation_sets_groups_init(void)
1145 {
1146   num_nation_sets = num_nation_groups = 0;
1147 }
1148
1149 /****************************************************************************
1150   Frees and resets all nation set/group data.
1151 ****************************************************************************/
1152 void nation_sets_groups_free(void)
1153 {
1154   num_nation_sets = num_nation_groups = 0;
1155 }
1156
1157 /****************************************************************************
1158   Return TRUE iff the editor is allowed to edit the player's nation in
1159   pregame.
1160 ****************************************************************************/
1161 bool can_conn_edit_players_nation(const struct connection *pconn,
1162                                   const struct player *pplayer)
1163 {
1164   return (can_conn_edit(pconn)
1165           || (game.info.is_new_game
1166               && ((!pconn->observer && pconn->playing == pplayer)
1167                    || pconn->access_level >= ALLOW_CTRL)));
1168 }
1169
1170 /****************************************************************************
1171   Returns how much two nations look good in the same game.
1172   Nations in the same group are considered to match, if that nation group
1173   has a 'match' greater than zero.
1174   Negative return value means that we really really don't want these
1175   nations together. This is dictated by "conflicts_with" in individual
1176   nation definitions. (If 'ignore_conflicts' is set, conflicts are not
1177   taken into account at all.)
1178   Server side function.
1179 ****************************************************************************/
1180 int nations_match(const struct nation_type *pnation1,
1181                   const struct nation_type *pnation2,
1182                   bool ignore_conflicts)
1183 {
1184   bool in_conflict = FALSE;
1185   int sum = 0;
1186
1187   fc_assert_ret_val(is_server(), -1);
1188   NATION_CHECK(pnation1, return -1);
1189   NATION_CHECK(pnation2, return -1);
1190
1191   if (!ignore_conflicts) {
1192     nation_list_iterate(pnation1->server.conflicts_with, pnation0) {
1193       if (pnation0 == pnation2) {
1194         in_conflict = TRUE;
1195         sum = 1; /* Be sure to returns something negative. */
1196         break;
1197       }
1198     } nation_list_iterate_end;
1199
1200     if (!in_conflict) {
1201       nation_list_iterate(pnation2->server.conflicts_with, pnation0) {
1202         if (pnation0 == pnation1) {
1203           in_conflict = TRUE;
1204           sum = 1; /* Be sure to returns something negative. */
1205           break;
1206         }
1207       } nation_list_iterate_end;
1208     }
1209   }
1210
1211   nation_group_list_iterate(pnation1->groups, pgroup) {
1212     if (nation_is_in_group(pnation2, pgroup)) {
1213       sum += pgroup->server.match;
1214     }
1215   } nation_group_list_iterate_end;
1216
1217   return (in_conflict ? -sum : sum);
1218 }