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