}

}

void ResetCompanyLivery(Company *c)

{

	for (LiveryScheme scheme = LS_BEGIN; scheme < LS_END; scheme++) {

	}

}

void DrawCatenaryOnBridge(const TileInfo *ti)

{

	TileIndex end = GetSouthernBridgeEnd(ti->tile);

	}

}

void DrawCatenary(const TileInfo *ti)

{

	switch (GetTileType(ti->tile)) {

	return HasCatenary(rt) && !IsInvisibilitySet(TO_CATENARY) && !_settings_game.vehicle.disable_elrails;

}

void DrawCatenary(const TileInfo *ti);

void DrawCatenaryOnTunnel(const TileInfo *ti);

void DrawCatenaryOnBridge(const TileInfo *ti);

CommandCost CheckTileOwnership(TileIndex tile);

/* misc functions */

void MarkTileDirtyByTile(TileIndex tile);

void ShowCostOrIncomeAnimation(int x, int y, int z, Money cost);

	_video_driver->MakeDirty(left, top, right - left, bottom - top);

}

 * Repaints the rectangle blocks which are marked as 'dirty'.

 *

 * @see SetDirtyBlocks

	_invalid_rect.bottom = 0;

}

 * This function extends the internal _invalid_rect rectangle as it

 * now contains the rectangle defined by the given parameters. Note

 * the point (0,0) is top left.

	} while (--height != 0);

}

 * This function mark the whole screen as dirty. This results in repainting

 * the whole screen. Use this with care as this function will break the

 * idea about marking only parts of the screen as 'dirty'.

 */

void MarkWholeScreenDirty()

{

Dimension GetStringMultiLineBoundingBox(StringID str, const Dimension &suggestion);

void LoadStringWidthTable();

void DrawDirtyBlocks();

void SetDirtyBlocks(int left, int top, int right, int bottom);

void MarkWholeScreenDirty();

void GfxInitPalettes();

	return num;

}

uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e);

static inline void IncreaseGroupNumVehicle(GroupID id_g)

	SetWindowDirty(WC_REPLACE_VEHICLE, VEH_TRAIN);

}

uint GetGroupNumEngines(CompanyID company, GroupID id_g, EngineID id_e)

{

	if (Group::IsValidID(id_g)) return Group::Get(id_g)->num_engines[id_e];

	}

}

bool GetHeightmapDimensions(char *filename, uint *x, uint *y)

{

	return ReadHeightMap(filename, x, y, NULL);

}

void LoadHeightmap(char *filename)

{

	uint x, y;

	MarkWholeScreenDirty();

}

void FlatEmptyWorld(byte tile_height)

{

	int edge_distance = _settings_game.construction.freeform_edges ? 0 : 2;

#ifndef HEIGHTMAP_H

#define HEIGHTMAP_H

 * Order of these enums has to be the same as in lang/english.txt

 * Otherwise you will get inconsistent behaviour.

 */

	HM_CLOCKWISE,         ///< Rotate the map clockwise 45 degrees

};

bool GetHeightmapDimensions(char *filename, uint *x, uint *y);

void LoadHeightmap(char *filename);

void FlatEmptyWorld(byte tile_height);

void FixSlopes();

#endif /* HEIGHTMAP_H */

	byte processing_time;              ///< Periodic refresh multiplier

	byte minimum_life;                 ///< The minimum number of years this house will survive before the town rebuilds it

	Money GetRemovalCost() const;

	static FORCEINLINE HouseSpec *Get(size_t house_id)

	_industry_builder.Reset();

}

bool IndustrySpec::IsRawIndustry() const

{

	/* Lumber mills are extractive/organic, but can always be built like a non-raw industry */

			(this->behaviour & INDUSTRYBEH_CUT_TREES) == 0;

}

Money IndustrySpec::GetConstructionCost() const

{

	/* Building raw industries like secondary uses different price base */

			PR_BUILD_INDUSTRY_RAW : PR_BUILD_INDUSTRY] * this->cost_multiplier) >> 8;

}

Money IndustrySpec::GetRemovalCost() const

{

	return (_price[PR_CLEAR_INDUSTRY] * this->removal_cost_multiplier) >> 8;

}

bool IndustrySpec::UsesSmoothEconomy() const

{

	return _settings_game.economy.smooth_economy &&

	bool enabled;                         ///< entity still available (by default true).newgrf can disable it, though

	GRFFileProps grf_prop;                ///< properties related to the grf file

	bool IsRawIndustry() const;

	Money GetConstructionCost() const;

	Money GetRemovalCost() const;

	bool UsesSmoothEconomy() const;

};

# include <shellapi.h>

#endif

IniItem::IniItem(IniGroup *parent, const char *name, size_t len) : next(NULL), value(NULL), comment(NULL)

{

	if (len == 0) len = strlen(name);

	parent->last_item = &this->next;

}

IniItem::~IniItem()

{

	free(this->name);

	delete this->next;

}

void IniItem::SetValue(const char *value)

{

	free(this->value);

	this->value = strdup(value);

}

IniGroup::IniGroup(IniFile *parent, const char *name, size_t len) : next(NULL), type(IGT_VARIABLES), item(NULL), comment(NULL)

{

	if (len == 0) len = strlen(name);

	}

}

IniGroup::~IniGroup()

{

	free(this->name);

	delete this->next;

}

IniItem *IniGroup::GetItem(const char *name, bool create)

{

	for (IniItem *item = this->item; item != NULL; item = item->next) {

	return new IniItem(this, name, strlen(name));

}

void IniGroup::Clear()

{

	delete this->item;

	this->last_item = &this->item;

}

IniFile::IniFile(const char * const *list_group_names) : group(NULL), comment(NULL), list_group_names(list_group_names)

{

	this->last_group = &this->group;

}

IniFile::~IniFile()

{

	free(this->comment);

	delete this->group;

}

IniGroup *IniFile::GetGroup(const char *name, size_t len)

{

	if (len == 0) len = strlen(name);

	return group;

}

void IniFile::RemoveGroup(const char *name)

{

	size_t len = strlen(name);

	delete group;

}

void IniFile::LoadFromDisk(const char *filename)

{

	assert(this->last_group == &this->group);

	fclose(in);

}

bool IniFile::SaveToDisk(const char *filename)

{

	/*

	char *value;   ///< The value of this item

	char *comment; ///< The comment associated with this item

	IniItem(struct IniGroup *parent, const char *name, size_t len = 0);

	~IniItem();

	void SetValue(const char *value);

};

	char *name;          ///< name of group

	char *comment;       ///< comment for group

	IniGroup(struct IniFile *parent, const char *name, size_t len = 0);

	~IniGroup();

	IniItem *GetItem(const char *name, bool create);

	void Clear();

};

	char *comment;                        ///< last comment in file

	const char * const *list_group_names; ///< NULL terminated list with group names that are lists

	IniFile(const char * const *list_group_names = NULL);

	~IniFile();

	IniGroup *GetGroup(const char *name, size_t len = 0);

	void RemoveGroup(const char *name);

	void LoadFromDisk(const char *filename);

	bool SaveToDisk(const char *filename);

};

	char genders[MAX_NUM_GENDERS][CASE_GENDER_LEN]; ///< the genders used by this translation

	char cases[MAX_NUM_CASES][CASE_GENDER_LEN];     ///< the cases used by this translation

	bool IsValid() const;

	/**

	byte colour2; ///< Second colour, for vehicles with 2CC support.

};

void ResetCompanyLivery(Company *c);

#endif /* LIVERY_H */

TileExtended *_me = NULL; ///< Extended Tiles of the map

 * (Re)allocates a map with the given dimension

 * @param size_x the width of the map along the NE/SW edge

 * @param size_y the 'height' of the map along the SE/NW edge

}

#endif

 * This function checks if we add addx/addy to tile, if we

 * do wrap around the edges. For example, tile = (10,2) and

 * addx = +3 and addy = -4. This function will now return

	{ 0, -1}  ///< DIR_NW

};

 * Gets the Manhattan distance between the two given tiles.

 * The Manhattan distance is the sum of the delta of both the

 * X and Y component.

}

 * Gets the 'Square' distance between the two given tiles.

 * The 'Square' distance is the square of the shortest (straight line)

 * distance between the two tiles.

}

 * Gets the biggest distance component (x or y) between the two given tiles.

 * Also known as L-Infinity-Norm.

 * @param t0 the start tile

}

 * Gets the biggest distance component (x or y) between the two given tiles

 * plus the Manhattan distance, i.e. two times the biggest distance component

 * and once the smallest component.

	return dx > dy ? 2 * dx + dy : 2 * dy + dx;

}

 * Param the minimum distance to an edge

 * @param tile the tile to get the distance from

 * @return the distance from the edge in tiles

	return min(minl, minh);

}

 * Gets the distance to the edge of the map in given direction.

 * @param tile the tile to get the distance from

 * @param diagdir the direction of interest

	}

}

 * Function performing a search around a center tile and going outward, thus in circle.

 * Although it really is a square search...

 * Every tile will be tested by means of the callback function proc,

	}

}

 * Generalized circular search allowing for rectangles and a hole.

 * Function performing a search around a center rectangle and going outward.

 * The center rectangle is left out from the search. To do a rectangular search

	return false;

}

 * Finds the distance for the closest tile with water/land given a tile

 * @param tile  the tile to find the distance too

 * @param water whether to find water or land

 */

extern TileExtended *_me;

void AllocateMap(uint size_x, uint size_y);

/**

 */

#define TILE_ADDXY(tile, x, y) TILE_ADD(tile, TileDiffXY(x, y))

TileIndex TileAddWrap(TileIndex tile, int addx, int addy);

/**

 */

typedef bool TestTileOnSearchProc(TileIndex tile, void *user_data);

bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data);

bool CircularTileSearch(TileIndex *tile, uint radius, uint w, uint h, TestTileOnSearchProc proc, void *user_data);

/**

 */

#define RandomTile() RandomTileSeed(Random())

uint GetClosestWaterDistance(TileIndex tile, bool water);

#endif /* MAP_FUNC_H */

static inline void SortNetworkLanguages() {}

#endif /* ENABLE_NETWORK */

bool LanguagePackHeader::IsValid() const

{

	return this->ident        == TO_LE32(LanguagePackHeader::IDENT) &&

	return Town::Get(index);

}

Money HouseSpec::GetRemovalCost() const

{

	return (_price[PR_CLEAR_HOUSE] * this->removal_cost) >> 8;

	}

}

void MarkTileDirtyByTile(TileIndex tile)

{

	Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, GetTileZ(tile));