common/nation.h

   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 #ifndef FC__NATION_H
  14 #define FC__NATION_H
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif /* __cplusplus */
  19
  20 /* utility */
  21 #include "iterator.h"
  22
  23 /* common */
  24 #include "fc_types.h"
  25 #include "name_translation.h"
  26 #include "rgbcolor.h"
  27 #include "terrain.h"            /* MAX_NUM_TERRAINS */
  28
  29 #define NO_NATION_SELECTED (NULL)
  30
  31 /* Changing this value will break network compatibility. */
  32 #define NATION_NONE -1
  33 #define NATION_ANY  -2
  34
  35 /* Nation city (server only). */
  36 struct nation_city;
  37
  38 enum nation_city_preference {
  39   NCP_DISLIKE = -1,
  40   NCP_NONE = 0,
  41   NCP_LIKE = 1
  42 };
  43
  44 #define SPECLIST_TAG nation_city
  45 #define SPECLIST_TYPE struct nation_city
  46 #include "speclist.h"
  47 #define nation_city_list_iterate(citylist, pncity)                          \
  48   TYPED_LIST_ITERATE(struct nation_city, citylist, pncity)
  49 #define nation_city_list_iterate_end LIST_ITERATE_END
  50
  51 /* Nation leader. */
  52 struct nation_leader;
  53 #define SPECLIST_TAG nation_leader
  54 #define SPECLIST_TYPE struct nation_leader
  55 #include "speclist.h"
  56 #define nation_leader_list_iterate(leaderlist, pleader)                     \
  57   TYPED_LIST_ITERATE(struct nation_leader, leaderlist, pleader)
  58 #define nation_leader_list_iterate_end LIST_ITERATE_END
  59
  60 /* Nation set. */
  61 struct nation_set;
  62 #define SPECLIST_TAG nation_set
  63 #define SPECLIST_TYPE struct nation_set
  64 #include "speclist.h"
  65 #define nation_set_list_iterate(setlist, pset)                        \
  66   TYPED_LIST_ITERATE(struct nation_set, setlist, pset)
  67 #define nation_set_list_iterate_end LIST_ITERATE_END
  68
  69 /* Nation group. */
  70 struct nation_group;
  71 #define SPECLIST_TAG nation_group
  72 #define SPECLIST_TYPE struct nation_group
  73 #include "speclist.h"
  74 #define nation_group_list_iterate(grouplist, pgroup)                        \
  75   TYPED_LIST_ITERATE(struct nation_group, grouplist, pgroup)
  76 #define nation_group_list_iterate_end LIST_ITERATE_END
  77
  78 /* Nation list. */
  79 struct nation_type;
  80 #define SPECLIST_TAG nation
  81 #define SPECLIST_TYPE struct nation_type
  82 #include "speclist.h"
  83 #define nation_list_iterate(nationlist, pnation)                            \
  84   TYPED_LIST_ITERATE(struct nation_type, nationlist, pnation)
  85 #define nation_list_iterate_end LIST_ITERATE_END
  86
  87 /* Nation hash. */
  88 #define SPECHASH_TAG nation
  89 #define SPECHASH_IKEY_TYPE struct nation_type *
  90 #define SPECHASH_IDATA_TYPE void *
  91 #include "spechash.h"
  92 #define nation_hash_iterate(nationhash, pnation)                            \
  93   TYPED_HASH_KEYS_ITERATE(struct nation_type *, nationhash, pnation)
  94 #define nation_hash_iterate_end HASH_KEYS_ITERATE_END
  95
  96 /* Pointer values are allocated on load then freed in free_nations(). */
  97 struct nation_type {
  98   Nation_type_id item_number;
  99   char *translation_domain;
 100   struct name_translation adjective;
 101   struct name_translation noun_plural;
 102   char flag_graphic_str[MAX_LEN_NAME];
 103   char flag_graphic_alt[MAX_LEN_NAME];
 104   struct nation_leader_list *leaders;
 105   struct nation_style *style;
 106   char *legend;                         /* may be empty */
 107
 108   bool is_playable;
 109   enum barbarian_type barb_type;
 110
 111   /* Sets which this nation is assigned to */
 112   struct nation_set_list *sets;
 113
 114   /* Groups which this nation is assigned to */
 115   struct nation_group_list *groups;
 116
 117   struct player *player; /* Who's using the nation, or NULL. */
 118
 119   /* Items given to this nation at game start. */
 120   /* (Only used in the client for documentation purposes.) */
 121   int init_techs[MAX_NUM_TECH_LIST];
 122   int init_buildings[MAX_NUM_BUILDING_LIST];
 123   struct government *init_government; /* use game default_government if NULL */
 124   struct unit_type *init_units[MAX_NUM_UNIT_LIST];
 125
 126   union {
 127     struct {
 128       /* Only used in the server (./ai/ and ./server/). */
 129
 130       struct nation_city_list *default_cities;
 131
 132       /* 'civilwar_nations' is a list of the nations that can fork from
 133        * this one. 'parent_nations' is the inverse of this list. */
 134       struct nation_list *civilwar_nations;
 135       struct nation_list *parent_nations;
 136
 137       /* Nations which we don't want in the same game. For example,
 138        * British and English. */
 139       struct nation_list *conflicts_with;
 140
 141       /* Nation's associated player color (NULL if none). */
 142       struct rgbcolor *rgb;
 143
 144       struct trait_limits *traits;
 145
 146       /* This nation has no start position in the current scenario. */
 147       bool no_startpos;
 148     } server;
 149
 150     struct {
 151       /* Only used at the client. */
 152
 153       /* Whether the client is allowed to try to pick the nation at game
 154        * start. Reasons for restricting this include lack of start positions
 155        * in a scenario, or a nation outside the current nationset. However,
 156        * in some circumstances the server may decide to put a nation with this
 157        * flag in the game anyway, so the client can't rely on its absence.
 158        * (On the server this is calculated on the fly from other values.
 159        * Use is_nation_pickable() to get the answer on client or server.) */
 160       bool is_pickable;
 161     } client;
 162   };
 163 };
 164
 165 /* Nation group structure. */
 166 struct nation_group {
 167   struct name_translation name;
 168   bool hidden;
 169
 170   union {
 171     struct {
 172       /* Only used in the server (./server/). */
 173
 174       /* How much the AI will try to select a nation in the same group */
 175       int match;
 176     } server;
 177
 178     /* Add client side when needed */
 179   };
 180 };
 181
 182 /* General nation accessor functions. */
 183 Nation_type_id nation_count(void);
 184 Nation_type_id nation_index(const struct nation_type *pnation);
 185 Nation_type_id nation_number(const struct nation_type *pnation);
 186
 187 struct nation_type *nation_by_number(const Nation_type_id nation);
 188 struct nation_type *nation_of_player(const struct player *pplayer);
 189 struct nation_type *nation_of_city(const struct city *pcity);
 190 struct nation_type *nation_of_unit(const struct unit *punit);
 191
 192 struct nation_type *nation_by_rule_name(const char *name);
 193 struct nation_type *nation_by_translated_plural(const char *name);
 194
 195 const char *nation_rule_name(const struct nation_type *pnation);
 196
 197 const char *nation_adjective_translation(const struct nation_type *pnation);
 198 const char *nation_adjective_for_player(const struct player *pplayer);
 199 const char *nation_plural_translation(const struct nation_type *pnation);
 200 const char *nation_plural_for_player(const struct player *pplayer);
 201
 202 struct government *init_government_of_nation(const struct nation_type *pnation);
 203
 204 struct nation_style *style_of_nation(const struct nation_type *pnation);
 205
 206 const struct rgbcolor *nation_color(const struct nation_type *pnation);
 207
 208 /* Ancillary nation routines */
 209 bool is_nation_pickable(const struct nation_type *nation);
 210 bool is_nation_playable(const struct nation_type *nation);
 211 enum barbarian_type nation_barbarian_type(const struct nation_type *nation);
 212 bool can_conn_edit_players_nation(const struct connection *pconn,
 213                                   const struct player *pplayer);
 214
 215 /* General nation leader accessor functions. */
 216 const struct nation_leader_list *
 217 nation_leaders(const struct nation_type *pnation);
 218 struct nation_leader *nation_leader_new(struct nation_type *pnation,
 219                                         const char *name, bool is_male);
 220 struct nation_leader *
 221 nation_leader_by_name(const struct nation_type *pnation, const char *name);
 222 const char *nation_leader_name(const struct nation_leader *pleader);
 223 bool nation_leader_is_male(const struct nation_leader *pleader);
 224
 225 const char *nation_legend_translation(const struct nation_type *pnation,
 226                                       const char *legend);
 227
 228 /* General nation city accessor functions. */
 229 struct terrain;
 230
 231 const struct nation_city_list *
 232 nation_cities(const struct nation_type *pnation);
 233 struct nation_city *nation_city_new(struct nation_type *pnation,
 234                                     const char *name);
 235
 236 const char *nation_city_name(const struct nation_city *pncity);
 237
 238 enum nation_city_preference
 239 nation_city_preference_revert(enum nation_city_preference prefer);
 240 void nation_city_set_terrain_preference(struct nation_city *pncity,
 241                                         const struct terrain *pterrain,
 242                                         enum nation_city_preference prefer);
 243 void nation_city_set_river_preference(struct nation_city *pncity,
 244                                       enum nation_city_preference prefer);
 245 enum nation_city_preference
 246 nation_city_terrain_preference(const struct nation_city *pncity,
 247                                const struct terrain *pterrain);
 248 enum nation_city_preference
 249 nation_city_river_preference(const struct nation_city *pncity);
 250
 251 /* General nation set accessor routines */
 252 int nation_set_count(void);
 253 int nation_set_index(const struct nation_set *pset);
 254 int nation_set_number(const struct nation_set *pset);
 255
 256 struct nation_set *nation_set_new(const char *set_name,
 257                                   const char *set_rule_name,
 258                                   const char *set_description);
 259 struct nation_set *nation_set_by_number(int id);
 260 struct nation_set *nation_set_by_rule_name(const char *name);
 261
 262 const char *nation_set_untranslated_name(const struct nation_set *pset);
 263 const char *nation_set_rule_name(const struct nation_set *pset);
 264 const char *nation_set_name_translation(const struct nation_set *pset);
 265 const char *nation_set_description(const struct nation_set *pset);
 266
 267 bool nation_is_in_set(const struct nation_type *pnation,
 268                       const struct nation_set *pset);
 269
 270 struct nation_set *nation_set_by_setting_value(const char *setting);
 271
 272 /* General nation group accessor routines */
 273 int nation_group_count(void);
 274 int nation_group_index(const struct nation_group *pgroup);
 275 int nation_group_number(const struct nation_group *pgroup);
 276
 277 struct nation_group *nation_group_new(const char *name);
 278 struct nation_group *nation_group_by_number(int id);
 279 struct nation_group *nation_group_by_rule_name(const char *name);
 280
 281 void nation_group_set_hidden(struct nation_group *pgroup, bool hidden);
 282 void nation_group_set_match(struct nation_group *pgroup, int match);
 283 bool is_nation_group_hidden(struct nation_group *pgroup);
 284
 285 const char *nation_group_untranslated_name(const struct nation_group *pgroup);
 286 const char *nation_group_rule_name(const struct nation_group *pgroup);
 287 const char *nation_group_name_translation(const struct nation_group *pgroup);
 288
 289 bool nation_is_in_group(const struct nation_type *pnation,
 290                         const struct nation_group *pgroup);
 291
 292 /* Initialization and iteration */
 293 void nation_sets_groups_init(void);
 294 void nation_sets_groups_free(void);
 295
 296 struct nation_set_iter;
 297 size_t nation_set_iter_sizeof(void);
 298 struct iterator *nation_set_iter_init(struct nation_set_iter *it);
 299
 300 #define nation_sets_iterate(NAME_pset)                                      \
 301   generic_iterate(struct nation_set_iter, struct nation_set *,              \
 302                   NAME_pset, nation_set_iter_sizeof,                        \
 303                   nation_set_iter_init)
 304 #define nation_sets_iterate_end generic_iterate_end
 305
 306 struct nation_group_iter;
 307 size_t nation_group_iter_sizeof(void);
 308 struct iterator *nation_group_iter_init(struct nation_group_iter *it);
 309
 310 #define nation_groups_iterate(NAME_pgroup)                                  \
 311   generic_iterate(struct nation_group_iter, struct nation_group *,          \
 312                   NAME_pgroup, nation_group_iter_sizeof,                    \
 313                   nation_group_iter_init)
 314 #define nation_groups_iterate_end generic_iterate_end
 315
 316 /* Initialization and iteration */
 317 void nations_alloc(int num);
 318 void nations_free(void);
 319
 320 int nations_match(const struct nation_type *pnation1,
 321                   const struct nation_type *pnation2,
 322                   bool ignore_conflicts);
 323
 324 struct nation_iter;
 325 size_t nation_iter_sizeof(void);
 326 struct iterator *nation_iter_init(struct nation_iter *it);
 327
 328 /* Iterate over nations.  This iterates over _all_ nations, including
 329  * unplayable ones (use is_nation_playable to filter if necessary).
 330  * This does not take account of the current nationset! -- on the
 331  * server, use allowed_nations_iterate() for that. */
 332 #define nations_iterate(NAME_pnation)\
 333   generic_iterate(struct nation_iter, struct nation_type *,\
 334                   NAME_pnation, nation_iter_sizeof, nation_iter_init)
 335 #define nations_iterate_end generic_iterate_end
 336
 337 #ifdef __cplusplus
 338 }
 339 #endif /* __cplusplus */
 340
 341 #endif  /* FC__NATION_H */