Freeciv-3.2
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 "traderoutes.h"
29
30/* server */
31#include "rssanity.h"
32#include "settings.h"
33
34#include "univ_value.h"
35
36/********************************************************************/
43{
44 switch (src->kind) {
45 case VUT_NONE:
46 /* Value of None should never be used */
47 return TRUE;
48 case VUT_ADVANCE:
49 if (game.control.num_tech_types <= 0) {
50 return FALSE;
51 }
53 return TRUE;
54 case VUT_COUNTER:
56 return FALSE;
57 }
59 return TRUE;
60 case VUT_GOVERNMENT:
62 return TRUE;
63 case VUT_IMPROVEMENT:
64 if (game.control.num_impr_types <= 0) {
65 return FALSE;
66 }
68 return TRUE;
69 case VUT_TERRAIN:
71 return TRUE;
72 case VUT_NATION:
73 if (game.control.nation_count <= 0) {
74 return FALSE;
75 }
77 return TRUE;
78 case VUT_UTYPE:
79 if (game.control.num_unit_types <= 0) {
80 return FALSE;
81 }
82 src->value.utype = utype_by_number(0);
83 return TRUE;
84 case VUT_UTFLAG:
85 src->value.unitflag = (enum unit_type_flag_id)0;
86 return TRUE;
87 case VUT_UCLASS:
88 if (game.control.num_unit_classes <= 0) {
89 return FALSE;
90 }
92 return TRUE;
93 case VUT_UCFLAG:
95 return TRUE;
96 case VUT_OTYPE:
97 src->value.outputtype = (enum output_type_id)0;
98 return TRUE;
99 case VUT_SPECIALIST:
101 return FALSE;
102 }
104 return TRUE;
105 case VUT_MINSIZE:
106 src->value.minsize = 0;
107 return TRUE;
108 case VUT_AI_LEVEL:
110 return TRUE;
111 case VUT_TERRAINCLASS:
113 return TRUE;
114 case VUT_MINYEAR:
115 src->value.minyear = 0;
116 return TRUE;
117 case VUT_MINCALFRAG:
118 src->value.mincalfrag = 0;
119 return TRUE;
120 case VUT_TERRAINALTER:
122 return TRUE;
123 case VUT_CITYTILE:
125 return TRUE;
126 case VUT_CITYSTATUS:
128 return TRUE;
129 case VUT_GOOD:
130 if (game.control.num_goods_types <= 0) {
131 return FALSE;
132 }
133 src->value.good = goods_by_number(0);
134 return TRUE;
135 case VUT_TERRFLAG:
137 return TRUE;
138 case VUT_NATIONALITY:
139 if (game.control.nation_count <= 0) {
140 return FALSE;
141 }
143 return TRUE;
145 if (game.control.nation_count <= 0) {
146 return FALSE;
147 }
149 return TRUE;
150 case VUT_ROADFLAG:
151 src->value.roadflag = RF_RIVER;
152 return TRUE;
153 case VUT_EXTRA:
154 if (game.control.num_extra_types <= 0) {
155 return FALSE;
156 }
157 src->value.extra = extra_by_number(0);
158 return TRUE;
159 case VUT_TECHFLAG:
161 return TRUE;
162 case VUT_ACHIEVEMENT:
164 return FALSE;
165 }
167 return TRUE;
168 case VUT_DIPLREL:
169 case VUT_DIPLREL_TILE:
173 src->value.diplrel = DS_WAR;
174 return TRUE;
175 case VUT_MAXTILEUNITS:
176 src->value.max_tile_units = 0;
177 return TRUE;
178 case VUT_STYLE:
179 if (game.control.num_styles <= 0) {
180 return FALSE;
181 }
182 src->value.style = style_by_number(0);
183 return TRUE;
184 case VUT_MINCULTURE:
185 src->value.minculture = 0;
186 return TRUE;
188 src->value.minforeignpct = 0;
189 return TRUE;
190 case VUT_UNITSTATE:
192 return TRUE;
193 case VUT_ACTIVITY:
195 return TRUE;
196 case VUT_MINMOVES:
197 src->value.minmoves = 0;
198 return TRUE;
199 case VUT_MINVETERAN:
200 src->value.minveteran = 0;
201 return TRUE;
202 case VUT_MINHP:
203 src->value.min_hit_points = 0;
204 return TRUE;
205 case VUT_AGE:
206 src->value.age = 0;
207 return TRUE;
208 case VUT_FORM_AGE:
209 src->value.form_age = 0;
210 return TRUE;
211 case VUT_NATIONGROUP:
212 if (nation_group_count() <= 0) {
213 return FALSE;
214 }
216 return TRUE;
217 case VUT_TOPO:
219 return TRUE;
220 case VUT_WRAP:
222 return TRUE;
224 src->value.ssetval
226 return TRUE;
227 case VUT_IMPR_GENUS:
229 return TRUE;
230 case VUT_IMPR_FLAG:
232 return TRUE;
233 case VUT_PLAYER_FLAG:
234 src->value.plr_flag = PLRF_AI;
235 return TRUE;
236 case VUT_PLAYER_STATE:
238 return TRUE;
239 case VUT_ACTION:
240 src->value.action = action_by_number(0);
241 return TRUE;
242 case VUT_MINTECHS:
243 src->value.min_techs = 0;
244 return TRUE;
245 case VUT_EXTRAFLAG:
247 return TRUE;
248 case VUT_MINLATITUDE:
249 case VUT_MAXLATITUDE:
250 src->value.latitude = 0;
251 return TRUE;
252 case VUT_COUNT:
253 fc_assert(src->kind != VUT_COUNT);
254 return FALSE;
255 }
256
257 return FALSE;
258}
259
260/********************************************************************/
264 univ_kind_values_cb cb, void *data)
265{
266 int i;
267
268 switch (univ->kind) {
269 case VUT_NONE:
270 break;
271 case VUT_ADVANCE:
273 cb(advance_rule_name(padv), univ->value.advance == padv, data);
275 break;
276 case VUT_COUNTER:
278 cb(counter_rule_name(pcount), univ->value.counter == pcount, data);
280 break;
281 case VUT_GOVERNMENT:
283 cb(government_rule_name(pgov), univ->value.govern == pgov, data);
285 break;
286 case VUT_IMPROVEMENT:
288 cb(improvement_rule_name(pimpr), univ->value.building == pimpr, data);
290 break;
291 case VUT_TERRAIN:
293 cb(terrain_rule_name(pterr), univ->value.terrain == pterr, data);
295 break;
296 case VUT_NATION:
298 cb(nation_rule_name(pnat), univ->value.nation == pnat, data);
300 break;
301 case VUT_UTYPE:
303 cb(utype_rule_name(putype), univ->value.utype == putype, data);
305 break;
306 case VUT_UCLASS:
308 cb(uclass_rule_name(pclass), univ->value.uclass == pclass, data);
310 break;
311 case VUT_OTYPE:
313 cb(get_output_name(otype), univ->value.outputtype == otype, data);
315 break;
316 case VUT_GOOD:
318 cb(goods_rule_name(pgood), univ->value.good == pgood, data);
320 break;
321 case VUT_NATIONALITY:
323 cb(nation_rule_name(pnat), univ->value.nationality == pnat, data);
325 break;
328 cb(nation_rule_name(pnat), univ->value.origowner == pnat, data);
330 break;
331 case VUT_EXTRA:
333 cb(extra_rule_name(pextra), univ->value.extra == pextra, data);
335 break;
336 case VUT_STYLE:
338 cb(style_rule_name(pstyle), univ->value.style == pstyle, data);
340 break;
341 case VUT_AI_LEVEL:
342 for (i = 0; i < AI_LEVEL_COUNT; i++) {
343 cb(ai_level_name(i), univ->value.ai_level == i, data);
344 }
345 break;
346 case VUT_SPECIALIST:
348 cb(specialist_rule_name(pspe), univ->value.specialist == pspe, data);
350 break;
351 case VUT_TERRAINCLASS:
352 for (i = 0; i < TC_COUNT; i++) {
353 cb(terrain_class_name(i), univ->value.terrainclass == i, data);
354 }
355 break;
356 case VUT_UTFLAG:
357 for (i = 0; i < UTYF_LAST_USER_FLAG; i++) {
358 cb(unit_type_flag_id_name(i), univ->value.unitflag == i, data);
359 }
360 break;
361 case VUT_UCFLAG:
362 for (i = 0; i < UCF_COUNT; i++) {
363 cb(unit_class_flag_id_name(i), univ->value.unitclassflag == i, data);
364 }
365 break;
366 case VUT_TERRFLAG:
367 for (i = 0; i < TER_USER_LAST; i++) {
368 cb(terrain_flag_id_name(i), univ->value.terrainflag == i, data);
369 }
370 break;
371 case VUT_ROADFLAG:
372 for (i = 0; i < RF_COUNT; i++) {
373 cb(road_flag_id_name(i), univ->value.roadflag == i, data);
374 }
375 break;
376 case VUT_TECHFLAG:
377 for (i = 0; i < TF_COUNT; i++) {
378 cb(tech_flag_id_name(i), univ->value.techflag == i, data);
379 }
380 break;
381 case VUT_EXTRAFLAG:
382 for (i = 0; i < EF_COUNT; i++) {
383 cb(extra_flag_id_name(i), univ->value.extraflag == i, data);
384 }
385 break;
386 case VUT_TERRAINALTER:
387 for (i = 0; i < TA_COUNT; i++) {
388 cb(terrain_alteration_name(i), univ->value.terrainalter == i, data);
389 }
390 break;
391 case VUT_CITYTILE:
392 for (i = 0; i < CITYT_LAST; i++) {
393 cb(citytile_type_name(i), univ->value.citytile == i, data);
394 }
395 break;
396 case VUT_CITYSTATUS:
397 for (i = 0; i < CITYS_LAST; i++) {
398 cb(citystatus_type_name(i), univ->value.citystatus == i, data);
399 }
400 break;
401 case VUT_ACHIEVEMENT:
403 cb(achievement_rule_name(pach), univ->value.achievement == pach, data);
405 break;
406 case VUT_DIPLREL:
407 case VUT_DIPLREL_TILE:
411 for (i = 0; i < DS_LAST; i++) {
412 cb(diplstate_type_name(i), univ->value.diplrel == i, data);
413 }
414 for (; i < DRO_LAST; i++) {
415 cb(diplrel_other_name(i), univ->value.diplrel == i, data);
416 }
417 break;
418 case VUT_UNITSTATE:
419 for (i = 0; i < USP_COUNT; i++) {
420 cb(ustate_prop_name(i), univ->value.unit_state == i, data);
421 }
422 break;
423 case VUT_ACTIVITY:
426 &(struct universal){.kind = VUT_ACTIVITY,
427 .value = {.activity = act}})) {
428 /* This activity is excluded from appearing in requirement
429 * vectors. */
430 continue;
431 }
432 cb(unit_activity_name(act), univ->value.activity == act, data);
434 break;
435 case VUT_NATIONGROUP:
439 break;
440 case VUT_TOPO:
441 for (i = 0; i < TOPO_FLAG_BITS; i++) {
442 cb(topo_flag_name(1 << i), univ->value.topo_property == 1 << i, data);
443 }
444 break;
445 case VUT_WRAP:
446 for (i = 0; i < WRAP_FLAG_BITS; i++) {
447 cb(wrap_flag_name(1 << i), univ->value.wrap_property == 1 << i, data);
448 }
449 break;
451 for (i = 0;
452 /* Only binary settings with the value TRUE are currently
453 * supported. */
454 i < settings_number();
455 i++) {
457 cb(ssetv_rule_name(i),
458 univ->value.ssetval == ssetv_from_values(i, TRUE), data);
459 }
460 }
461 break;
462 case VUT_IMPR_GENUS:
463 genus_iterate(genus) {
464 cb(impr_genus_id_name(genus), univ->value.impr_genus == genus, data);
466 break;
467 case VUT_IMPR_FLAG:
468 for (i = 0; i < IF_COUNT; i++) {
469 cb(impr_flag_id_name(i), univ->value.impr_flag == i, data);
470 }
471 break;
472 case VUT_PLAYER_FLAG:
473 for (i = 0; i < PLRF_COUNT; i++) {
474 cb(plr_flag_id_name(i), univ->value.plr_flag == i, data);
475 }
476 break;
477 case VUT_PLAYER_STATE:
478 for (i = 0; i < PLRS_LAST; i++) {
479 cb(plrstate_type_name(i), univ->value.plrstate == i, data);
480 }
481 break;
482 case VUT_ACTION:
483 action_iterate(act) {
484 struct action *pact = action_by_number(act);
485
486 cb(action_rule_name(pact), univ->value.action == pact, data);
488 break;
489 case VUT_MINSIZE:
490 case VUT_MINYEAR:
491 case VUT_MINCALFRAG:
492 case VUT_MAXTILEUNITS:
493 case VUT_MINCULTURE:
495 case VUT_MINMOVES:
496 case VUT_MINVETERAN:
497 case VUT_MINHP:
498 case VUT_AGE:
499 case VUT_FORM_AGE:
500 case VUT_MINTECHS:
501 case VUT_MINLATITUDE:
502 case VUT_MAXLATITUDE:
503 /* Requirement types having numerical value */
504 cb(NULL, FALSE, data);
505 break;
506 case VUT_COUNT:
507 fc_assert(univ->kind != VUT_COUNT);
508 break;
509 }
510}
struct achievement * achievement_by_number(int id)
const char * achievement_rule_name(struct achievement *pach)
#define achievements_re_active_iterate(_p)
#define achievements_re_active_iterate_end
const char * action_rule_name(const struct action *action)
Definition actions.c:1968
static struct action * action_by_number(action_id act_id)
Definition actions.h:633
#define action_iterate_end
Definition actions.h:463
#define action_iterate(_act_)
Definition actions.h:459
const char * get_output_name(Output_type_id output)
Definition city.c:628
#define output_type_iterate(output)
Definition city.h:833
#define output_type_iterate_end
Definition city.h:839
char * incite_cost
Definition comments.c:74
struct counter * counter_by_index(int index, enum counter_target target)
Definition counters.c:183
const char * counter_rule_name(struct counter *pcount)
Definition counters.c:165
int counters_get_city_counters_count(void)
Definition counters.c:74
#define city_counters_iterate_end
Definition counters.h:64
#define city_counters_iterate(pcount)
Definition counters.h:57
struct extra_type * extra_by_number(int id)
Definition extras.c:183
const char * extra_rule_name(const struct extra_type *pextra)
Definition extras.c:203
#define extra_type_re_active_iterate_end
Definition extras.h:329
#define extra_type_re_active_iterate(_p)
Definition extras.h:325
#define TOPO_FLAG_BITS
Definition fc_types.h:626
@ CTGT_CITY
Definition fc_types.h:126
#define WRAP_FLAG_BITS
Definition fc_types.h:635
output_type_id
Definition fc_types.h:100
struct civ_game game
Definition game.c:62
const char * government_rule_name(const struct government *pgovern)
Definition government.c:133
#define governments_re_active_iterate(_p)
Definition government.h:125
#define governments_re_active_iterate_end
Definition government.h:129
struct impr_type * improvement_by_number(const Impr_type_id id)
const char * improvement_rule_name(const struct impr_type *pimprove)
#define genus_iterate_end
#define improvement_re_active_iterate_end
#define genus_iterate(_p)
#define improvement_re_active_iterate(_p)
#define fc_assert(condition)
Definition log.h:176
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
struct nation_type * nation_by_number(const Nation_type_id nation)
Definition nation.c:475
const char * nation_group_rule_name(const struct nation_group *pgroup)
Definition nation.c:1079
struct nation_group * nation_group_by_number(int id)
Definition nation.c:1004
int nation_group_count(void)
Definition nation.c:935
#define nations_iterate_end
Definition nation.h:336
#define nations_iterate(NAME_pnation)
Definition nation.h:333
#define nation_groups_iterate(NAME_pgroup)
Definition nation.h:311
#define nation_groups_iterate_end
Definition nation.h:315
bool universal_is_legal_in_requirement(const struct universal *univ)
bool sanity_check_server_setting_value_in_req(ssetv ssetval)
Definition rssanity.c:141
server_setting_id server_setting_by_name(const char *name)
const char * ssetv_rule_name(ssetv val)
ssetv ssetv_from_values(server_setting_id setting, int value)
int settings_number(void)
Definition settings.c:5292
struct specialist * specialist_by_number(const Specialist_type_id id)
Definition specialist.c:100
const char * specialist_rule_name(const struct specialist *sp)
Definition specialist.c:146
#define specialist_type_re_active_iterate_end
Definition specialist.h:88
#define specialist_type_re_active_iterate(_p)
Definition specialist.h:83
struct packet_ruleset_control control
Definition game.h:83
struct government * government_during_revolution
Definition game.h:94
enum universals_n kind
Definition fc_types.h:903
universals_u value
Definition fc_types.h:902
struct nation_style * style_by_number(int id)
Definition style.c:88
const char * style_rule_name(const struct nation_style *pstyle)
Definition style.c:108
#define styles_re_active_iterate_end
Definition style.h:60
#define styles_re_active_iterate(_p)
Definition style.h:56
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
const char * advance_rule_name(const struct advance *padvance)
Definition tech.c:299
#define advance_re_active_iterate(_p)
Definition tech.h:281
#define advance_re_active_iterate_end
Definition tech.h:285
#define A_NONE
Definition tech.h:43
struct terrain * terrain_by_number(const Terrain_type_id type)
Definition terrain.c:156
const char * terrain_rule_name(const struct terrain *pterrain)
Definition terrain.c:247
#define terrain_re_active_iterate_end
Definition terrain.h:388
#define terrain_re_active_iterate(_p)
Definition terrain.h:384
const char * goods_rule_name(struct goods_type *pgood)
struct goods_type * goods_by_number(Goods_type_id id)
#define goods_type_re_active_iterate_end
#define goods_type_re_active_iterate(_p)
const struct unit_type * utype
Definition fc_types.h:724
struct nation_style * style
Definition fc_types.h:728
enum ai_level ai_level
Definition fc_types.h:732
struct specialist * specialist
Definition fc_types.h:721
enum impr_genus_id impr_genus
Definition fc_types.h:754
enum citytile_type citytile
Definition fc_types.h:733
struct nation_group * nationgroup
Definition fc_types.h:727
struct extra_type * extra
Definition fc_types.h:725
enum wrap_flag wrap_property
Definition fc_types.h:767
enum plrstate_type plrstate
Definition fc_types.h:735
struct nation_type * nation
Definition fc_types.h:718
int terrainclass
Definition fc_types.h:742
int unitclassflag
Definition fc_types.h:744
struct government * govern
Definition fc_types.h:716
struct nation_type * origowner
Definition fc_types.h:720
enum impr_flag_id impr_flag
Definition fc_types.h:755
int max_tile_units
Definition fc_types.h:758
int terrainalter
Definition fc_types.h:743
enum citystatus_type citystatus
Definition fc_types.h:734
int minforeignpct
Definition fc_types.h:738
const struct impr_type * building
Definition fc_types.h:717
struct achievement * achievement
Definition fc_types.h:726
ssetv ssetval
Definition fc_types.h:768
struct advance * advance
Definition fc_types.h:714
enum unit_activity activity
Definition fc_types.h:753
struct goods_type * good
Definition fc_types.h:730
struct terrain * terrain
Definition fc_types.h:722
int terrainflag
Definition fc_types.h:746
enum ustate_prop unit_state
Definition fc_types.h:752
Output_type_id outputtype
Definition fc_types.h:741
enum topo_flag topo_property
Definition fc_types.h:766
struct counter * counter
Definition fc_types.h:715
int min_hit_points
Definition fc_types.h:760
struct unit_class * uclass
Definition fc_types.h:723
struct nation_type * nationality
Definition fc_types.h:719
struct action * action
Definition fc_types.h:729
enum plr_flag_id plr_flag
Definition fc_types.h:756
#define activity_type_iterate(_act_)
Definition unit.h:284
#define activity_type_iterate_end
Definition unit.h:289
struct unit_class * uclass_by_number(const Unit_Class_id id)
Definition unittype.c:2476
const char * utype_rule_name(const struct unit_type *punittype)
Definition unittype.c:1578
struct unit_type * utype_by_number(const Unit_type_id id)
Definition unittype.c:112
const char * uclass_rule_name(const struct unit_class *pclass)
Definition unittype.c:1641
#define unit_type_re_active_iterate(_p)
Definition unittype.h:864
#define unit_class_re_active_iterate_end
Definition unittype.h:921
#define UTYF_LAST_USER_FLAG
Definition unittype.h:331
#define unit_class_re_active_iterate(_p)
Definition unittype.h:917
#define unit_type_re_active_iterate_end
Definition unittype.h:868
bool universal_value_initial(struct universal *src)
Definition univ_value.c:42
void universal_kind_values(struct universal *univ, univ_kind_values_cb cb, void *data)
Definition univ_value.c:263
void(* univ_kind_values_cb)(const char *value, bool current, void *data)
Definition univ_value.h:20