* See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#include "../stdafx.h"

#include "../table/sprites.h"

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef AI_GUI_HPP

#define AI_GUI_HPP

/**

 * Get the finite state machine of an airport type.

 * @return Finite state machine of the airport.

 */

const AirportFTAClass *GetAirport(const byte airport_type)

	STARTTAKEOFF   = 11, ///< Airplane has arrived at a runway for take-off.

	ENDTAKEOFF     = 12, ///< Airplane has reached end-point of the take-off runway.

	HELITAKEOFF    = 13, ///< Helicopter wants to leave the airport.

	LANDING        = 15, ///< Airplane wants to land.

	ENDLANDING     = 16, ///< Airplane wants to finish landing.

	HELILANDING    = 17, ///< Helicopter wants to land.

	const AirportMovingData *moving_data; ///< Movement data.

	struct AirportFTA *layout;            ///< state machine for airport

	const byte num_helipads;              ///< Number of helipads on this airport. When 0 helicopters will go to normal terminals.

	Flags flags;                          ///< Flags for this airport type.

	byte nofelements;                     ///< number of positions the airport consists of

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef ANIMATED_TILE_FUNC_H

#define ANIMATED_TILE_FUNC_H

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#include "stdafx.h"

#include "error.h"

/**

 * Simple pair of data. Both types have to be POD ("Plain Old Data")!

 */

template <typename T, typename U>

struct SmallPair {

/**

 * Implementation of simple mapping class. Both types have to be POD ("Plain Old Data")!

 * It has inherited accessors from SmallVector().

 *

 * @see SmallVector

 */

#include "date_type.h"

#include "strings_type.h"

struct CurrencySpec {

	uint16 rate;

	char separator[8];

	char prefix[16];

	char suffix[16];

	/**

	 * The currency symbol is represented by two possible values, prefix and suffix

	 * 0 = prefix

	 * 1 = suffix

	 * 2 = both : Special case only for custom currency.

	 *            It is not a spec from Newgrf,

	 */

	byte symbol_pos;

	StringID name;

	TOKEN_ELSE,       ///< (#)else in code

	TOKEN_ENDIF,      ///< (#)endif in code

	TOKEN_UNDEF,      ///< (#)undef in code

	TOKEN_INCLUDE,    ///< (#)include in code

};

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#include "stdafx.h"

#include "command_func.h"

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef ENGINE_GUI_H

#define ENGINE_GUI_H

typedef GUIList<EngineID, CargoID> GUIEngineList;

StringID GetEngineCategoryName(EngineID engine);

StringID GetEngineInfoString(EngineID engine);

	BASESET_DIR,   ///< Subdirectory for all base data (base sets, intro game)

	NEWGRF_DIR,    ///< Subdirectory for all NewGRFs

	LANG_DIR,      ///< Subdirectory for all translation files

	GAME_DIR,      ///< Subdirectory for all game scripts

	GAME_LIBRARY_DIR, ///< Subdirectory for all GS libraries

	NUM_SUBDIRS,   ///< Number of subdirectories

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GOAL_BASE_H

#define GOAL_BASE_H

 */

static inline byte RGBToGrayscale(byte red, byte green, byte blue)

{

	 *  divide by it to normalize the value to a byte again. */

	return ((red * 19595) + (green * 38470) + (blue * 7471)) / 65536;

}

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef HOTKEYS_H

#define HOTKEYS_H

 * @param [out] town Pointer to return town for the new industry, \c NULL is written if no good town can be found.

 * @return Succeeded or failed command.

 *

 */

static CommandCost FindTownForIndustry(TileIndex tile, int type, Town **t)

{

void IndustryBuildData::MonthlyLoop()

{

	static const int NEWINDS_PER_MONTH = 0x38000 / (10 * 12); // lower 16 bits is a float fraction, 3.5 industries per decade, divided by 10 * 12 months.

	/* To prevent running out of unused industries for the player to connect,

	 * add a fraction of new industries each month, but only if the manager can keep up. */

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef INDUSTRYTYPE_H

#define INDUSTRYTYPE_H

	SpriteID preview_sprite;               ///< preview sprite for this airport

	uint16 maintenance_cost;               ///< maintenance cost mulltiplier

	/* Newgrf data */

	static const AirportSpec *Get(byte type);

	static AirportSpec *GetWithoutOverride(byte type);

 */

/**

 */

#include "stdafx.h"

}

/**

 * This is done for *all* storages that have been registered to with

 *

 * This can be done in two ways:

 *  - saving the changes permanently

 *  - reverting to the previous version

 */

void ClearStorageChanges(bool keep_changes)

{

 * Base class for all NewGRF storage arrays. Nothing fancy, only here

 * so we have a generalised class to use.

 */

	virtual ~BaseStorageArray();

	/**

	 * This can be done in two ways:

	 *  - saving the changes permanently

	 *  - reverting to the previous version

	 */

	virtual void ClearChanges(bool keep_changes) = 0;

/**

 * Class for persistent storage of data.

 */

template <typename TYPE, uint SIZE>

struct PersistentStorageArray : BaseStorageArray {

/**

 * Class for temporary storage of data.

 */

template <typename TYPE, uint SIZE>

struct TemporaryStorageArray : BaseStorageArray {

/**

 * Class for pooled persistent storage of data.

 */

struct PersistentStorage : PersistentStorageArray<int32, 16>, PersistentStoragePool::PoolItem<&_persistent_storage_pool> {

	uint32 grfid; ///< GRFID associated to this persistent storage. A value of zero means "default".

	/**

	 * Makes an entrance occupied or free

	 */

	inline void SetEntranceBusy(bool busy)

	{

	/**

	 * Get the drive through road stop entry struct for the given direction.

	 * @return the entry

	 */

	inline const Entry *GetEntry(DiagDirection dir) const

	/**

	 * Get the drive through road stop entry struct for the given direction.

	 * @return the entry

	 */

	inline Entry *GetEntry(DiagDirection dir)

	/**

	 * Compute height given a number of columns.

	 * @return Needed height for displaying the smallmap legends in pixels.

	 */

	uint GetLegendHeight(uint num_columns) const

		number = -number;

	}

	 * The only remaining value is 1 (suffix), so everything that is not 1 */

	if (spec->symbol_pos != 1) buff = strecpy(buff, spec->prefix, last);

	buff = FormatNumber(buff, number, last, separator);

	buff = strecpy(buff, multiplier, last);

	 * The only remaining value is 1 (prefix), so everything that is not 0 */

	if (spec->symbol_pos != 0) buff = strecpy(buff, spec->suffix, last);

}

/**

 * @param file the file to read

 * @param hdr  the place to write the header information to

 * @return true if and only if the language file is of a compatible version

}

/**

 */

void InitializeLanguagePacks()

{

	const char *lang = GetCurrentLocale("LC_MESSAGES");

	if (lang == NULL) lang = "en_GB";

	const LanguageMetadata *language_fallback = NULL; ///< Using pt_PT for pt_BR locale when pt_BR is not available

	const LanguageMetadata *en_GB_fallback    = _languages.Begin(); ///< Fallback when no locale-matching language has been found

	for (const LanguageMetadata *lng = _languages.Begin(); lng != _languages.End(); lng++) {

		/* We are trying to find a default language. The priority is by

		 * configuration file, local environment and last, if nothing found,

		const char *lang_file = strrchr(lng->file, PATHSEPCHAR) + 1;

		if (strcmp(lang_file, _config_language_file) == 0) {

			chosen_language = lng;

#include "table/strings.h"

INSTANTIATE_POOL_METHODS(Subsidy)

/**

	InvalidateWindowData(WC_SUBSIDIES_LIST, 0);

}

Pair SetupSubsidyDecodeParam(const Subsidy *s, bool mode)

{

	NewsReferenceType reftype1 = NR_NONE;

	}

}

void RebuildSubsidisedSourceAndDestinationCache()

{

	Town *t;

	}

}

void DeleteSubsidyWith(SourceType type, SourceID index)

{

	bool dirty = false;

	}

}

static bool CheckSubsidyDuplicate(CargoID cargo, SourceType src_type, SourceID src, SourceType dst_type, SourceID dst)

{

	const Subsidy *s;

	return false;

}

 * @param src_type Type of #src.

 * @param src      Index of source.

 * @param dst_type Type of #dst.

	return (DistanceManhattan(tile_src, tile_dst) <= SUBSIDY_MAX_DISTANCE);

}

 * @param cid      Subsidised cargo.

 * @param src_type Type of #src.

 * @param src      Index of source.

	return CommandCost();

}

 * @return True iff the subsidy was created.

 */

bool FindSubsidyPassengerRoute()

bool FindSubsidyCargoDestination(CargoID cid, SourceType src_type, SourceID src);

 * @return True iff the subsidy was created.

 */

bool FindSubsidyTownCargoRoute()

	return FindSubsidyCargoDestination(cid, src_type, src);

}

 * @return True iff the subsidy was created.

 */

bool FindSubsidyIndustryCargoRoute()

	return FindSubsidyCargoDestination(cid, src_type, src);

}

 * @param cid      Subsidized cargo.

 * @param src_type Type of #src.

 * @param src      Index of source.

	return true;

}

void SubsidyMonthlyLoop()

{

	bool modified = false;

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef SUBSIDY_BASE_H

#define SUBSIDY_BASE_H

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef TILEMATRIX_TYPE_HPP

#define TILEMATRIX_TYPE_HPP

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#include "stdafx.h"

#include "string_func.h"

 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef TOWNNAME_FUNC_H

#define TOWNNAME_FUNC_H

	return min(max_speed, this->gcache.cached_max_track_speed);

}

void Train::UpdateAcceleration()

{

	assert(this->IsFrontEngine());

	return ((direction + _engine_sprite_add[spritenum]) & _engine_sprite_and[spritenum]) + _engine_sprite_base[spritenum];

}

SpriteID Train::GetImage(Direction direction, EngineImageType image_type) const

{

	uint8 spritenum = this->spritenum;

	return CommandCost();

}

bool Train::IsInDepot() const

{

	/* Is the front engine stationary in the depot? */

	return true;

}

bool Train::IsStoppedInDepot() const

{

	/* Are we stopped? Of course wagons don't really care... */

	}

}

static void MarkTrainAsStuck(Train *v)

{

	if (!HasBit(v->flags, VRF_TRAIN_STUCK)) {

	}

}

static void SwapTrainFlags(uint16 *swap_flag1, uint16 *swap_flag2)

{

	uint16 flag1 = *swap_flag1;

	v->UpdateViewport(true, true);

}

void ReverseTrainSwapVeh(Train *v, int l, int r)

{

	Train *a, *b;

	}

}

void ReverseTrainDirection(Train *v)

{

	if (IsRailDepotTile(v->tile)) {

}

/**

 */

static FindDepotData FindClosestTrainDepot(Train *v, int max_distance)

{

	}

}

bool Train::FindClosestDepot(TileIndex *location, DestinationID *destination, bool *reverse)

{

	FindDepotData tfdd = FindClosestTrainDepot(this, 0);

	return true;

}

void Train::PlayLeaveStationSound() const

{

	static const SoundFx sfx[] = {

	SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], this);

}

static void CheckNextTrainTile(Train *v)

{

	/* Don't do any look-ahead if path_backoff_interval is 255. */

	}

}

static bool CheckTrainStayInDepot(Train *v)

{

	/* bail out if not all wagons are in the same depot or not in a depot at all */

	return false;