#include "fc_types.h"
#include "specenum_gen.h"
#include "specvec.h"

Include dependency graph for requirements.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	requirement

struct	req_vec_change

struct	req_vec_problem

Macros
#define	SPECENUM_NAME req_range

#define	SPECENUM_VALUE0 REQ_RANGE_LOCAL

#define	SPECENUM_VALUE0NAME "Local"

#define	SPECENUM_VALUE1 REQ_RANGE_CADJACENT

#define	SPECENUM_VALUE1NAME "CAdjacent"

#define	SPECENUM_VALUE2 REQ_RANGE_ADJACENT

#define	SPECENUM_VALUE2NAME "Adjacent"

#define	SPECENUM_VALUE3 REQ_RANGE_CITY

#define	SPECENUM_VALUE3NAME "City"

#define	SPECENUM_VALUE4 REQ_RANGE_TRADEROUTE

#define	SPECENUM_VALUE4NAME "Traderoute"

#define	SPECENUM_VALUE5 REQ_RANGE_CONTINENT

#define	SPECENUM_VALUE5NAME "Continent"

#define	SPECENUM_VALUE6 REQ_RANGE_PLAYER

#define	SPECENUM_VALUE6NAME "Player"

#define	SPECENUM_VALUE7 REQ_RANGE_TEAM

#define	SPECENUM_VALUE7NAME "Team"

#define	SPECENUM_VALUE8 REQ_RANGE_ALLIANCE

#define	SPECENUM_VALUE8NAME "Alliance"

#define	SPECENUM_VALUE9 REQ_RANGE_WORLD

#define	SPECENUM_VALUE9NAME "World"

#define	SPECENUM_COUNT REQ_RANGE_COUNT

#define	req_range_iterate(_range_)

#define	req_range_iterate_end

#define	SPECVEC_TAG requirement

#define	SPECVEC_TYPE struct requirement

#define	requirement_vector_iterate(req_vec, preq) TYPED_VECTOR_ITERATE(struct requirement, req_vec, preq)

#define	requirement_vector_iterate_end VECTOR_ITERATE_END

#define	SPECENUM_NAME req_vec_change_operation

#define	SPECENUM_VALUE0 RVCO_REMOVE

#define	SPECENUM_VALUE0NAME N_("Remove")

#define	SPECENUM_VALUE1 RVCO_APPEND

#define	SPECENUM_VALUE1NAME N_("Append")

#define	SPECENUM_COUNT RVCO_NOOP

#define	universal_is_mentioned_by_requirement(preq, psource) are_universals_equal(&preq->source, psource)

#define	universals_iterate(_univ_)

#define	universals_iterate_end

#define	requirement_fulfilled_by_government(_gov_, _rqs_)

#define	requirement_fulfilled_by_nation(_nat_, _rqs_)

#define	requirement_fulfilled_by_improvement(_imp_, _rqs_)

#define	requirement_fulfilled_by_terrain(_ter_, _rqs_)

#define	requirement_fulfilled_by_unit_class(_uc_, _rqs_)

#define	requirement_fulfilled_by_unit_type(_ut_, _rqs_)

#define	requirement_needs_improvement(_imp_, _rqs_)

#define	requirement_diplrel_ereq(_id_, _range_, _present_) requirement_kind_ereq(_id_, _range_, _present_, DRO_LAST)

Typedefs
typedef signed char	req_vec_num_in_item
	req_vec_num_in_item a requirement vectors number in an item. More...

typedef req_vec_num_in_item(*	requirement_vector_number) (const void parent_item, const struct requirement_vector vec)
	Returns the requirement vector number of the specified requirement vector in the specified parent item or -1 if the vector doesn't belong to the parent item. More...

typedef struct requirement_vector (	requirement_vector_by_number) (const void *parent_item, req_vec_num_in_item number)
	Returns a writable pointer to the specified requirement vector in the specified parent item or nullptr if the parent item doesn't have a requirement vector with that requirement vector number. More...

typedef const char (	requirement_vector_namer) (req_vec_num_in_item number)
	Returns the name of the specified requirement vector number in the parent item or nullptr if parent items of the kind this function is for don't have a requirement vector with that number. More...

Enumerations
enum	req_item_found { ITF_NO , ITF_YES , ITF_NOT_APPLICABLE }

Functions
struct requirement	req_from_str (const char type, const char range, bool survives, bool present, bool quiet, const char *value)
	Parse a requirement type and value string into a requirement structure. More...

QString	req_to_fstring (const struct requirement *req)
	Returns the given requirement as a formatted string ready for printing. More...

void	req_get_values (const struct requirement req, int type, int range, bool survives, bool present, bool quiet, int *value)
	Return the value of a req as a serializable integer. More...

struct requirement	req_from_values (int type, int range, bool survives, bool present, bool quiet, int value)
	Set the values of a req from serializable integers. More...

bool	are_requirements_equal (const struct requirement req1, const struct requirement req2)
	Returns TRUE if req1 and req2 are equal. More...

bool	are_requirements_contradictions (const struct requirement req1, const struct requirement req2)
	Returns TRUE if req1 and req2 contradicts each other. More...

bool	does_req_contradicts_reqs (const struct requirement req, const struct requirement_vector vec)
	Returns TRUE if the given requirement contradicts the given requirement vector. More...

bool	is_req_active (const struct player target_player, const struct player other_player, const struct city target_city, const struct impr_type target_building, const struct tile target_tile, const struct unit target_unit, const struct unit_type target_unittype, const struct output_type target_output, const struct specialist target_specialist, const struct action target_action, const struct requirement *req, const enum req_problem_type prob_type, const enum vision_layer vision_layer=V_COUNT, const enum national_intelligence nintel=NI_COUNT)
	Checks the requirement to see if it is active on the given target. More...

bool	are_reqs_active (const struct player target_player, const struct player other_player, const struct city target_city, const struct impr_type target_building, const struct tile target_tile, const struct unit target_unit, const struct unit_type target_unittype, const struct output_type target_output, const struct specialist target_specialist, const struct action target_action, const struct requirement_vector *reqs, const enum req_problem_type prob_type, const enum vision_layer vision_layer=V_COUNT, const enum national_intelligence nintel=NI_COUNT)
	Checks the requirement(s) to see if they are active on the given target. More...

bool	is_req_unchanging (const struct requirement *req)
	Return TRUE if this is an "unchanging" requirement. More...

bool	is_req_in_vec (const struct requirement req, const struct requirement_vector vec)
	Returns TRUE iff the requirement vector vec contains the requirement req. More...

bool	req_vec_wants_type (const struct requirement_vector *reqs, enum universals_n kind)
	Returns TRUE iff the specified requirement vector has a positive requirement of the specified requirement type. More...

req_vec_num_in_item	req_vec_vector_number (const void parent_item, const struct requirement_vector vec)
	Returns the requirement vector number of the specified requirement vector in the specified requirement vector. More...

const char *	req_vec_change_translation (const struct req_vec_change *change, const requirement_vector_namer namer)
	Returns the specified requirement vector change as a translated string ready for use in the user interface. More...

bool	req_vec_change_apply (const struct req_vec_change modification, requirement_vector_by_number getter, const void parent_item)
	Returns TRUE iff the specified requirement vector modification was successfully applied to the specified target requirement vector. More...

struct req_vec_problem *	req_vec_problem_new (int num_suggested_solutions, const char *description,...)
	Returns a new requirement vector problem with the specified number of suggested solutions and the specified description. More...

void	req_vec_problem_free (struct req_vec_problem *issue)
	De-allocates resources associated with the given requirement vector problem. More...

struct req_vec_problem *	req_vec_get_first_contradiction (const struct requirement_vector vec, requirement_vector_number get_num, const void parent_item)
	Returns the first self contradiction found in the specified requirement vector with suggested solutions or nullptr if no contradiction was found. More...

int	universal_number (const struct universal *source)
	Return the universal number of the constituent. More...

struct universal	universal_by_number (const enum universals_n kind, const int value)
	Combine values into a universal structure. More...

struct universal	universal_by_rule_name (const char kind, const char value)
	Parse requirement type (kind) and value strings into a universal structure. More...

void	universal_value_from_str (struct universal source, const char value)
	Parse requirement value strings into a universal structure. More...

void	universal_extraction (const struct universal source, int kind, int *value)
	Extract universal structure into its components for serialization; the opposite of universal_by_number(). More...

bool	are_universals_equal (const struct universal psource1, const struct universal psource2)
	Return TRUE iff the two sources are equivalent. More...

const char *	universal_rule_name (const struct universal *psource)
	Return the (untranslated) rule name of the universal. More...

const char *	universal_name_translation (const struct universal psource, char buf, size_t bufsz)
	Make user-friendly text for the source. More...

const char *	universal_type_rule_name (const struct universal *psource)
	Return untranslated name of the universal source name. More...

int	universal_build_shield_cost (const struct city pcity, const struct universal target)
	Return the number of shields it takes to build this universal. More...

bool	universal_replace_in_req_vec (struct requirement_vector reqs, const struct universal to_replace, const struct universal *replacement)
	Replaces all instances of the universal to_replace with replacement in the requirement vector reqs and returns TRUE iff any requirements were replaced. More...

bool	universal_is_mentioned_by_requirements (const struct requirement_vector reqs, const struct universal psource)
	Returns TRUE iff the universal 'psource' is directly mentioned by any of the requirements in 'reqs'. More...

void	universal_found_functions_init ()
	Initialise universal_found_function array. More...

enum req_item_found	universal_fulfills_requirement (const struct requirement preq, const struct universal source)
	Will the universal 'source' fulfill this requirement? More...

bool	universal_fulfills_requirements (bool check_necessary, const struct requirement_vector reqs, const struct universal source)
	Will the universal 'source' fulfill the requirements in the list? If 'check_necessary' is FALSE: are there no requirements that 'source' would actively prevent the fulfilment of? If 'check_necessary' is TRUE: does 'source' help the requirements to be fulfilled? (NB 'source' might not be the only source of its type that would be sufficient; for instance, if 'source' is a specific terrain type, we can return TRUE even if the requirement is only for something vague like a TerrainClass.) More...

bool	sv_universal_fulfills_requirements (bool check_necessary, const struct requirement_vector *reqs, const struct universal source)
	Version of universal_fulfills_requirements that takes the universal by value. More...

bool	universal_is_relevant_to_requirement (const struct requirement req, const struct universal source)
	Returns TRUE iff the specified universal is relevant to fulfilling the specified requirement. More...

int	requirement_kind_ereq (const int value, const enum req_range range, const bool present, const int max_value)
	Returns (the position of) the given requirement's enumerator in the enumeration of all possible requirements of its requirement kind. More...

Macro Definition Documentation

◆ req_range_iterate

#define req_range_iterate ( _range_ )

Value:

  {                                                                         \
    enum req_range _range_;                                                 \
    for (_range_ = REQ_RANGE_LOCAL; _range_ < REQ_RANGE_COUNT;              \
         _range_ = (enum req_range)(_range_ + 1)) {

Definition at line 51 of file requirements.h.

◆ req_range_iterate_end

#define req_range_iterate_end

Value:

} \

}

Definition at line 57 of file requirements.h.

◆ requirement_diplrel_ereq

#define requirement_diplrel_ereq	(	_id_,
		_range_,
		_present_
	)	requirement_kind_ereq(_id_, _range_, _present_, DRO_LAST)

Definition at line 320 of file requirements.h.

◆ requirement_fulfilled_by_government

#define requirement_fulfilled_by_government	(	_gov_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.govern = (_gov_)},                      \
                         .kind = VUT_GOVERNMENT})

Definition at line 283 of file requirements.h.

◆ requirement_fulfilled_by_improvement

#define requirement_fulfilled_by_improvement	(	_imp_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.building = (_imp_)},                    \
                         .kind = VUT_IMPROVEMENT})

Definition at line 292 of file requirements.h.

◆ requirement_fulfilled_by_nation

#define requirement_fulfilled_by_nation	(	_nat_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.nation = (_nat_)}, .kind = VUT_NATION})

Definition at line 288 of file requirements.h.

◆ requirement_fulfilled_by_terrain

#define requirement_fulfilled_by_terrain	(	_ter_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.terrain = (_ter_)},                     \
                         .kind = VUT_TERRAIN})

Definition at line 297 of file requirements.h.

◆ requirement_fulfilled_by_unit_class

#define requirement_fulfilled_by_unit_class	(	_uc_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.uclass = (_uc_)}, .kind = VUT_UCLASS})

Definition at line 302 of file requirements.h.

◆ requirement_fulfilled_by_unit_type

#define requirement_fulfilled_by_unit_type	(	_ut_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      false, (_rqs_),                                                       \
      (struct universal){.value = {.utype = (_ut_)}, .kind = VUT_UTYPE})

Definition at line 306 of file requirements.h.

◆ requirement_needs_improvement

#define requirement_needs_improvement	(	_imp_,
		_rqs_
	)

Value:

  sv_universal_fulfills_requirements(                                       \
      true, (_rqs_),                                                        \
      (struct universal){.value = {.building = (_imp_)},                    \
                         .kind = VUT_IMPROVEMENT})

Definition at line 311 of file requirements.h.

◆ requirement_vector_iterate

#define requirement_vector_iterate	(	req_vec,
		preq
	)	TYPED_VECTOR_ITERATE(struct requirement, req_vec, preq)

Definition at line 78 of file requirements.h.

◆ requirement_vector_iterate_end

#define requirement_vector_iterate_end VECTOR_ITERATE_END

Definition at line 80 of file requirements.h.

◆ SPECENUM_COUNT [1/2]

#define SPECENUM_COUNT REQ_RANGE_COUNT

Definition at line 187 of file requirements.h.

◆ SPECENUM_COUNT [2/2]

#define SPECENUM_COUNT RVCO_NOOP

Definition at line 187 of file requirements.h.

◆ SPECENUM_NAME [1/2]

#define SPECENUM_NAME req_range

Definition at line 182 of file requirements.h.

◆ SPECENUM_NAME [2/2]

#define SPECENUM_NAME req_vec_change_operation

Definition at line 182 of file requirements.h.

◆ SPECENUM_VALUE0 [1/2]

#define SPECENUM_VALUE0 REQ_RANGE_LOCAL

Definition at line 183 of file requirements.h.

◆ SPECENUM_VALUE0 [2/2]

#define SPECENUM_VALUE0 RVCO_REMOVE

Definition at line 183 of file requirements.h.

◆ SPECENUM_VALUE0NAME [1/2]

#define SPECENUM_VALUE0NAME "Local"

Definition at line 184 of file requirements.h.

◆ SPECENUM_VALUE0NAME [2/2]

#define SPECENUM_VALUE0NAME N_("Remove")

Definition at line 184 of file requirements.h.

◆ SPECENUM_VALUE1 [1/2]

#define SPECENUM_VALUE1 REQ_RANGE_CADJACENT

Definition at line 185 of file requirements.h.

◆ SPECENUM_VALUE1 [2/2]

#define SPECENUM_VALUE1 RVCO_APPEND

Definition at line 185 of file requirements.h.

◆ SPECENUM_VALUE1NAME [1/2]

#define SPECENUM_VALUE1NAME "CAdjacent"

Definition at line 186 of file requirements.h.

◆ SPECENUM_VALUE1NAME [2/2]

#define SPECENUM_VALUE1NAME N_("Append")

Definition at line 186 of file requirements.h.

◆ SPECENUM_VALUE2

#define SPECENUM_VALUE2 REQ_RANGE_ADJACENT

Definition at line 32 of file requirements.h.

◆ SPECENUM_VALUE2NAME

#define SPECENUM_VALUE2NAME "Adjacent"

Definition at line 33 of file requirements.h.

◆ SPECENUM_VALUE3

#define SPECENUM_VALUE3 REQ_RANGE_CITY

Definition at line 34 of file requirements.h.

◆ SPECENUM_VALUE3NAME

#define SPECENUM_VALUE3NAME "City"

Definition at line 35 of file requirements.h.

◆ SPECENUM_VALUE4

#define SPECENUM_VALUE4 REQ_RANGE_TRADEROUTE

Definition at line 36 of file requirements.h.

◆ SPECENUM_VALUE4NAME

#define SPECENUM_VALUE4NAME "Traderoute"

Definition at line 37 of file requirements.h.

◆ SPECENUM_VALUE5

#define SPECENUM_VALUE5 REQ_RANGE_CONTINENT

Definition at line 38 of file requirements.h.

◆ SPECENUM_VALUE5NAME

#define SPECENUM_VALUE5NAME "Continent"

Definition at line 39 of file requirements.h.

◆ SPECENUM_VALUE6

#define SPECENUM_VALUE6 REQ_RANGE_PLAYER

Definition at line 40 of file requirements.h.

◆ SPECENUM_VALUE6NAME

#define SPECENUM_VALUE6NAME "Player"

Definition at line 41 of file requirements.h.

◆ SPECENUM_VALUE7

#define SPECENUM_VALUE7 REQ_RANGE_TEAM

Definition at line 42 of file requirements.h.

◆ SPECENUM_VALUE7NAME

#define SPECENUM_VALUE7NAME "Team"

Definition at line 43 of file requirements.h.

◆ SPECENUM_VALUE8

#define SPECENUM_VALUE8 REQ_RANGE_ALLIANCE

Definition at line 44 of file requirements.h.

◆ SPECENUM_VALUE8NAME

#define SPECENUM_VALUE8NAME "Alliance"

Definition at line 45 of file requirements.h.

◆ SPECENUM_VALUE9

#define SPECENUM_VALUE9 REQ_RANGE_WORLD

Definition at line 46 of file requirements.h.

◆ SPECENUM_VALUE9NAME

#define SPECENUM_VALUE9NAME "World"

Definition at line 47 of file requirements.h.

◆ SPECVEC_TAG

#define SPECVEC_TAG requirement

Definition at line 75 of file requirements.h.

◆ SPECVEC_TYPE

#define SPECVEC_TYPE struct requirement

Definition at line 76 of file requirements.h.

◆ universal_is_mentioned_by_requirement

#define universal_is_mentioned_by_requirement	(	preq,
		psource
	)	are_universals_equal(&preq->source, psource)

Definition at line 248 of file requirements.h.

◆ universals_iterate

#define universals_iterate ( _univ_ )

Value:

  {                                                                         \
    enum universals_n _univ_;                                               \
    for (_univ_ = VUT_NONE; _univ_ < VUT_COUNT;                             \
         _univ_ = (enum universals_n)(_univ_ + 1)) {

Definition at line 269 of file requirements.h.

◆ universals_iterate_end

#define universals_iterate_end

Value:

} \

}

Definition at line 275 of file requirements.h.

Typedef Documentation

◆ req_vec_num_in_item

typedef signed char req_vec_num_in_item

req_vec_num_in_item a requirement vectors number in an item.

A ruleset item can have more than one requirement vector. This numbers them. Allows applying a change suggested based on one ruleset item to another ruleset item of the same kind - say to a copy.

Definition at line 143 of file requirements.h.

◆ requirement_vector_by_number

typedef struct requirement_vector*(* requirement_vector_by_number) (const void *parent_item, req_vec_num_in_item number)

Returns a writable pointer to the specified requirement vector in the specified parent item or nullptr if the parent item doesn't have a requirement vector with that requirement vector number.

Parameters

parent_item	the item that should have the requirement vector.
number	the item's requirement vector number.

Returns: a pointer to the specified requirement vector.

Definition at line 153 of file requirements.h.

◆ requirement_vector_namer

typedef const char*(* requirement_vector_namer) (req_vec_num_in_item number)

Returns the name of the specified requirement vector number in the parent item or nullptr if parent items of the kind this function is for don't have a requirement vector with that number.

Parameters

number the requirement vector to name

Returns: the requirement vector name or nullptr.

Definition at line 174 of file requirements.h.

◆ requirement_vector_number

typedef req_vec_num_in_item(* requirement_vector_number) (const void *parent_item, const struct requirement_vector *vec)

Returns the requirement vector number of the specified requirement vector in the specified parent item or -1 if the vector doesn't belong to the parent item.

Parameters

parent_item	the item that may own the vector.
vec	the requirement vector to number.

Returns: the requirement vector number the vector has in the parent item.

Definition at line 153 of file requirements.h.

Enumeration Type Documentation

◆ req_item_found

enum req_item_found

Enumerator
ITF_NO
ITF_YES
ITF_NOT_APPLICABLE

Definition at line 254 of file requirements.h.

Function Documentation

◆ are_reqs_active()

bool are_reqs_active	(	const struct player *	target_player,
		const struct player *	other_player,
		const struct city *	target_city,
		const struct impr_type *	target_building,
		const struct tile *	target_tile,
		const struct unit *	target_unit,
		const struct unit_type *	target_unittype,
		const struct output_type *	target_output,
		const struct specialist *	target_specialist,
		const struct action *	target_action,
		const struct requirement_vector *	reqs,
		const enum req_problem_type	prob_type,
		const enum vision_layer	vision_layer,
		const enum national_intelligence	nintel
	)

Checks the requirement(s) to see if they are active on the given target.

target gives the type of the target (player,city,building,tile) give the exact target

reqs gives the requirement vector. The function returns TRUE only if all requirements are active.

Make sure you give all aspects of the target when calling this function: for instance if you have TARGET_CITY pass the city's owner as the target player as well as the city itself as the target city.

Definition at line 3500 of file requirements.cpp.

Referenced by action_auto_perf_unit_sel(), add_clause(), are_road_reqs_fulfilled(), can_build_base(), can_build_extra(), can_change_to_government(), can_city_build_improvement_direct(), can_city_build_unit_direct(), can_disaster_happen(), can_extra_appear(), can_extra_disappear(), can_remove_extra(), can_unit_do_connect(), city_can_use_specialist(), city_style(), get_target_bonus_effects(), get_tile_infrastructure_set(), get_tile_value(), goods_can_be_provided(), handle_diplomacy_accept_treaty_req(), is_enabler_active(), is_native_tile_to_extra(), is_target_possible(), multiplier_can_be_changed(), player_can_build_extra(), player_can_remove_extra(), player_music_style(), research_invention_set(), sg_special_set(), unit_can_displace_hut(), unit_can_enter_hut(), and unit_enter_hut().

◆ are_requirements_contradictions()

bool are_requirements_contradictions	(	const struct requirement *	req1,
		const struct requirement *	req2
	)

Returns TRUE if req1 and req2 contradicts each other.

TODO: If information about what entity each requirement type will be evaluated against is passed it will become possible to detect stuff like that an unclaimed tile contradicts all DiplRel requirements against it.

Definition at line 1215 of file requirements.cpp.

Referenced by does_req_contradicts_reqs(), req_vec_first_contradiction_in_vec(), and req_vec_get_first_contradiction().

◆ are_requirements_equal()

bool are_requirements_equal	(	const struct requirement *	req1,
		const struct requirement *	req2
	)

Returns TRUE if req1 and req2 are equal.

Does not care if one is quiet and the other not.

Definition at line 1131 of file requirements.cpp.

Referenced by req_edit::incoming_rec_vec_change(), is_req_in_vec(), and req_vec_change_apply().

◆ are_universals_equal()

bool are_universals_equal	(	const struct universal *	psource1,
		const struct universal *	psource2
	)

Return TRUE iff the two sources are equivalent.

Note this isn't the same as an == or memcmp check.

Definition at line 3887 of file requirements.cpp.

Referenced by are_requirements_equal(), are_requirements_opposites(), are_worklists_equal(), change_build_target(), city_set_queue(), clipboard_send_production_packet(), handle_city_change(), handle_city_info(), insert_allows_single(), and ruledit_gui::open_effect_edit().

◆ does_req_contradicts_reqs()

bool does_req_contradicts_reqs	(	const struct requirement *	req,
		const struct requirement_vector *	vec
	)

Returns TRUE if the given requirement contradicts the given requirement vector.

Definition at line 1307 of file requirements.cpp.

Referenced by action_enabler_suggest_repair_oblig(), city_production_caravan_shields_init(), local_dipl_rel_action_cache_set(), and utype_may_act_tgt_city_tile().

◆ is_req_active()

bool is_req_active	(	const struct player *	target_player,
		const struct player *	other_player,
		const struct city *	target_city,
		const struct impr_type *	target_building,
		const struct tile *	target_tile,
		const struct unit *	target_unit,
		const struct unit_type *	target_unittype,
		const struct output_type *	target_output,
		const struct specialist *	target_specialist,
		const struct action *	target_action,
		const struct requirement *	req,
		const enum req_problem_type	prob_type,
		const enum vision_layer	vision_layer,
		const enum national_intelligence	nintel
	)

Checks the requirement to see if it is active on the given target.

target gives the type of the target (player,city,building,tile) give the exact target req gives the requirement itself

Make sure you give all aspects of the target when calling this function: for instance if you have TARGET_CITY pass the city's owner as the target player as well as the city itself as the target city.

Definition at line 3111 of file requirements.cpp.

Referenced by adjust_improvement_wants_by_effects(), adjust_wants_for_reqs(), adv_units_ruleset_init(), are_reqs_active(), can_city_build_improvement_later(), can_player_build_improvement_direct(), can_player_build_improvement_later(), can_player_build_unit_direct(), city_landlocked_sell_coastal_improvements(), dai_find_source_building(), dai_gov_value(), dai_tech_effect_values(), dai_wants_defender_against(), get_potential_improvement_bonus(), improvement_obsolete(), is_effect_prevented(), reqs_may_activate(), utype_needs_improvement(), and worklist_item_postpone_req_vec().

◆ is_req_in_vec()

bool is_req_in_vec	(	const struct requirement *	req,
		const struct requirement_vector *	vec
	)

Returns TRUE iff the requirement vector vec contains the requirement req.

Definition at line 3611 of file requirements.cpp.

Referenced by tgt_citytile_act_cache_set(), and unit_state_action_cache_set().

◆ is_req_unchanging()

bool is_req_unchanging ( const struct requirement * req )

Return TRUE if this is an "unchanging" requirement.

This means that if a target can't meet the requirement now, it probably won't ever be able to do so later. This can be used to do requirement filtering when checking if a target may "eventually" become available.

Note this isn't absolute. Returning TRUE here just means that the requirement probably can't be met. In some cases (particularly terrains) it may be wrong.

Definition at line 3539 of file requirements.cpp.

Referenced by can_city_build_improvement_later(), can_player_build_improvement_later(), reqs_may_activate(), and sanity_check_ruleset_data().

◆ req_from_str()

struct requirement req_from_str	(	const char *	type,
		const char *	range,
		bool	survives,
		bool	present,
		bool	quiet,
		const char *	value
	)

Parse a requirement type and value string into a requirement structure.

Returns the invalid element for enum universal_n on error. Passing in a nullptr type is considered VUT_NONE (not an error).

Pass this some values like "Building", "Factory".

Definition at line 804 of file requirements.cpp.

Referenced by effect_list_compat_cb(), load_ruleset_cities(), lookup_req_list(), rscompat_old_slow_invasions_3_1(), rscompat_optional_capabilities(), rscompat_postprocess(), and rscompat_vision_effect_cb().

◆ req_from_values()

struct requirement req_from_values	(	int	type,
		int	range,
		bool	survives,
		bool	present,
		bool	quiet,
		int	value
	)

Set the values of a req from serializable integers.

This is the opposite of req_get_values.

Definition at line 804 of file requirements.cpp.

Referenced by req_edit::add_now(), dio_get_requirement_raw(), effect_to_enabler(), hard_code_oblig_hard_reqs(), hard_code_oblig_hard_reqs_ruleset(), load_action_auto_uflag_block(), load_ruleset_units(), rscompat_auto_attack_3_1(), rscompat_migrate_eft_nation_intelligence(), rscompat_old_slow_invasions_3_1(), rscompat_postprocess(), and send_ruleset_techs().

◆ req_get_values()

void req_get_values	(	const struct requirement *	req,
		int *	type,
		int *	range,
		bool *	survives,
		bool *	present,
		bool *	quiet,
		int *	value
	)

Return the value of a req as a serializable integer.

This is the opposite of req_set_value.

Definition at line 1117 of file requirements.cpp.

Referenced by dio_put_requirement_raw().

◆ req_to_fstring()

QString req_to_fstring ( const struct requirement * req )

Returns the given requirement as a formatted string ready for printing.

Does not care about the 'quiet' property.

Definition at line 804 of file requirements.cpp.

Referenced by effect_list_sanity_cb(), enabler_first_self_contradiction(), enabler_tile_tgt_local_diplrel_implies_claimed(), req_vec_change_translation(), req_vec_get_first_contradiction(), sanity_check_ruleset_data(), and save_action_auto_uflag_block().

◆ req_vec_change_apply()

bool req_vec_change_apply	(	const struct req_vec_change *	modification,
		requirement_vector_by_number	getter,
		const void *	parent_item
	)

Returns TRUE iff the specified requirement vector modification was successfully applied to the specified target requirement vector.

Parameters

modification	the requirement vector change
getter	a function that returns a pointer to the requirement vector the change should be applied to given a ruleset item and the vectors number in the item.
parent_item	the item to apply the change to.

Returns: if the specified modification was successfully applied

Definition at line 3741 of file requirements.cpp.

Referenced by req_vec_fix::apply_solution(), and rscompat_enabler_add_obligatory_hard_reqs().

◆ req_vec_change_translation()

const char* req_vec_change_translation	(	const struct req_vec_change *	change,
		const requirement_vector_namer	namer
	)

Returns the specified requirement vector change as a translated string ready for use in the user interface.

N.B.: The returned string is static, so every call to this function overwrites the previous.

Parameters

change	the requirement vector change
namer	a function that returns a description of the vector to change for the item the vector belongs to.

Returns: the specified requirement vector change

Definition at line 3673 of file requirements.cpp.

Referenced by req_vec_fix::apply_solution(), req_vec_fix_problem::req_vec_fix_problem(), and rscompat_enabler_add_obligatory_hard_reqs().

◆ req_vec_get_first_contradiction()

struct req_vec_problem* req_vec_get_first_contradiction	(	const struct requirement_vector *	vec,
		requirement_vector_number	get_num,
		const void *	parent_item
	)

Returns the first self contradiction found in the specified requirement vector with suggested solutions or nullptr if no contradiction was found.

It is the responsibility of the caller to free the suggestion when it is done with it.

Parameters

vec	the requirement vector to look in.
get_num	function that returns the requirement vector's number in the parent item.
parent_item	the item that owns the vector.

Returns: the first self contradiction found.

Definition at line 3833 of file requirements.cpp.

Referenced by action_enabler_suggest_repair(), and sanity_check_req_vec().

◆ req_vec_problem_free()

void req_vec_problem_free ( struct req_vec_problem * issue )

De-allocates resources associated with the given requirement vector problem.

Parameters

issue the no longer needed problem.

Definition at line 3813 of file requirements.cpp.

Referenced by req_vec_fix::refresh(), rscompat_enabler_add_obligatory_hard_reqs(), sanity_check_req_vec(), and req_vec_fix::~req_vec_fix().

◆ req_vec_problem_new()

struct req_vec_problem* req_vec_problem_new	(	int	num_suggested_solutions,
		const char *	descr,
			...
	)

Returns a new requirement vector problem with the specified number of suggested solutions and the specified description.

The suggestions are added by the caller. The description

Parameters

num_suggested_solutions	the number of suggested solutions.
descr	the description of the problem as a format string

Returns: the new requirement vector problem.

Definition at line 3779 of file requirements.cpp.

Referenced by action_enabler_suggest_improvement(), action_enabler_suggest_repair_oblig(), enabler_first_self_contradiction(), enabler_tile_tgt_local_diplrel_implies_claimed(), and req_vec_get_first_contradiction().

◆ req_vec_vector_number()

req_vec_num_in_item req_vec_vector_number	(	const void *	parent_item,
		const struct requirement_vector *	vec
	)

Returns the requirement vector number of the specified requirement vector in the specified requirement vector.

Parameters

parent_item	the item that may own the vector.
vec	the requirement vector to number.

Returns: the requirement vector number the vector has in the parent item.

Definition at line 3652 of file requirements.cpp.

Referenced by sanity_check_req_vec().

◆ req_vec_wants_type()

bool req_vec_wants_type	(	const struct requirement_vector *	reqs,
		enum universals_n	kind
	)

Returns TRUE iff the specified requirement vector has a positive requirement of the specified requirement type.

Parameters

reqs	the requirement vector to look in
kind	the requirement type to look for

Definition at line 3631 of file requirements.cpp.

Referenced by city_production_caravan_shields_init().

◆ requirement_kind_ereq()

int requirement_kind_ereq	(	const int	value,
		const enum req_range	range,
		const bool	present,
		const int	max_value
	)

Returns (the position of) the given requirement's enumerator in the enumeration of all possible requirements of its requirement kind.

Note: Since this isn't used for any requirement type that supports surviving requirements those aren't supported. Add support if a user appears.

Definition at line 4932 of file requirements.cpp.

◆ sv_universal_fulfills_requirements()

bool sv_universal_fulfills_requirements	(	bool	check_necessary,
		const struct requirement_vector *	reqs,
		const struct universal	source
	)

Version of universal_fulfills_requirements that takes the universal by value.

Definition at line 4572 of file requirements.cpp.

◆ universal_build_shield_cost()

int universal_build_shield_cost	(	const struct city *	pcity,
		const struct universal *	target
	)

Return the number of shields it takes to build this universal.

Definition at line 4455 of file requirements.cpp.

Referenced by city_production_build_shield_cost(), city_turns_to_build(), and polished_citybar_painter::paint().

◆ universal_by_number()

struct universal universal_by_number	(	const enum universals_n	kind,
		const int	value
	)

Combine values into a universal structure.

This is for serialization and is the opposite of universal_extraction(). FIXME: ensure that every caller checks error return!

Definition at line 70 of file requirements.cpp.

Referenced by dio_get_worklist_raw(), effect_list_compat_cb(), handle_city_change(), and handle_city_info().

◆ universal_by_rule_name()

struct universal universal_by_rule_name	(	const char *	kind,
		const char *	value
	)

Parse requirement type (kind) and value strings into a universal structure.

Passing in a nullptr type is considered VUT_NONE (not an error).

Pass this some values like "Building", "Factory". FIXME: ensure that every caller checks error return!

Definition at line 41 of file requirements.cpp.

Referenced by global_worklists_build(), sg_load_player_city(), and worklist_load().

◆ universal_extraction()

void universal_extraction	(	const struct universal *	source,
		int *	kind,
		int *	value
	)

Extract universal structure into its components for serialization; the opposite of universal_by_number().

Definition at line 681 of file requirements.cpp.

Referenced by get_req_source_effects(), req_get_values(), help_widget::set_topic_building(), and universal_value_cb().

◆ universal_found_functions_init()

void universal_found_functions_init ( )

Initialise universal_found_function array.

Definition at line 4908 of file requirements.cpp.

Referenced by game_init().

◆ universal_fulfills_requirement()

enum req_item_found universal_fulfills_requirement	(	const struct requirement *	preq,
		const struct universal *	source
	)

Will the universal 'source' fulfill this requirement?

Definition at line 4496 of file requirements.cpp.

Referenced by action_found(), and effect_value_from_universals().

◆ universal_fulfills_requirements()

bool universal_fulfills_requirements	(	bool	check_necessary,
		const struct requirement_vector *	reqs,
		const struct universal *	source
	)

Will the universal 'source' fulfill the requirements in the list? If 'check_necessary' is FALSE: are there no requirements that 'source' would actively prevent the fulfilment of? If 'check_necessary' is TRUE: does 'source' help the requirements to be fulfilled? (NB 'source' might not be the only source of its type that would be sufficient; for instance, if 'source' is a specific terrain type, we can return TRUE even if the requirement is only for something vague like a TerrainClass.)

Definition at line 4534 of file requirements.cpp.

Referenced by action_univs_not_blocking(), help_widget::add_extras_of_act_for_terrain(), effect_cumulative_max(), effect_cumulative_min(), helptext_building(), and sv_universal_fulfills_requirements().

◆ universal_is_mentioned_by_requirements()

bool universal_is_mentioned_by_requirements	(	const struct requirement_vector *	reqs,
		const struct universal *	psource
	)

Returns TRUE iff the universal 'psource' is directly mentioned by any of the requirements in 'reqs'.

Definition at line 4496 of file requirements.cpp.

Referenced by effect_handle_split_universal(), effect_list_fill_cb(), effect_list_universal_needed_cb(), and is_universal_needed().

◆ universal_is_relevant_to_requirement()

bool universal_is_relevant_to_requirement	(	const struct requirement *	req,
		const struct universal *	source
	)

Returns TRUE iff the specified universal is relevant to fulfilling the specified requirement.

Definition at line 4583 of file requirements.cpp.

Referenced by helptext_building().

◆ universal_name_translation()

const char* universal_name_translation	(	const struct universal *	psource,
		char *	buf,
		size_t	bufsz
	)

Make user-friendly text for the source.

The text is put into a user buffer which is also returned. This should be short, as it's used in lists like "Aqueduct+Size 8" when explaining a calculated value. It just needs to be enough to remind the player of rules they already know, not a complete explanation (use insert_requirement() for that).

Definition at line 4145 of file requirements.cpp.

Referenced by apply_disaster(), city_production_name_translation(), clipboard_copy_production(), diplomat_sabotage(), do_unit_strike_city_production(), city_widget::gen_production_labels(), get_city_mapview_production(), get_effect_req_text(), insert_allows_single(), manual_command(), req_edit::refresh(), req_text_insert(), and help_widget::set_topic_building().

◆ universal_number()

int universal_number ( const struct universal * source )

Return the universal number of the constituent.

Definition at line 691 of file requirements.cpp.

Referenced by city_change_production(), clipboard_send_production_packet(), dio_put_worklist_raw(), package_city(), and universal_extraction().

◆ universal_replace_in_req_vec()

bool universal_replace_in_req_vec	(	struct requirement_vector *	reqs,
		const struct universal *	to_replace,
		const struct universal *	replacement
	)

Replaces all instances of the universal to_replace with replacement in the requirement vector reqs and returns TRUE iff any requirements were replaced.

Definition at line 4474 of file requirements.cpp.

Referenced by effect_handle_split_universal().

◆ universal_rule_name()

const char* universal_rule_name ( const struct universal * psource )

Return the (untranslated) rule name of the universal.

You don't have to free the return pointer.

Definition at line 4003 of file requirements.cpp.

Referenced by define_orig_production_values(), effect_list_sanity_cb(), global_worklist_save(), global_worklists_unbuild(), req_from_str(), save_reqs_vector(), save_units_ruleset(), sg_save_player_cities(), and worklist_save().

◆ universal_type_rule_name()

const char* universal_type_rule_name ( const struct universal * psource )

Return untranslated name of the universal source name.

Definition at line 4447 of file requirements.cpp.

Referenced by global_worklist_save(), global_worklists_unbuild(), req_from_str(), sanity_check_req_set(), sg_save_player_cities(), universal_fulfills_requirements(), and worklist_save().

◆ universal_value_from_str()

void universal_value_from_str	(	struct universal *	source,
		const char *	value
	)

Parse requirement value strings into a universal structure.

Definition at line 70 of file requirements.cpp.

Referenced by req_edit::univ_value_edit(), and req_edit::univ_value_enum_menu().

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ req_range_iterate

◆ req_range_iterate_end

◆ requirement_diplrel_ereq

◆ requirement_fulfilled_by_government

◆ requirement_fulfilled_by_improvement

◆ requirement_fulfilled_by_nation

◆ requirement_fulfilled_by_terrain

◆ requirement_fulfilled_by_unit_class

◆ requirement_fulfilled_by_unit_type

◆ requirement_needs_improvement

◆ requirement_vector_iterate

◆ requirement_vector_iterate_end

◆ SPECENUM_COUNT [1/2]

◆ SPECENUM_COUNT [2/2]

◆ SPECENUM_NAME [1/2]

◆ SPECENUM_NAME [2/2]

◆ SPECENUM_VALUE0 [1/2]

◆ SPECENUM_VALUE0 [2/2]

◆ SPECENUM_VALUE0NAME [1/2]

◆ SPECENUM_VALUE0NAME [2/2]

◆ SPECENUM_VALUE1 [1/2]

◆ SPECENUM_VALUE1 [2/2]

◆ SPECENUM_VALUE1NAME [1/2]

◆ SPECENUM_VALUE1NAME [2/2]

◆ SPECENUM_VALUE2

◆ SPECENUM_VALUE2NAME

◆ SPECENUM_VALUE3

◆ SPECENUM_VALUE3NAME

◆ SPECENUM_VALUE4

◆ SPECENUM_VALUE4NAME

◆ SPECENUM_VALUE5

◆ SPECENUM_VALUE5NAME

◆ SPECENUM_VALUE6

◆ SPECENUM_VALUE6NAME

◆ SPECENUM_VALUE7

◆ SPECENUM_VALUE7NAME

◆ SPECENUM_VALUE8

◆ SPECENUM_VALUE8NAME

◆ SPECENUM_VALUE9

◆ SPECENUM_VALUE9NAME

◆ SPECVEC_TAG

◆ SPECVEC_TYPE

◆ universal_is_mentioned_by_requirement

◆ universals_iterate

◆ universals_iterate_end

Typedef Documentation

◆ req_vec_num_in_item

◆ requirement_vector_by_number

◆ requirement_vector_namer

◆ requirement_vector_number

Enumeration Type Documentation

◆ req_item_found

Function Documentation

◆ are_reqs_active()

◆ are_requirements_contradictions()

◆ are_requirements_equal()

◆ are_universals_equal()

◆ does_req_contradicts_reqs()

◆ is_req_active()

◆ is_req_in_vec()

◆ is_req_unchanging()

◆ req_from_str()

◆ req_from_values()

◆ req_get_values()

◆ req_to_fstring()

◆ req_vec_change_apply()

◆ req_vec_change_translation()

◆ req_vec_get_first_contradiction()

◆ req_vec_problem_free()

◆ req_vec_problem_new()

◆ req_vec_vector_number()

◆ req_vec_wants_type()

◆ requirement_kind_ereq()

◆ sv_universal_fulfills_requirements()