Freeciv-3.4
Loading...
Searching...
No Matches
univ_value.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* common */
19#include "achievements.h"
20#include "counters.h"
21#include "game.h"
22#include "government.h"
23#include "nation.h"
24#include "requirements.h"
25#include "server_settings.h"
26#include "specialist.h"
27#include "tech.h"
28#include "tiledef.h"
29#include "traderoutes.h"
30
31/* server */
32#include "rssanity.h"
33#include "settings.h"
34
35#include "univ_value.h"
36
37/********************************************************************/
43bool universal_value_initial(struct universal *src)
44{
45 switch (src->kind) {
46 case VUT_NONE:
47 /* Value of None should never be used */
48 return TRUE;
49 case VUT_ADVANCE:
50 if (game.control.num_tech_types <= 0) {
51 return FALSE;
52 }
53 src->value.advance = advance_by_number(A_NONE);
54 return TRUE;
55 case VUT_COUNTER:
56 if (counters_get_city_counters_count() <= 0) {
57 return FALSE;
58 }
59 src->value.counter = counter_by_index(0, CTGT_CITY);
60 return TRUE;
61 case VUT_GOVERNMENT:
62 src->value.govern = game.government_during_revolution;
63 return TRUE;
64 case VUT_GOVFLAG:
65 src->value.govflag = 0;
66 return TRUE;
67 case VUT_IMPROVEMENT:
68 case VUT_SITE:
69 if (game.control.num_impr_types <= 0) {
70 return FALSE;
71 }
72 src->value.building = improvement_by_number(0);
73 return TRUE;
74 case VUT_TERRAIN:
75 src->value.terrain = terrain_by_number(0);
76 return TRUE;
77 case VUT_NATION:
78 if (game.control.nation_count <= 0) {
79 return FALSE;
80 }
81 src->value.nation = nation_by_number(0);
82 return TRUE;
83 case VUT_UTYPE:
84 if (game.control.num_unit_types <= 0) {
85 return FALSE;
86 }
87 src->value.utype = utype_by_number(0);
88 return TRUE;
89 case VUT_UTFLAG:
90 src->value.unitflag = (enum unit_type_flag_id)0;
91 return TRUE;
92 case VUT_UCLASS:
93 if (game.control.num_unit_classes <= 0) {
94 return FALSE;
95 }
96 src->value.uclass = uclass_by_number(0);
97 return TRUE;
98 case VUT_UCFLAG:
99 src->value.unitclassflag = (enum unit_class_flag_id)0;
100 return TRUE;
101 case VUT_OTYPE:
102 src->value.outputtype = (enum output_type_id)0;
103 return TRUE;
104 case VUT_SPECIALIST:
105 if (game.control.num_specialist_types <= 0) {
106 return FALSE;
107 }
108 src->value.specialist = specialist_by_number(0);
109 return TRUE;
110 case VUT_MINSIZE:
111 src->value.minsize = 0;
112 return TRUE;
113 case VUT_AI_LEVEL:
114 src->value.ai_level = AI_LEVEL_CHEATING;
115 return TRUE;
116 case VUT_TERRAINCLASS:
117 src->value.terrainclass = TC_LAND;
118 return TRUE;
119 case VUT_MINYEAR:
120 src->value.minyear = 0;
121 return TRUE;
122 case VUT_MINCALFRAG:
123 src->value.mincalfrag = 0;
124 return TRUE;
125 case VUT_TERRAINALTER:
126 src->value.terrainalter = TA_CAN_IRRIGATE;
127 return TRUE;
128 case VUT_CITYTILE:
129 src->value.citytile = CITYT_CENTER;
130 return TRUE;
131 case VUT_CITYSTATUS:
132 src->value.citystatus = CITYS_OWNED_BY_ORIGINAL;
133 return TRUE;
134 case VUT_GOOD:
135 if (game.control.num_goods_types <= 0) {
136 return FALSE;
137 }
138 src->value.good = goods_by_number(0);
139 return TRUE;
140 case VUT_TERRFLAG:
141 src->value.terrainflag = TER_NO_BARBS;
142 return TRUE;
143 case VUT_NATIONALITY:
144 if (game.control.nation_count <= 0) {
145 return FALSE;
146 }
147 src->value.nationality = nation_by_number(0);
148 return TRUE;
149 case VUT_ORIGINAL_OWNER:
150 if (game.control.nation_count <= 0) {
151 return FALSE;
152 }
153 src->value.origowner = nation_by_number(0);
154 return TRUE;
155 case VUT_ROADFLAG:
156 src->value.roadflag = RF_RIVER;
157 return TRUE;
158 case VUT_EXTRA:
159 if (game.control.num_extra_types <= 0) {
160 return FALSE;
161 }
162 src->value.extra = extra_by_number(0);
163 return TRUE;
164 case VUT_TILEDEF:
165 if (game.control.num_tiledef_types <= 0) {
166 return FALSE;
167 }
168 src->value.tiledef = tiledef_by_number(0);
169 return TRUE;
170 case VUT_TECHFLAG:
171 src->value.techflag = TF_BONUS_TECH;
172 return TRUE;
173 case VUT_ACHIEVEMENT:
174 if (game.control.num_achievement_types <= 0) {
175 return FALSE;
176 }
177 src->value.achievement = achievement_by_number(0);
178 return TRUE;
179 case VUT_DIPLREL:
180 case VUT_DIPLREL_TILE:
181 case VUT_DIPLREL_TILE_O:
182 case VUT_DIPLREL_UNITANY:
183 case VUT_DIPLREL_UNITANY_O:
184 src->value.diplrel = DS_WAR;
185 return TRUE;
186 case VUT_MAXTILETOTALUNITS:
187 src->value.max_tile_total_units = 0;
188 return TRUE;
189 case VUT_MAXTILETOPUNITS:
190 src->value.max_tile_top_units = 0;
191 return TRUE;
192 case VUT_STYLE:
193 if (game.control.num_styles <= 0) {
194 return FALSE;
195 }
196 src->value.style = style_by_number(0);
197 return TRUE;
198 case VUT_MINCULTURE:
199 src->value.minculture = 0;
200 return TRUE;
201 case VUT_MINFOREIGNPCT:
202 src->value.minforeignpct = 0;
203 return TRUE;
204 case VUT_UNITSTATE:
205 src->value.unit_state = USP_TRANSPORTED;
206 return TRUE;
207 case VUT_ACTIVITY:
208 src->value.activity = ACTIVITY_IDLE;
209 return TRUE;
210 case VUT_MINMOVES:
211 src->value.minmoves = 0;
212 return TRUE;
213 case VUT_MINVETERAN:
214 src->value.minveteran = 0;
215 return TRUE;
216 case VUT_MINHP:
217 src->value.min_hit_points = 0;
218 return TRUE;
219 case VUT_AGE:
220 src->value.age = 0;
221 return TRUE;
222 case VUT_FORM_AGE:
223 src->value.form_age = 0;
224 return TRUE;
225 case VUT_NATIONGROUP:
226 if (nation_group_count() <= 0) {
227 return FALSE;
228 }
229 src->value.nationgroup = nation_group_by_number(0);
230 return TRUE;
231 case VUT_TOPO:
232 src->value.topo_property = TF_ISO;
233 return TRUE;
234 case VUT_WRAP:
235 src->value.wrap_property = WRAP_X;
236 return TRUE;
237 case VUT_SERVERSETTING:
238 src->value.ssetval
239 = ssetv_from_values(server_setting_by_name("killstack"), TRUE);
240 return TRUE;
241 case VUT_IMPR_GENUS:
242 src->value.impr_genus = IG_IMPROVEMENT;
243 return TRUE;
244 case VUT_IMPR_FLAG:
245 src->value.impr_flag = IF_VISIBLE_BY_OTHERS;
246 return TRUE;
247 case VUT_PLAYER_FLAG:
248 src->value.plr_flag = PLRF_AI;
249 return TRUE;
250 case VUT_PLAYER_STATE:
251 src->value.plrstate = PLRS_BARBARIAN;
252 return TRUE;
253 case VUT_ACTION:
254 src->value.action = action_by_number(0);
255 return TRUE;
256 case VUT_MINTECHS:
257 src->value.min_techs = 0;
258 return TRUE;
259 case VUT_FUTURETECHS:
260 src->value.future_techs = 0;
261 return TRUE;
262 case VUT_MINCITIES:
263 src->value.min_cities = 0;
264 return TRUE;
265 case VUT_EXTRAFLAG:
266 src->value.extraflag = EF_NATIVE_TILE;
267 return TRUE;
268 case VUT_MINLATITUDE:
269 case VUT_MAXLATITUDE:
270 src->value.latitude = 0;
271 return TRUE;
272 case VUT_MAX_DISTANCE_SQ:
273 src->value.distance_sq = 0;
274 return TRUE;
275 case VUT_MAX_REGION_TILES:
276 src->value.region_tiles = 0;
277 return TRUE;
278 case VUT_TILE_REL:
279 src->value.tilerel = TREL_SAME_REGION;
280 return TRUE;
281 case VUT_COUNT:
282 fc_assert(src->kind != VUT_COUNT);
283 return FALSE;
284 }
285
286 return FALSE;
287}
288
289/********************************************************************/
292void universal_kind_values(struct universal *univ,
293 univ_kind_values_cb cb, void *data)
294{
295 int i;
296
297 switch (univ->kind) {
298 case VUT_NONE:
299 break;
300 case VUT_ADVANCE:
301 advance_re_active_iterate(padv) {
302 cb(advance_rule_name(padv), univ->value.advance == padv, data);
303 } advance_re_active_iterate_end;
304 break;
305 case VUT_COUNTER:
306 city_counters_iterate(pcount) {
307 cb(counter_rule_name(pcount), univ->value.counter == pcount, data);
308 } city_counters_iterate_end;
309 break;
310 case VUT_GOVERNMENT:
311 governments_re_active_iterate(pgov) {
312 cb(government_rule_name(pgov), univ->value.govern == pgov, data);
313 } governments_re_active_iterate_end;
314 break;
315 case VUT_GOVFLAG:
316 for (i = 0; i < GOVF_LAST_USER_FLAG; i++) {
317 cb(gov_flag_id_name(i), univ->value.govflag == i, data);
318 }
319 break;
320 case VUT_IMPROVEMENT:
321 case VUT_SITE:
322 improvement_re_active_iterate(pimpr) {
323 cb(improvement_rule_name(pimpr), univ->value.building == pimpr, data);
324 } improvement_re_active_iterate_end;
325 break;
326 case VUT_TERRAIN:
327 terrain_re_active_iterate(pterr) {
328 cb(terrain_rule_name(pterr), univ->value.terrain == pterr, data);
329 } terrain_re_active_iterate_end;
330 break;
331 case VUT_NATION:
332 nations_iterate(pnat) {
333 cb(nation_rule_name(pnat), univ->value.nation == pnat, data);
334 } nations_iterate_end;
335 break;
336 case VUT_UTYPE:
337 unit_type_re_active_iterate(putype) {
338 cb(utype_rule_name(putype), univ->value.utype == putype, data);
339 } unit_type_re_active_iterate_end;
340 break;
341 case VUT_UCLASS:
342 unit_class_re_active_iterate(pclass) {
343 cb(uclass_rule_name(pclass), univ->value.uclass == pclass, data);
344 } unit_class_re_active_iterate_end;
345 break;
346 case VUT_OTYPE:
347 output_type_iterate(otype) {
348 cb(get_output_name(otype), univ->value.outputtype == otype, data);
349 } output_type_iterate_end;
350 break;
351 case VUT_GOOD:
352 goods_type_re_active_iterate(pgood) {
353 cb(goods_rule_name(pgood), univ->value.good == pgood, data);
354 } goods_type_re_active_iterate_end;
355 break;
356 case VUT_NATIONALITY:
357 nations_iterate(pnat) {
358 cb(nation_rule_name(pnat), univ->value.nationality == pnat, data);
359 } nations_iterate_end;
360 break;
361 case VUT_ORIGINAL_OWNER:
362 nations_iterate(pnat) {
363 cb(nation_rule_name(pnat), univ->value.origowner == pnat, data);
364 } nations_iterate_end;
365 break;
366 case VUT_EXTRA:
367 extra_type_re_active_iterate(pextra) {
368 cb(extra_rule_name(pextra), univ->value.extra == pextra, data);
369 } extra_type_re_active_iterate_end;
370 break;
371 case VUT_TILEDEF:
372 tiledef_iterate(ptd) {
373 cb(tiledef_rule_name(ptd), univ->value.tiledef == ptd, data);
374 } tiledef_iterate_end;
375 break;
376 case VUT_STYLE:
377 styles_re_active_iterate(pstyle) {
378 cb(style_rule_name(pstyle), univ->value.style == pstyle, data);
379 } styles_re_active_iterate_end;
380 break;
381 case VUT_AI_LEVEL:
382 for (i = 0; i < AI_LEVEL_COUNT; i++) {
383 cb(ai_level_name(i), univ->value.ai_level == i, data);
384 }
385 break;
386 case VUT_SPECIALIST:
387 specialist_type_re_active_iterate(pspe) {
388 cb(specialist_rule_name(pspe), univ->value.specialist == pspe, data);
389 } specialist_type_re_active_iterate_end;
390 break;
391 case VUT_TERRAINCLASS:
392 for (i = 0; i < TC_COUNT; i++) {
393 cb(terrain_class_name(i), univ->value.terrainclass == i, data);
394 }
395 break;
396 case VUT_UTFLAG:
397 for (i = 0; i < UTYF_LAST_USER_FLAG; i++) {
398 cb(unit_type_flag_id_name(i), univ->value.unitflag == i, data);
399 }
400 break;
401 case VUT_UCFLAG:
402 for (i = 0; i < UCF_COUNT; i++) {
403 cb(unit_class_flag_id_name(i), univ->value.unitclassflag == i, data);
404 }
405 break;
406 case VUT_TERRFLAG:
407 for (i = 0; i < TER_USER_LAST; i++) {
408 cb(terrain_flag_id_name(i), univ->value.terrainflag == i, data);
409 }
410 break;
411 case VUT_ROADFLAG:
412 for (i = 0; i < RF_COUNT; i++) {
413 cb(road_flag_id_name(i), univ->value.roadflag == i, data);
414 }
415 break;
416 case VUT_TECHFLAG:
417 for (i = 0; i < TF_COUNT; i++) {
418 cb(tech_flag_id_name(i), univ->value.techflag == i, data);
419 }
420 break;
421 case VUT_EXTRAFLAG:
422 for (i = 0; i < EF_COUNT; i++) {
423 cb(extra_flag_id_name(i), univ->value.extraflag == i, data);
424 }
425 break;
426 case VUT_TERRAINALTER:
427 for (i = 0; i < TA_COUNT; i++) {
428 cb(terrain_alteration_name(i), univ->value.terrainalter == i, data);
429 }
430 break;
431 case VUT_CITYTILE:
432 for (i = 0; i < CITYT_LAST; i++) {
433 cb(citytile_type_name(i), univ->value.citytile == i, data);
434 }
435 break;
436 case VUT_CITYSTATUS:
437 for (i = 0; i < CITYS_LAST; i++) {
438 cb(citystatus_type_name(i), univ->value.citystatus == i, data);
439 }
440 break;
441 case VUT_TILE_REL:
442 for (i = 0; i < TREL_COUNT; i++) {
443 cb(tilerel_type_name(i), univ->value.tilerel == i, data);
444 }
445 break;
446 case VUT_ACHIEVEMENT:
447 achievements_re_active_iterate(pach) {
448 cb(achievement_rule_name(pach), univ->value.achievement == pach, data);
449 } achievements_re_active_iterate_end;
450 break;
451 case VUT_DIPLREL:
452 case VUT_DIPLREL_TILE:
453 case VUT_DIPLREL_TILE_O:
454 case VUT_DIPLREL_UNITANY:
455 case VUT_DIPLREL_UNITANY_O:
456 for (i = 0; i < DS_LAST; i++) {
457 cb(diplstate_type_name(i), univ->value.diplrel == i, data);
458 }
459 for (; i < DRO_LAST; i++) {
460 cb(diplrel_other_name(i), univ->value.diplrel == i, data);
461 }
462 break;
463 case VUT_UNITSTATE:
464 for (i = 0; i < USP_COUNT; i++) {
465 cb(ustate_prop_name(i), univ->value.unit_state == i, data);
466 }
467 break;
468 case VUT_ACTIVITY:
469 activity_type_iterate(act) {
470 if (!universal_is_legal_in_requirement(
471 &(struct universal){.kind = VUT_ACTIVITY,
472 .value = {.activity = act}})) {
473 /* This activity is excluded from appearing in requirement
474 * vectors. */
475 continue;
476 }
477 cb(unit_activity_name(act), univ->value.activity == act, data);
478 } activity_type_iterate_end;
479 break;
480 case VUT_NATIONGROUP:
481 nation_groups_iterate(pgroup) {
482 cb(nation_group_rule_name(pgroup), univ->value.nationgroup == pgroup, data);
483 } nation_groups_iterate_end;
484 break;
485 case VUT_TOPO:
486 for (i = 0; i < TOPO_FLAG_BITS; i++) {
487 cb(topo_flag_name(1 << i), univ->value.topo_property == 1 << i, data);
488 }
489 break;
490 case VUT_WRAP:
491 for (i = 0; i < WRAP_FLAG_BITS; i++) {
492 cb(wrap_flag_name(1 << i), univ->value.wrap_property == 1 << i, data);
493 }
494 break;
495 case VUT_SERVERSETTING:
496 for (i = 0;
497 /* Only binary settings with the value TRUE are currently
498 * supported. */
499 i < settings_number();
500 i++) {
501 if (sanity_check_server_setting_value_in_req(i)) {
502 cb(ssetv_rule_name(i),
503 univ->value.ssetval == ssetv_from_values(i, TRUE), data);
504 }
505 }
506 break;
507 case VUT_IMPR_GENUS:
508 genus_iterate(genus) {
509 cb(impr_genus_id_name(genus), univ->value.impr_genus == genus, data);
510 } genus_iterate_end;
511 break;
512 case VUT_IMPR_FLAG:
513 for (i = 0; i < IF_COUNT; i++) {
514 cb(impr_flag_id_name(i), univ->value.impr_flag == i, data);
515 }
516 break;
517 case VUT_PLAYER_FLAG:
518 for (i = 0; i < PLRF_COUNT; i++) {
519 cb(plr_flag_id_name(i), univ->value.plr_flag == i, data);
520 }
521 break;
522 case VUT_PLAYER_STATE:
523 for (i = 0; i < PLRS_LAST; i++) {
524 cb(plrstate_type_name(i), univ->value.plrstate == i, data);
525 }
526 break;
527 case VUT_ACTION:
528 action_iterate(act) {
529 struct action *pact = action_by_number(act);
530
531 cb(action_rule_name(pact), univ->value.action == pact, data);
532 } action_iterate_end;
533 break;
534 case VUT_MINSIZE:
535 case VUT_MINYEAR:
536 case VUT_MINCALFRAG:
537 case VUT_MAXTILETOTALUNITS:
538 case VUT_MAXTILETOPUNITS:
539 case VUT_MINCULTURE:
540 case VUT_MINFOREIGNPCT:
541 case VUT_MINMOVES:
542 case VUT_MINVETERAN:
543 case VUT_MINHP:
544 case VUT_AGE:
545 case VUT_FORM_AGE:
546 case VUT_MINTECHS:
547 case VUT_FUTURETECHS:
548 case VUT_MINCITIES:
549 case VUT_MINLATITUDE:
550 case VUT_MAXLATITUDE:
551 case VUT_MAX_DISTANCE_SQ:
552 case VUT_MAX_REGION_TILES:
553 /* Requirement types having numerical value */
554 cb(nullptr, FALSE, data);
555 break;
556 case VUT_COUNT:
557 fc_assert(univ->kind != VUT_COUNT);
558 break;
559 }
560}
achievement_by_number
struct achievement * achievement_by_number(int id)
Definition achievements.c:96
achievement_rule_name
const char * achievement_rule_name(struct achievement *pach)
Definition achievements.c:114
achievements_re_active_iterate
#define achievements_re_active_iterate(_p)
Definition achievements.h:74
achievements_re_active_iterate_end
#define achievements_re_active_iterate_end
Definition achievements.h:78
action_rule_name
const char * action_rule_name(const struct action *action)
Definition actions.c:1237
action_by_number
static struct action * action_by_number(action_id act_id)
Definition actions.h:400
action_iterate_end
#define action_iterate_end
Definition actions.h:218
action_iterate
#define action_iterate(_act_)
Definition actions.h:214
get_output_name
const char * get_output_name(Output_type_id output)
Definition city.c:629
output_type_iterate
#define output_type_iterate(output)
Definition city.h:846
output_type_iterate_end
#define output_type_iterate_end
Definition city.h:852
incite_cost
char * incite_cost
Definition comments.c:77
counter_by_index
struct counter * counter_by_index(int index, enum counter_target target)
Definition counters.c:183
counter_rule_name
const char * counter_rule_name(struct counter *pcount)
Definition counters.c:165
counters_get_city_counters_count
int counters_get_city_counters_count(void)
Definition counters.c:74
city_counters_iterate_end
#define city_counters_iterate_end
Definition counters.h:64
city_counters_iterate
#define city_counters_iterate(pcount)
Definition counters.h:57
extra_by_number
struct extra_type * extra_by_number(int id)
Definition extras.c:183
extra_rule_name
const char * extra_rule_name(const struct extra_type *pextra)
Definition extras.c:203
extra_type_re_active_iterate_end
#define extra_type_re_active_iterate_end
Definition extras.h:329
extra_type_re_active_iterate
#define extra_type_re_active_iterate(_p)
Definition extras.h:325
TOPO_FLAG_BITS
#define TOPO_FLAG_BITS
Definition fc_types.h:463
CTGT_CITY
@ CTGT_CITY
Definition fc_types.h:128
WRAP_FLAG_BITS
#define WRAP_FLAG_BITS
Definition fc_types.h:472
output_type_id
output_type_id
Definition fc_types.h:102
game
struct civ_game game
Definition game.c:62
government_rule_name
const char * government_rule_name(const struct government *pgovern)
Definition government.c:135
governments_re_active_iterate
#define governments_re_active_iterate(_p)
Definition government.h:132
governments_re_active_iterate_end
#define governments_re_active_iterate_end
Definition government.h:136
GOVF_LAST_USER_FLAG
#define GOVF_LAST_USER_FLAG
Definition government.h:28
improvement_by_number
struct impr_type * improvement_by_number(const Impr_type_id id)
Definition improvement.c:198
improvement_rule_name
const char * improvement_rule_name(const struct impr_type *pimprove)
Definition improvement.c:257
genus_iterate_end
#define genus_iterate_end
Definition improvement.h:224
improvement_re_active_iterate_end
#define improvement_re_active_iterate_end
Definition improvement.h:214
genus_iterate
#define genus_iterate(_p)
Definition improvement.h:218
improvement_re_active_iterate
#define improvement_re_active_iterate(_p)
Definition improvement.h:210
fc_assert
#define fc_assert(condition)
Definition log.h:177
nation_rule_name
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
nation_by_number
struct nation_type * nation_by_number(const Nation_type_id nation)
Definition nation.c:472
nation_group_rule_name
const char * nation_group_rule_name(const struct nation_group *pgroup)
Definition nation.c:1071
nation_group_by_number
struct nation_group * nation_group_by_number(int id)
Definition nation.c:999
nation_group_count
int nation_group_count(void)
Definition nation.c:929
nations_iterate_end
#define nations_iterate_end
Definition nation.h:364
nations_iterate
#define nations_iterate(NAME_pnation)
Definition nation.h:361
nation_groups_iterate
#define nation_groups_iterate(NAME_pgroup)
Definition nation.h:339
nation_groups_iterate_end
#define nation_groups_iterate_end
Definition nation.h:343
universal_is_legal_in_requirement
bool universal_is_legal_in_requirement(const struct universal *univ)
Definition requirements.c:270
sanity_check_server_setting_value_in_req
bool sanity_check_server_setting_value_in_req(ssetv ssetval)
Definition rssanity.c:144
server_setting_by_name
server_setting_id server_setting_by_name(const char *name)
Definition server_settings.c:29
ssetv_rule_name
const char * ssetv_rule_name(ssetv val)
Definition server_settings.c:169
ssetv_from_values
ssetv ssetv_from_values(server_setting_id setting, int value)
Definition server_settings.c:106
server_settings.h
settings_number
int settings_number(void)
Definition settings.c:5302
specialist_by_number
struct specialist * specialist_by_number(const Specialist_type_id id)
Definition specialist.c:110
specialist_rule_name
const char * specialist_rule_name(const struct specialist *sp)
Definition specialist.c:157
specialist_type_re_active_iterate_end
#define specialist_type_re_active_iterate_end
Definition specialist.h:114
specialist_type_re_active_iterate
#define specialist_type_re_active_iterate(_p)
Definition specialist.h:109
civ_game::control
struct packet_ruleset_control control
Definition game.h:83
civ_game::government_during_revolution
struct government * government_during_revolution
Definition game.h:94
packet_ruleset_control::num_goods_types
int num_goods_types
Definition packets_gen.h:1468
packet_ruleset_control::num_styles
int num_styles
Definition packets_gen.h:1472
packet_ruleset_control::num_extra_types
int num_extra_types
Definition packets_gen.h:1463
packet_ruleset_control::num_unit_types
int num_unit_types
Definition packets_gen.h:1459
packet_ruleset_control::num_impr_types
int num_impr_types
Definition packets_gen.h:1460
packet_ruleset_control::nation_count
int nation_count
Definition packets_gen.h:1475
packet_ruleset_control::num_tech_types
int num_tech_types
Definition packets_gen.h:1462
packet_ruleset_control::num_achievement_types
int num_achievement_types
Definition packets_gen.h:1470
packet_ruleset_control::num_specialist_types
int num_specialist_types
Definition packets_gen.h:1478
packet_ruleset_control::num_unit_classes
int num_unit_classes
Definition packets_gen.h:1458
packet_ruleset_control::num_tiledef_types
int num_tiledef_types
Definition packets_gen.h:1464
universal::kind
enum universals_n kind
Definition fc_types.h:595
universal::value
universals_u value
Definition fc_types.h:594
style_by_number
struct nation_style * style_by_number(int id)
Definition style.c:88
style_rule_name
const char * style_rule_name(const struct nation_style *pstyle)
Definition style.c:108
styles_re_active_iterate_end
#define styles_re_active_iterate_end
Definition style.h:60
styles_re_active_iterate
#define styles_re_active_iterate(_p)
Definition style.h:56
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
advance_by_number
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
advance_rule_name
const char * advance_rule_name(const struct advance *padvance)
Definition tech.c:309
advance_re_active_iterate
#define advance_re_active_iterate(_p)
Definition tech.h:279
advance_re_active_iterate_end
#define advance_re_active_iterate_end
Definition tech.h:283
A_NONE
#define A_NONE
Definition tech.h:43
terrain_by_number
struct terrain * terrain_by_number(const Terrain_type_id type)
Definition terrain.c:157
terrain_rule_name
const char * terrain_rule_name(const struct terrain *pterrain)
Definition terrain.c:249
terrain_re_active_iterate_end
#define terrain_re_active_iterate_end
Definition terrain.h:282
terrain_re_active_iterate
#define terrain_re_active_iterate(_p)
Definition terrain.h:278
tiledef_rule_name
const char * tiledef_rule_name(const struct tiledef *td)
Definition tiledef.c:104
tiledef_by_number
struct tiledef * tiledef_by_number(int id)
Definition tiledef.c:84
tiledef_iterate_end
#define tiledef_iterate_end
Definition tiledef.h:54
tiledef_iterate
#define tiledef_iterate(_p)
Definition tiledef.h:48
goods_rule_name
const char * goods_rule_name(struct goods_type *pgood)
Definition traderoutes.c:639
goods_by_number
struct goods_type * goods_by_number(Goods_type_id id)
Definition traderoutes.c:621
goods_type_re_active_iterate_end
#define goods_type_re_active_iterate_end
Definition traderoutes.h:245
goods_type_re_active_iterate
#define goods_type_re_active_iterate(_p)
Definition traderoutes.h:241
universals_u::utype
const struct unit_type * utype
Definition fc_types.h:536
universals_u::unitflag
int unitflag
Definition fc_types.h:560
universals_u::min_techs
int min_techs
Definition fc_types.h:579
universals_u::mincalfrag
int mincalfrag
Definition fc_types.h:554
universals_u::tiledef
struct tiledef * tiledef
Definition fc_types.h:538
universals_u::region_tiles
int region_tiles
Definition fc_types.h:584
universals_u::diplrel
int diplrel
Definition fc_types.h:565
universals_u::style
struct nation_style * style
Definition fc_types.h:541
universals_u::ai_level
enum ai_level ai_level
Definition fc_types.h:545
universals_u::specialist
struct specialist * specialist
Definition fc_types.h:533
universals_u::impr_genus
enum impr_genus_id impr_genus
Definition fc_types.h:569
universals_u::citytile
enum citytile_type citytile
Definition fc_types.h:546
universals_u::nationgroup
struct nation_group * nationgroup
Definition fc_types.h:540
universals_u::extra
struct extra_type * extra
Definition fc_types.h:537
universals_u::wrap_property
enum wrap_flag wrap_property
Definition fc_types.h:587
universals_u::plrstate
enum plrstate_type plrstate
Definition fc_types.h:548
universals_u::govflag
int govflag
Definition fc_types.h:558
universals_u::min_cities
int min_cities
Definition fc_types.h:581
universals_u::tilerel
enum tilerel_type tilerel
Definition fc_types.h:549
universals_u::nation
struct nation_type * nation
Definition fc_types.h:530
universals_u::minmoves
int minmoves
Definition fc_types.h:572
universals_u::terrainclass
int terrainclass
Definition fc_types.h:556
universals_u::unitclassflag
int unitclassflag
Definition fc_types.h:559
universals_u::govern
struct government * govern
Definition fc_types.h:528
universals_u::origowner
struct nation_type * origowner
Definition fc_types.h:532
universals_u::age
int age
Definition fc_types.h:577
universals_u::minsize
int minsize
Definition fc_types.h:550
universals_u::impr_flag
enum impr_flag_id impr_flag
Definition fc_types.h:570
universals_u::terrainalter
int terrainalter
Definition fc_types.h:557
universals_u::minculture
int minculture
Definition fc_types.h:551
universals_u::citystatus
enum citystatus_type citystatus
Definition fc_types.h:547
universals_u::minforeignpct
int minforeignpct
Definition fc_types.h:552
universals_u::building
const struct impr_type * building
Definition fc_types.h:529
universals_u::max_tile_total_units
int max_tile_total_units
Definition fc_types.h:573
universals_u::max_tile_top_units
int max_tile_top_units
Definition fc_types.h:574
universals_u::achievement
struct achievement * achievement
Definition fc_types.h:539
universals_u::ssetval
ssetv ssetval
Definition fc_types.h:588
universals_u::techflag
int techflag
Definition fc_types.h:562
universals_u::advance
struct advance * advance
Definition fc_types.h:526
universals_u::activity
enum unit_activity activity
Definition fc_types.h:568
universals_u::good
struct goods_type * good
Definition fc_types.h:543
universals_u::terrain
struct terrain * terrain
Definition fc_types.h:534
universals_u::terrainflag
int terrainflag
Definition fc_types.h:561
universals_u::unit_state
enum ustate_prop unit_state
Definition fc_types.h:567
universals_u::minveteran
int minveteran
Definition fc_types.h:575
universals_u::extraflag
int extraflag
Definition fc_types.h:564
universals_u::outputtype
Output_type_id outputtype
Definition fc_types.h:555
universals_u::distance_sq
int distance_sq
Definition fc_types.h:583
universals_u::roadflag
int roadflag
Definition fc_types.h:563
universals_u::topo_property
enum topo_flag topo_property
Definition fc_types.h:586
universals_u::latitude
int latitude
Definition fc_types.h:582
universals_u::counter
struct counter * counter
Definition fc_types.h:527
universals_u::min_hit_points
int min_hit_points
Definition fc_types.h:576
universals_u::uclass
struct unit_class * uclass
Definition fc_types.h:535
universals_u::nationality
struct nation_type * nationality
Definition fc_types.h:531
universals_u::minyear
int minyear
Definition fc_types.h:553
universals_u::action
struct action * action
Definition fc_types.h:542
universals_u::future_techs
int future_techs
Definition fc_types.h:580
universals_u::form_age
int form_age
Definition fc_types.h:578
universals_u::plr_flag
enum plr_flag_id plr_flag
Definition fc_types.h:571
activity_type_iterate
#define activity_type_iterate(_act_)
Definition unit.h:287
activity_type_iterate_end
#define activity_type_iterate_end
Definition unit.h:292
uclass_by_number
struct unit_class * uclass_by_number(const Unit_Class_id id)
Definition unittype.c:2506
utype_rule_name
const char * utype_rule_name(const struct unit_type *punittype)
Definition unittype.c:1604
utype_by_number
struct unit_type * utype_by_number(const Unit_type_id id)
Definition unittype.c:114
uclass_rule_name
const char * uclass_rule_name(const struct unit_class *pclass)
Definition unittype.c:1667
unit_type_re_active_iterate
#define unit_type_re_active_iterate(_p)
Definition unittype.h:875
unit_class_re_active_iterate_end
#define unit_class_re_active_iterate_end
Definition unittype.h:932
UTYF_LAST_USER_FLAG
#define UTYF_LAST_USER_FLAG
Definition unittype.h:335
unit_class_re_active_iterate
#define unit_class_re_active_iterate(_p)
Definition unittype.h:928
unit_type_re_active_iterate_end
#define unit_type_re_active_iterate_end
Definition unittype.h:879
universal_value_initial
bool universal_value_initial(struct universal *src)
Definition univ_value.c:43
universal_kind_values
void universal_kind_values(struct universal *univ, univ_kind_values_cb cb, void *data)
Definition univ_value.c:292
univ_value.h
univ_kind_values_cb
void(* univ_kind_values_cb)(const char *value, bool current, void *data)
Definition univ_value.h:20
Generated on Sun Dec 7 2025 22:31:31 for Freeciv-3.4 by doxygen 1.9.8