Classes
struct	t_terrain
	A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separated by a caret and each group consists of 2 to 4 characters if no second layer is defined it is stored as 0xFFFFFFFF, if the second layer is empty (needed for matching) the layer has the value 0. More...
struct	t_match
	This structure can be used for matching terrain strings. More...
struct	coordinate
	Contains an x and y coordinate used for starting positions in maps. More...
struct	error
Typedefs
typedef Uint32	t_layer
typedef std::vector< t_terrain >	t_list
typedef std::vector < std::vector< t_terrain > >	t_map
Functions
size_t	max_map_size ()
	Return the maximum allowed map size (in either dimension), the maximum map area is, therefore, this value squared.
static t_layer	get_layer_mask_ (t_layer terrain)
	Get the mask for a single layer.
static t_terrain	get_mask_ (const t_terrain &terrain)
	Gets a mask for a terrain, this mask is used for wildcard matching.
static t_layer	string_to_layer_ (const std::string &str)
	Converts a string to a layer.
static t_terrain	string_to_number_ (std::string str, int &start_position, const t_layer filler)
	Converts a terrain string to a number.
static t_terrain	string_to_number_ (const std::string &str, const t_layer filler=NO_LAYER)
static std::string	number_to_string_ (t_terrain terrain, const int start_position=-1)
	Converts a terrain number to a string.
static t_terrain	string_to_builder_number_ (std::string str)
	Converts a terrain string to a number for the builder.
const t_match	ALL_FORESTS ("F,^F*")
t_terrain	read_terrain_code (const std::string &str, const t_layer filler=NO_LAYER)
	Reads a single terrain from a string.
std::string	write_terrain_code (const t_terrain &tcode)
	Writes a single terrain code to a string.
t_list	read_list (const std::string &str, const t_layer filler=NO_LAYER)
	Reads a list of terrains from a string, when reading the.
std::string	write_list (const t_list &list)
	Writes a list of terrains to a string, only writes the new format.
t_map	read_game_map (const std::string &str, std::map< int, coordinate > &starting_positions)
	Reads a gamemap string into a 2D vector.
std::string	write_game_map (const t_map &map, std::map< int, coordinate > starting_positions=std::map< int, coordinate >())
	Write a gamemap in to a vector string.
bool	terrain_matches (const t_terrain &src, const t_terrain &dest)
	Tests whether a specific terrain matches an expression, for matching rules see above.
bool	terrain_matches (const t_terrain &src, const t_list &dest)
	Tests whether a specific terrain matches a list of expressions.
bool	terrain_matches (const t_terrain &src, const t_match &dest)
	Tests whether a certain terrain matches a list of expressions, for matching rules see above.
bool	has_wildcard (const t_terrain &tcode)
	Tests whether a terrain code contains a wildcard.
bool	has_wildcard (const t_list &list)
	Tests whether a terrain-code list contains at least one item with a wildcard.
t_map	read_builder_map (const std::string &str)
	Reads a builder map.
bool	operator< (const t_terrain &a, const t_terrain &b)
bool	operator== (const t_terrain &a, const t_terrain &b)
bool	operator!= (const t_terrain &a, const t_terrain &b)
t_terrain	operator& (const t_terrain &a, const t_terrain &b)
t_terrain	operator\| (const t_terrain &a, const t_terrain &b)
std::ostream &	operator<< (std::ostream &s, const t_terrain &a)
Variables
const t_terrain	OFF_MAP_USER = string_to_number_("_off^_usr")
const t_terrain	VOID_TERRAIN = string_to_number_("_s")
const t_terrain	FOGGED = string_to_number_("_f")
const t_terrain	HUMAN_CASTLE = string_to_number_("Ch")
const t_terrain	HUMAN_KEEP = string_to_number_("Kh")
const t_terrain	SHALLOW_WATER = string_to_number_("Ww")
const t_terrain	DEEP_WATER = string_to_number_("Wo")
const t_terrain	GRASS_LAND = string_to_number_("Gg")
const t_terrain	FOREST = string_to_number_("Gg^Ff")
const t_terrain	MOUNTAIN = string_to_number_("Mm")
const t_terrain	HILL = string_to_number_("Hh")
const t_terrain	CAVE_WALL = string_to_number_("Xu")
const t_terrain	CAVE = string_to_number_("Uu")
const t_terrain	UNDERGROUND_VILLAGE = string_to_number_("Uu^Vu")
const t_terrain	DWARVEN_CASTLE = string_to_number_("Cud")
const t_terrain	DWARVEN_KEEP = string_to_number_("Kud")
const t_terrain	PLUS = string_to_number_("+")
const t_terrain	MINUS = string_to_number_("-")
const t_terrain	NOT = string_to_number_("!")
const t_terrain	STAR = string_to_number_("*")
const t_terrain	BASE = string_to_number_("_bas")
const t_match	ALL_HILLS ("!,^V,!,H*")
const t_match	ALL_MOUNTAINS ("!,^V,!,M*")
const t_match	ALL_SWAMPS ("!,^V,^B,!,S*")
const t_layer	WILDCARD = 0x2A000000
const t_layer	NO_LAYER = 0xFFFFFFFF
const t_terrain	NONE_TERRAIN = t_terrain()
const t_match	ALL_FORESTS
const t_layer	TB_STAR = '*' << 24
const t_layer	TB_DOT = '.' << 24

Typedef Documentation

typedef Uint32 t_translation::t_layer

Definition at line 35 of file terrain_translation.hpp.

typedef std::vector<t_terrain> t_translation::t_list

Definition at line 74 of file terrain_translation.hpp.

typedef std::vector<std::vector<t_terrain> > t_translation::t_map

Definition at line 75 of file terrain_translation.hpp.

Function Documentation

const t_match t_translation::ALL_FORESTS	(	"F*	,
		^F "
	)

t_layer t_translation::get_layer_mask_ ( t_layer terrain ) [inline, static]

Get the mask for a single layer.

Parameters:

terrain

1 layer of a terrain, might have a wildcard.

Returns:: Mask for that layer.

Definition at line 673 of file terrain_translation.cpp.

Referenced by get_mask_().

Here is the caller graph for this function:

static t_terrain t_translation::get_mask_ ( const t_terrain & terrain ) [static]

Gets a mask for a terrain, this mask is used for wildcard matching.

Parameters:

terrain

The terrain which might have a wildcard.

Returns:: The mask for this terrain.

Definition at line 698 of file terrain_translation.cpp.

References t_translation::t_terrain::base, get_layer_mask_(), NO_LAYER, and t_translation::t_terrain::overlay.

Referenced by t_translation::t_match::t_match().

Here is the call graph for this function:

Here is the caller graph for this function:

bool t_translation::has_wildcard ( const t_terrain & tcode )

Tests whether a terrain code contains a wildcard.

Parameters:

tcode

the terrain code to test for a wildcard

Returns:: true if wildcard found, else false

bool t_translation::has_wildcard ( const t_list & list )

Tests whether a terrain-code list contains at least one item with a wildcard.

Parameters:

list

the list to test for a wildcard

Returns:: true if a wildcard found, else false

size_t t_translation::max_map_size ( )

Return the maximum allowed map size (in either dimension), the maximum map area is, therefore, this value squared.

static std::string t_translation::number_to_string_	(	t_terrain	terrain,
		const int	start_position = `-1`
	)			`[static]`

Converts a terrain number to a string.

Parameters:

	terrain	The terrain number to convert.
	start_position	The starting position, if smaller than 0 it's ignored else it's written.
	min_size	Padds the results with spaces if required, until the result has a length of min_size.

Returns:: The converted string, if no starting position given it's padded to 4 chars else padded to 7 chars.

Definition at line 783 of file terrain_translation.cpp.

References t_translation::t_terrain::base, NO_LAYER, t_translation::t_terrain::overlay, and str_cast().

Here is the call graph for this function:

bool t_translation::operator!=	(	const t_terrain &	a,
		const t_terrain &	b
	)			`[inline]`

Definition at line 63 of file terrain_translation.hpp.

References t_translation::t_terrain::base, and t_translation::t_terrain::overlay.

t_terrain t_translation::operator&	(	const t_terrain &	a,
		const t_terrain &	b
	)			`[inline]`

Definition at line 66 of file terrain_translation.hpp.

References t_translation::t_terrain::base, and t_translation::t_terrain::overlay.

bool t_translation::operator<	(	const t_terrain &	a,
		const t_terrain &	b
	)			`[inline]`

Definition at line 57 of file terrain_translation.hpp.

References t_translation::t_terrain::base, and t_translation::t_terrain::overlay.

std::ostream& t_translation::operator<<	(	std::ostream &	s,
		const t_terrain &	a
	)			`[inline]`

Definition at line 177 of file terrain_translation.hpp.

References write_terrain_code().

Here is the call graph for this function:

bool t_translation::operator==	(	const t_terrain &	a,
		const t_terrain &	b
	)			`[inline]`

Definition at line 60 of file terrain_translation.hpp.

References t_translation::t_terrain::base, and t_translation::t_terrain::overlay.

t_terrain t_translation::operator\|	(	const t_terrain &	a,
		const t_terrain &	b
	)			`[inline]`

Definition at line 69 of file terrain_translation.hpp.

References t_translation::t_terrain::base, and t_translation::t_terrain::overlay.

t_map t_translation::read_builder_map ( const std::string & str )

Reads a builder map.

A builder map differs a great deal from a normal map, hence the different functions.

Parameters:

str

The map data, a terrain letter is either a * or a . or a number as anchor. The star or dot are stored in the base part of the terrain and the anchor in the overlay part. If more letters are allowed as special case they will be stored in the base part. Anchor 0 is no anchor.

Returns:: A 2D vector with the data found the vector data is stored like result[y][x] where x the column number is and y the row number.

Referenced by terrain_builder::parse_mapstring().

Here is the caller graph for this function:

t_map t_translation::read_game_map	(	const std::string &	str,
		std::map< int, coordinate > &	starting_positions
	)

Reads a gamemap string into a 2D vector.

Parameters:

str

A string containing the gamemap, the following rules are stated for a gamemap: * The map is square * The map can be prefixed with one or more empty lines, these lines are ignored * The map can be postfixed with one or more empty lines, these lines are ignored * Every end of line can be followed by one or more empty lines, these lines are ignored.

Deprecated:: NOTE it's deprecated to use this feature. * Terrain strings are separated by comma's or an end of line symbol, for the last terrain string in the row. For readability it's allowed to pad strings with either spaces or tab, however the tab is deprecated. * A terrain string contains either a terrain or a terrain and starting loction. The following format is used [S ]T S = starting location a positive non-zero number T = terrain code (see read_terrain_code)

Parameters:

starting_positions

This parameter will be filled with the starting locations found. Starting locations can only occur once if multiple definitions occur of the same position only the last is stored. The returned value is a map: * first the starting locations * second a coordinate structure where the location was found

Returns:: A 2D vector with the terrains found the vector data is stored like result[x][y] where x the column number is and y the row number.

Referenced by gamemap::read().

Here is the caller graph for this function:

t_list t_translation::read_list	(	const std::string &	str,
		const t_layer	filler = `NO_LAYER`
	)

Reads a list of terrains from a string, when reading the.

Parameters:

	str	A string with one or more terrain codes (see read_terrain_code)
	filler	If there's no layer, this value will be used as the second layer

Returns:: A vector which contains the terrain codes found in the string

Referenced by default_generate_map(), preferences::manager::manager(), gamemap::overlay(), place_village(), placing_score(), and terrain_type::terrain_type().

Here is the caller graph for this function:

t_terrain t_translation::read_terrain_code	(	const std::string &	str,
		const t_layer	filler = `NO_LAYER`
	)

Reads a single terrain from a string.

Parameters:

str

The string which should contain 1 terrain code; the new format of a terrain code is 2 to 4 characters in the set

	 *				[a-Z][A-Z]/|\_
	 *

The underscore is intended for internal use. Other letters and characters are not validated but users of these letters can get nasty surprices. The * is used as wildcard in some cases. The terrain code can be two groups separated by a caret, the first group is the base terrain, the second the overlay terrain.

filler

if there's no layer this value will be used as the second layer

Returns:: A single terrain code

Referenced by default_generate_map(), intf_get_terrain_info(), intf_set_terrain(), intf_unit_defense(), and intf_unit_movement_cost().

Here is the caller graph for this function:

static t_terrain t_translation::string_to_builder_number_ ( std::string str ) [static]

Converts a terrain string to a number for the builder.

The translation rules differ from the normal conversion rules

Parameters:

str

The terrain string.

Returns:: Number for the builder map.

Definition at line 829 of file terrain_translation.cpp.

References lexical_cast_default(), and schema_validation::number.

Here is the call graph for this function:

static t_layer t_translation::string_to_layer_ ( const std::string & str ) [static]

Converts a string to a layer.

Parameters:

str

The terrain string to convert, but needs to be sanitized so no spaces and only the terrain to convert.

Returns:: The converted layer.

Definition at line 707 of file terrain_translation.cpp.

References _, NO_LAYER, and VALIDATE.

static t_terrain t_translation::string_to_number_	(	const std::string &	str,
		const t_layer	filler = `NO_LAYER`
	)			`[static]`

Definition at line 736 of file terrain_translation.cpp.

References string_to_number_().

Here is the call graph for this function:

static t_terrain t_translation::string_to_number_	(	std::string	str,
		int &	start_position,
		const t_layer	filler
	)			`[static]`

Converts a terrain string to a number.

Parameters:

	str	The terrain string with an optional number.
	start_position	Returns the start_position, the caller should set it on -1 and it's only changed it there is a starting position found.
	filler	If the terrain has only 1 layer then the filler will be used as the second layer.

Returns:: The terrain code found in the string if no valid terrain is found VOID will be returned.

Definition at line 741 of file terrain_translation.cpp.

References t_translation::t_terrain::base, lexical_cast(), NO_LAYER, NOT, t_translation::t_terrain::overlay, STAR, VOID_TERRAIN, and WILDCARD.

Referenced by string_to_number_().

Here is the call graph for this function:

Here is the caller graph for this function:

bool t_translation::terrain_matches	(	const t_terrain &	src,
		const t_list &	dest
	)

Tests whether a specific terrain matches a list of expressions.

The list can use wildcard matching with *. It also has an inversion function. When a ! is found the result of the match is inverted. The matching stops at the first match (regardless of the ! found) the data is match from start to end.

Example: Ww, W* does match and returns true Ww, {!, W*} does match and returns false (due to the !) WW, Ww doesn't match and return false

Multilayer rules: If a terrain has multiple layers, each layer will be matched separately, returning true only if both layers match.

Example: A*^* matches Abcd but also Abcd^Abcd A*^ matches Abcd but *not* Abcd^Abcd A*^Abcd does not match Abcd but matches Abcd^Abcd

Note: If an expression doesn't specify a second layer (i.e. it contains no caret) the second layer will be filled in with a default value (See read_terrain_code and read_list).

In the terrain building code, the second layer will default to the wildcard, so both A* and A*^* will match Abcd^Abcd

Parameters:

	src	the value to match (may not contain wildcards)
	dest	the list of expressions to match against

Returns:: the result of the match (depending on the !'s)

bool t_translation::terrain_matches	(	const t_terrain &	src,
		const t_terrain &	dest
	)

Tests whether a specific terrain matches an expression, for matching rules see above.

Parameters:

	src	the value to match (may not contain wildcards)
	dest	the expression to match against

Returns:: the result of the match (depending on the !'s)

Referenced by default_generate_map(), flood_name(), terrain_filter::match_internal(), unit_animation::matches(), and gamemap::overlay().

Here is the caller graph for this function:

bool t_translation::terrain_matches	(	const t_terrain &	src,
		const t_match &	dest
	)

Tests whether a certain terrain matches a list of expressions, for matching rules see above.

The matching requires some bit mask which impose a certain overhead. This version uses a cache to cache the masks so if a list needs to be matched often this version is preferred.

Parameters:

	src	the value to match (may not contain wildcards)
	dest	the cached list of expressions to match against

Returns:: the result of the match (depending on the !'s)

std::string t_translation::write_game_map	(	const t_map &	map,
		std::map< int, coordinate >	starting_positions = `std::map< int, coordinate >()`
	)

Write a gamemap in to a vector string.

Parameters:

	map	A terrain vector, as returned from read_game_map
	starting_positions	A starting positions map, as returned from read_game_map

Returns:: A terrain string which can be read with read_game_map. For readability the map is padded to groups of 12 chars, followed by a comma and space.

Referenced by cave_map_generator::create_scenario(), output_map(), and gamemap::write().

Here is the caller graph for this function: