STR_NEWGRF_SETTINGS_SET_PARAMETERS                              :{BLACK}Set parameters

STR_NEWGRF_SETTINGS_TOGGLE_PALETTE                              :{BLACK}Toggle palette

STR_NEWGRF_SETTINGS_TOGGLE_PALETTE_TOOLTIP                      :{BLACK}Toggle the palette of the selected NewGRF.{}Do this when the graphics from this NewGRF look pink in-game

STR_NEWGRF_SETTINGS_APPLY_CHANGES                               :{BLACK}Apply changes

STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_BUTTON                 :{BLACK}Find missing content online

STR_NEWGRF_SETTINGS_FIND_MISSING_CONTENT_TOOLTIP                :{BLACK}Check whether the missing content can be found online

STR_NEWGRF_SETTINGS_FILENAME                                    :{BLACK}Filename: {SILVER}{RAW_STRING}

STR_NEWGRF_SETTINGS_GRF_ID                                      :{BLACK}GRF ID: {SILVER}{RAW_STRING}

STR_NEWGRF_SETTINGS_VERSION                                     :{BLACK}Version: {SILVER}{NUM}

STR_NEWGRF_SETTINGS_MD5SUM                                      :{BLACK}MD5sum: {SILVER}{RAW_STRING}

STR_NEWGRF_SETTINGS_PALETTE                                     :{BLACK}Palette: {SILVER}{RAW_STRING}

STR_NEWGRF_SETTINGS_PARAMETER                                   :{BLACK}Parameters: {SILVER}{STRING1}

STR_NEWGRF_SETTINGS_NO_INFO                                     :{BLACK}No information available

STR_NEWGRF_SETTINGS_NOT_FOUND                                   :{RED}Matching file not found

STR_NEWGRF_SETTINGS_DISABLED                                    :{RED}Disabled

STR_NEWGRF_SETTINGS_PARAMETER_QUERY                             :{BLACK}Enter NewGRF parameters

# NewGRF parameters window

STR_NEWGRF_PARAMETERS_CAPTION                                   :{WHITE}Change NewGRF parameters

STR_NEWGRF_PARAMETERS_CLOSE                                     :{BLACK}Close

STR_NEWGRF_PARAMETERS_DEFAULT_NAME                              :Parameter {NUM}

STR_NEWGRF_PARAMETERS_SETTING                                   :{STRING1}: {ORANGE}{STRING1}

# NewGRF inspect window

STR_NEWGRF_INSPECT_CAPTION                                      :{WHITE}Inspect - {STRING5}

STR_NEWGRF_INSPECT_PARENT_BUTTON                                :{BLACK}Parent

STR_NEWGRF_INSPECT_PARENT_TOOLTIP                               :{BLACK}Inspect the object of the parent scope

STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT                            :{STRING1} at {HEX}

STR_NEWGRF_INSPECT_CAPTION_OBJECT_AT_RAIL_TYPE                  :Rail type

STR_NEWGRF_INSPECT_QUERY_CAPTION                                :{WHITE}NewGRF variable 60+x parameter (hexadecimal)

# Sprite aligner window

STR_SPRITE_ALIGNER_CAPTION                                      :{WHITE}Aligning sprite {COMMA} ({RAW_STRING})

STR_SPRITE_ALIGNER_NEXT_BUTTON                                  :{BLACK}Next sprite

STR_SPRITE_ALIGNER_NEXT_TOOLTIP                                 :{BLACK}Proceed to the next normal sprite, skipping any pseudo/recolour/font sprites and wrapping around at the end

STR_SPRITE_ALIGNER_GOTO_BUTTON                                  :{BLACK}Go to sprite

STR_SPRITE_ALIGNER_GOTO_TOOLTIP                                 :{BLACK}Go to the given sprite. If the sprite is not a normal sprite, proceed to the next normal sprite

STR_SPRITE_ALIGNER_PREVIOUS_BUTTON                              :{BLACK}Previous sprite

STR_SPRITE_ALIGNER_PREVIOUS_TOOLTIP                             :{BLACK}Proceed to the previous normal sprite, skipping any pseudo/recolour/font sprites and wrapping around at the begin

STR_SPRITE_ALIGNER_SPRITE_TOOLTIP                               :{BLACK}Representation of the currently selected sprite. The alignment is ignored when drawing this sprite

STR_SPRITE_ALIGNER_MOVE_TOOLTIP                                 :{BLACK}Move the sprite around, changing the X and Y offsets

STR_SPRITE_ALIGNER_OFFSETS                                      :{BLACK}X offset: {NUM}, Y offset: {NUM}

STR_SPRITE_ALIGNER_PICKER_BUTTON                                :{BLACK}Pick sprite

STR_SPRITE_ALIGNER_PICKER_TOOLTIP                               :{BLACK}Pick a sprite from anywhere on the screen

STR_SPRITE_ALIGNER_GOTO_CAPTION                                 :{WHITE}Go to sprite

# NewGRF (self) generated warnings/errors

STR_NEWGRF_ERROR_MSG_INFO                                       :{SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_WARNING                                    :{RED}Warning: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_ERROR                                      :{RED}Error: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_MSG_FATAL                                      :{RED}Fatal: {SILVER}{RAW_STRING}

STR_NEWGRF_ERROR_FATAL_POPUP                                    :{WHITE}A fatal NewGRF error has occurred: {}{STRING5}

STR_NEWGRF_ERROR_VERSION_NUMBER                                 :{1:STRING1} will not work with the TTDPatch version reported by OpenTTD.

STR_NEWGRF_ERROR_DOS_OR_WINDOWS                                 :{1:STRING1} is for the {STRING1} version of TTD.

STR_NEWGRF_ERROR_UNSET_SWITCH                                   :{1:STRING1} is designed to be used with {STRING1}

STR_NEWGRF_ERROR_INVALID_PARAMETER                              :Invalid parameter for {1:STRING1}: parameter {STRING1} ({NUM})

STR_NEWGRF_ERROR_LOAD_BEFORE                                    :{1:STRING1} must be loaded before {STRING1}.

STR_NEWGRF_ERROR_LOAD_AFTER                                     :{1:STRING1} must be loaded after {STRING1}.

STR_NEWGRF_ERROR_OTTD_VERSION_NUMBER                            :{1:STRING1} requires OpenTTD version {STRING1} or better.

STR_NEWGRF_ERROR_AFTER_TRANSLATED_FILE                          :the GRF file it was designed to translate

STR_NEWGRF_ERROR_TOO_MANY_NEWGRFS_LOADED                        :Too many NewGRFs are loaded.

STR_NEWGRF_ERROR_STATIC_GRF_CAUSES_DESYNC                       :Loading {RAW_STRING} as static NewGRF with {RAW_STRING} could cause desyncs.

STR_NEWGRF_ERROR_UNEXPECTED_SPRITE                              :Unexpected sprite.

STR_NEWGRF_ERROR_UNKNOWN_PROPERTY                               :Unknown Action 0 property.

STR_NEWGRF_ERROR_INVALID_ID                                     :Attempt to use invalid ID.

STR_NEWGRF_ERROR_CORRUPT_SPRITE                                 :{YELLOW}{RAW_STRING} contains a corrupt sprite. All corrupt sprites will be shown as a red question mark (?).

STR_NEWGRF_ERROR_MULTIPLE_ACTION_8                              :Contains multiple Action 8 entries.

STR_NEWGRF_ERROR_READ_BOUNDS                                    :Read past end of pseudo-sprite.

# NewGRF related 'general' warnings

STR_NEWGRF_POPUP_CAUTION_CAPTION                                :{WHITE}Caution!

STR_NEWGRF_CONFIRMATION_TEXT                                    :{YELLOW}You are about to make changes to a running game. This can crash OpenTTD.{}Are you absolutely sure about this?

STR_NEWGRF_DUPLICATE_GRFID                                      :{WHITE}Can't add file: duplicate GRF ID

STR_NEWGRF_COMPATIBLE_LOADED                                    :{ORANGE}Matching file not found (compatible GRF loaded)

STR_NEWGRF_COMPATIBLE_LOAD_WARNING                              :{WHITE}Compatible GRF(s) loaded for missing files

STR_NEWGRF_DISABLED_WARNING                                     :{WHITE}Missing GRF file(s) have been disabled

STR_NEWGRF_UNPAUSE_WARNING_TITLE                                :{YELLOW}Missing GRF file(s)

STR_NEWGRF_UNPAUSE_WARNING                                      :{WHITE}Unpausing can crash OpenTTD. Do not file bug reports for subsequent crashes.{}Do you really want to unpause?

# NewGRF status

STR_NEWGRF_LIST_NONE                                            :None

STR_NEWGRF_LIST_ALL_FOUND                                       :All files present

STR_NEWGRF_LIST_COMPATIBLE                                      :{YELLOW}Found compatible files

STR_NEWGRF_LIST_MISSING                                         :{RED}Missing files

# NewGRF 'it's broken' warnings

STR_NEWGRF_BROKEN                                               :{WHITE}Behaviour of NewGRF '{0:RAW_STRING}' is likely to cause desyncs and/or crashes.

STR_NEWGRF_BROKEN_VEHICLE_LENGTH                                :{WHITE}It changes vehicle length for '{1:ENGINE}' when not inside a depot.

STR_BROKEN_VEHICLE_LENGTH                                       :{WHITE}Train '{VEHICLE}' belonging to '{COMPANY}' has invalid length. It is probably caused by problems with NewGRFs. Game may desync or crash.

STR_NEWGRF_BUGGY                                                :{WHITE}NewGRF '{0:RAW_STRING}' provides incorrect information.

STR_NEWGRF_BUGGY_ARTICULATED_CARGO                              :{WHITE}Cargo/refit information for '{1:ENGINE}' differs from purchase list after construction. This might cause autorenew/-replace to fail refitting correctly.

STR_NEWGRF_BUGGY_ENDLESS_PRODUCTION_CALLBACK                    :{WHITE}'{1:STRING}' caused an endless loop in the production callback.

# 'User removed essential NewGRFs'-placeholders for stuff without specs.

STR_NEWGRF_INVALID_CARGO                                        :<invalid cargo>

STR_NEWGRF_INVALID_CARGO_ABBREV                                 :??

STR_NEWGRF_INVALID_CARGO_QUANTITY                               :{COMMA} of <invalid cargo>

STR_NEWGRF_INVALID_ENGINE                                       :<invalid vehicle model>

STR_NEWGRF_INVALID_INDUSTRYTYPE                                 :<invalid industry>

# Sign list window

STR_SIGN_LIST_CAPTION                                           :{WHITE}Sign List - {COMMA} Sign{P "" s}

# Sign window

STR_EDIT_SIGN_CAPTION                                           :{WHITE}Edit sign text

STR_EDIT_SIGN_NEXT_SIGN_TOOLTIP                                 :{BLACK}Go to next sign

STR_EDIT_SIGN_PREVIOUS_SIGN_TOOLTIP                             :{BLACK}Go to previous sign

STR_EDIT_SIGN_SIGN_OSKTITLE                                     :{BLACK}Enter a name for the sign

# Town directory window

STR_TOWN_DIRECTORY_CAPTION                                      :{WHITE}Towns

STR_TOWN_DIRECTORY_NONE                                         :{ORANGE}- None -

STR_TOWN_DIRECTORY_TOWN                                         :{ORANGE}{TOWN}{BLACK} ({COMMA})

STR_TOWN_DIRECTORY_LIST_TOOLTIP                                 :{BLACK}Town names - click on name to centre view on town. Ctrl+Click opens a new viewport on town location

STR_TOWN_POPULATION                                             :{BLACK}World population: {COMMA}

# Town view window

STR_TOWN_VIEW_TOWN_CAPTION                                      :{WHITE}{TOWN}

STR_TOWN_VIEW_CITY_CAPTION                                      :{WHITE}{TOWN} (City)

STR_TOWN_VIEW_POPULATION_HOUSES                                 :{BLACK}Population: {ORANGE}{COMMA}{BLACK}  Houses: {ORANGE}{COMMA}

STR_TOWN_VIEW_PASSENGERS_LAST_MONTH_MAX                         :{BLACK}Passengers last month: {ORANGE}{COMMA}{BLACK}  max: {ORANGE}{COMMA}

STR_TOWN_VIEW_MAIL_LAST_MONTH_MAX                               :{BLACK}Mail last month: {ORANGE}{COMMA}{BLACK}  max: {ORANGE}{COMMA}

STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH                              :{BLACK}Cargo needed for town growth:

STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_REQUIRED                     :{ORANGE}{STRING}{BLACK} required

STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_REQUIRED_WINTER              :{ORANGE}{STRING}{BLACK} required in winter

STR_TOWN_VIEW_CARGO_FOR_TOWNGROWTH_LAST_MONTH                   :{ORANGE}{CARGO}{BLACK} delivered last month

STR_TOWN_VIEW_NOISE_IN_TOWN                                     :{BLACK}Noise limit in town: {ORANGE}{COMMA}{BLACK}  max: {ORANGE}{COMMA}

STR_TOWN_VIEW_CENTER_TOOLTIP                                    :{BLACK}Centre the main view on town location. Ctrl+Click opens a new viewport on town location

STR_TOWN_VIEW_LOCAL_AUTHORITY_BUTTON                            :{BLACK}Local authority

STR_TOWN_VIEW_LOCAL_AUTHORITY_TOOLTIP                           :{BLACK}Show information on local authority

STR_TOWN_VIEW_RENAME_TOOLTIP                                    :{BLACK}Change town name

STR_TOWN_VIEW_EXPAND_BUTTON                                     :{BLACK}Expand

STR_TOWN_VIEW_EXPAND_TOOLTIP                                    :{BLACK}Increase size of town

STR_TOWN_VIEW_DELETE_BUTTON                                     :{BLACK}Delete

STR_TOWN_VIEW_DELETE_TOOLTIP                                    :{BLACK}Delete this town completely

STR_TOWN_VIEW_RENAME_TOWN_BUTTON                                :Rename Town

# Town local authority window

STR_LOCAL_AUTHORITY_CAPTION                                     :{WHITE}{TOWN} local authority

STR_LOCAL_AUTHORITY_COMPANY_RATINGS                             :{BLACK}Transport company ratings:

STR_LOCAL_AUTHORITY_COMPANY_RATING                              :{YELLOW}{COMPANY} {COMPANYNUM}: {ORANGE}{STRING}

STR_LOCAL_AUTHORITY_ACTIONS_TITLE                               :{BLACK}Actions available:

STR_LOCAL_AUTHORITY_ACTIONS_TOOLTIP                             :{BLACK}List of things to do at this town - click on item for more details

STR_LOCAL_AUTHORITY_DO_IT_BUTTON                                :{BLACK}Do it

STR_LOCAL_AUTHORITY_DO_IT_TOOLTIP                               :{BLACK}Carry out the highlighted action in the list above

STR_LOCAL_AUTHORITY_ACTION_SMALL_ADVERTISING_CAMPAIGN           :Small advertising campaign

STR_LOCAL_AUTHORITY_ACTION_MEDIUM_ADVERTISING_CAMPAIGN          :Medium advertising campaign

STR_LOCAL_AUTHORITY_ACTION_LARGE_ADVERTISING_CAMPAIGN           :Large advertising campaign

STR_LOCAL_AUTHORITY_ACTION_ROAD_RECONSTRUCTION                  :Fund local road reconstruction

STR_LOCAL_AUTHORITY_ACTION_STATUE_OF_COMPANY                    :Build statue of company owner

STR_LOCAL_AUTHORITY_ACTION_NEW_BUILDINGS                        :Fund new buildings

STR_LOCAL_AUTHORITY_ACTION_EXCLUSIVE_TRANSPORT                  :Buy exclusive transport rights

STR_LOCAL_AUTHORITY_ACTION_BRIBE                                :Bribe the local authority

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_SMALL_ADVERTISING            :{YELLOW}Initiate a small local advertising campaign, to attract more passengers and cargo to your transport services.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_MEDIUM_ADVERTISING           :{YELLOW}Initiate a medium local advertising campaign, to attract more passengers and cargo to your transport services.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_LARGE_ADVERTISING            :{YELLOW}Initiate a large local advertising campaign, to attract more passengers and cargo to your transport services.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_ROAD_RECONSTRUCTION          :{YELLOW}Fund the reconstruction of the urban road network. Causes considerable disruption to road traffic for up to 6 months.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_STATUE_OF_COMPANY            :{YELLOW}Build a statue in honour of your company.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_NEW_BUILDINGS                :{YELLOW}Fund the construction of new commercial buildings in the town.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_EXCLUSIVE_TRANSPORT          :{YELLOW}Buy 1 year's exclusive transport rights in town. Town authority will only allow passengers and cargo to use your company's stations.{}Cost: {CURRENCY}

STR_LOCAL_AUTHORITY_ACTION_TOOLTIP_BRIBE                        :{YELLOW}Bribe the local authority to increase your rating, at the risk of a severe penalty if caught.{}Cost: {CURRENCY}

# Subsidies window

STR_SUBSIDIES_CAPTION                                           :{WHITE}Subsidies

STR_SUBSIDIES_OFFERED_TITLE                                     :{BLACK}Subsidies on offer for services taking:

STR_SUBSIDIES_OFFERED_FROM_TO                                   :{ORANGE}{STRING} from {STRING2} to {STRING2}{YELLOW} (by {DATE_SHORT})

STR_SUBSIDIES_NONE                                              :{ORANGE}- None -

STR_SUBSIDIES_SUBSIDISED_TITLE                                  :{BLACK}Services already subsidised:

STR_SUBSIDIES_SUBSIDISED_FROM_TO                                :{ORANGE}{STRING} from {STRING2} to {STRING2}{YELLOW} ({COMPANY}{YELLOW}, until {DATE_SHORT})

STR_SUBSIDIES_TOOLTIP_CLICK_ON_SERVICE_TO_CENTER                :{BLACK}Click on service to centre view on industry/town. Ctrl+Click opens a new viewport on industry/town location

# Station list window

STR_STATION_LIST_TOOLTIP                                        :{BLACK}Station names - click on name to centre view on station. Ctrl+Click opens a new viewport on station location

STR_STATION_LIST_USE_CTRL_TO_SELECT_MORE                        :{BLACK}Hold Ctrl to select more than one item

STR_STATION_LIST_CAPTION                                        :{WHITE}{COMPANY} - {COMMA} Station{P "" s}

STR_STATION_LIST_STATION                                        :{YELLOW}{STATION} {STATIONFEATURES}

STR_STATION_LIST_WAYPOINT                                       :{YELLOW}{WAYPOINT}

/* $Id$ */

/*

 * This file is part of OpenTTD.

 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.

 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 * 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/>.

 */

/** @file newgrf_config.h Functions to find and configure NewGRFs. */

#ifndef NEWGRF_CONFIG_H

#define NEWGRF_CONFIG_H

#include "strings_type.h"

#include "core/alloc_type.hpp"

#include "core/smallmap_type.hpp"

/** GRF config bit flags */

enum GCF_Flags {

	GCF_SYSTEM,     ///< GRF file is an openttd-internal system grf

	GCF_UNSAFE,     ///< GRF file is unsafe for static usage

	GCF_STATIC,     ///< GRF file is used statically (can be used in any MP game)

	GCF_COMPATIBLE, ///< GRF file does not exactly match the requested GRF (different MD5SUM), but grfid matches)

	GCF_COPY,       ///< The data is copied from a grf in _all_grfs

	GCF_INIT_ONLY,  ///< GRF file is processed up to GLS_INIT

	GCF_RESERVED,   ///< GRF file passed GLS_RESERVE stage

};

/** Status of GRF */

enum GRFStatus {

	GCS_UNKNOWN,      ///< The status of this grf file is unknown

	GCS_DISABLED,     ///< GRF file is disabled

	GCS_NOT_FOUND,    ///< GRF file was not found in the local cache

	GCS_INITIALISED,  ///< GRF file has been initialised

	GCS_ACTIVATED     ///< GRF file has been activated

};

/** Encountered GRF bugs */

enum GRFBugs {

	GBUG_VEH_LENGTH,  ///< Length of rail vehicle changes when not inside a depot

	GBUG_VEH_REFIT,   ///< Articulated vehicles carry different cargos resp. are differently refittable than specified in purchase list

};

/** Status of post-gameload GRF compatibility check */

enum GRFListCompatibility {

	GLC_ALL_GOOD,   ///< All GRF needed by game are present

	GLC_COMPATIBLE, ///< Compatible (eg. the same ID, but different chacksum) GRF found in at least one case

	GLC_NOT_FOUND   ///< At least one GRF couldn't be found (higher priority than GLC_COMPATIBLE)

};

/** Information that can/has to be stored about a GRF's palette. */

enum GRFPalette {

	GRFP_USE_BIT     = 0,   ///< The bit used for storing the palette to use.

	GRFP_GRF_OFFSET  = 2,   ///< The offset of the GRFP_GRF data.

	GRFP_GRF_SIZE    = 2,   ///< The size of the GRFP_GRF data.

	GRFP_USE_DOS     = 0x0, ///< The palette state is set to use the DOS palette.

	GRFP_USE_WINDOWS = 0x1, ///< The palette state is set to use the Windows palette.

	GRFP_USE_MASK    = 0x1, ///< Bitmask to get only the use palette use states.

	GRFP_GRF_UNSET   = 0x0 << GRFP_GRF_OFFSET,          ///< The NewGRF provided no information.

	GRFP_GRF_DOS     = 0x1 << GRFP_GRF_OFFSET,          ///< The NewGRF says the DOS palette can be used.

	GRFP_GRF_WINDOWS = 0x2 << GRFP_GRF_OFFSET,          ///< The NewGRF says the Windows palette can be used.

	GRFP_GRF_ANY     = GRFP_GRF_DOS | GRFP_GRF_WINDOWS, ///< The NewGRF says any palette can be used.

	GRFP_GRF_MASK    = GRFP_GRF_ANY,                    ///< Bitmask to get only the NewGRF supplied information.

};

/** Basic data to distinguish a GRF. Used in the server list window */

struct GRFIdentifier {

	uint32 grfid;     ///< GRF ID (defined by Action 0x08)

	uint8 md5sum[16]; ///< MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)

	/**

	 * Does the identification match the provided values?

	 * @param grfid  Expected grfid.

	 * @param md5sum Expected md5sum, may be \c NULL (in which case, do not check it).

	 * @return the object has the provided grfid and md5sum.

	 */

	FORCEINLINE bool HasGrfIdentifier(uint32 grfid, const uint8 *md5sum) const

	{

		if (this->grfid != grfid) return false;

		if (md5sum == NULL) return true;

		return memcmp(md5sum, this->md5sum, sizeof(this->md5sum)) == 0;

	}

};

/** Information about why GRF had problems during initialisation */

struct GRFError : ZeroedMemoryAllocator {

	GRFError(StringID severity, StringID message = 0);

	GRFError(const GRFError &error);

	~GRFError();

	char *custom_message;  ///< Custom message (if present)

	char *data;            ///< Additional data for message and custom_message

	StringID message;      ///< Default message

	StringID severity;     ///< Info / Warning / Error / Fatal

	uint8 num_params;      ///< Number of additinal parameters for message and custom_message (0, 1 or 2)

	uint32 param_value[2]; ///< Values of GRF parameters to show for message and custom_message

};

/** The possible types of a newgrf parameter. */

enum GRFParameterType {

	PTYPE_UINT_ENUM, ///< The parameter allows a range of numbers, each of which can have a special name

	PTYPE_BOOL,      ///< The parameter is either 0 or 1

	PTYPE_END,       ///< Invalid parameter type

};

/** Information about one grf parameter. */

struct GRFParameterInfo {

	GRFParameterInfo(uint nr);

	GRFParameterInfo(GRFParameterInfo &info);

	~GRFParameterInfo();

	struct GRFText *name;  ///< The name of this parameter

	struct GRFText *desc;  ///< The description of this parameter

	GRFParameterType type; ///< The type of this parameter

	uint32 min_value;      ///< The minimal value this parameter can have

	uint32 max_value;      ///< The maximal value of this parameter

	byte param_nr;         ///< GRF parameter to store content in

	byte first_bit;        ///< First bit to use in the GRF parameter

	byte num_bit;          ///< Number of bits to use for this parameter

	SmallMap<uint32, struct GRFText *, 8> value_names; ///< Names for each value.

	uint32 GetValue(struct GRFConfig *config) const;

	void SetValue(struct GRFConfig *config, uint32 value);

};

/** Information about GRF, used in the game and (part of it) in savegames */

struct GRFConfig : ZeroedMemoryAllocator {

	GRFConfig(const char *filename = NULL);

	GRFConfig(const GRFConfig &config);

	~GRFConfig();

	GRFIdentifier ident;       ///< grfid and md5sum to uniquely identify newgrfs

	uint8 original_md5sum[16]; ///< MD5 checksum of original file if only a 'compatible' file was loaded

	char *filename;            ///< Filename - either with or without full path

	struct GRFText *name;      ///< NOSAVE: GRF name (Action 0x08)

/**

 * Remove signals

 * @param tile coordinates where signal is being deleted from

 * @param flags operation to perform

 * @param p1 various bitstuffed elements, only track information is used

 *           - (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)

 *           - (bit  3)    - override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)

 *           - (bit  4)    - 0 = signals, 1 = semaphores

 * @param p2 unused

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdRemoveSingleSignal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	Track track = Extract<Track, 0, 3>(p1);

	if (!ValParamTrackOrientation(track) || !IsPlainRailTile(tile) || !HasTrack(tile, track)) {

		return_cmd_error(STR_ERROR_THERE_IS_NO_RAILROAD_TRACK);

	}

	if (!HasSignalOnTrack(tile, track)) {

		return_cmd_error(STR_ERROR_THERE_ARE_NO_SIGNALS);

	}

	CommandCost ret = EnsureNoTrainOnTrack(tile, track);

	if (ret.Failed()) return ret;

	/* Only water can remove signals from anyone */

	if (_current_company != OWNER_WATER) {

		CommandCost ret = CheckTileOwnership(tile);

		if (ret.Failed()) return ret;

	}

	/* Do it? */

	if (flags & DC_EXEC) {

		Train *v = NULL;

		if (HasReservedTracks(tile, TrackToTrackBits(track))) {

			v = GetTrainForReservation(tile, track);

		} else if (IsPbsSignal(GetSignalType(tile, track))) {

			/* PBS signal, might be the end of a path reservation. */

			Trackdir td = TrackToTrackdir(track);

			for (int i = 0; v == NULL && i < 2; i++, td = ReverseTrackdir(td)) {

				/* Only test the active signal side. */

				if (!HasSignalOnTrackdir(tile, ReverseTrackdir(td))) continue;

				TileIndex next = TileAddByDiagDir(tile, TrackdirToExitdir(td));

				TrackBits tracks = TrackdirBitsToTrackBits(TrackdirReachesTrackdirs(td));

				if (HasReservedTracks(next, tracks)) {

					v = GetTrainForReservation(next, TrackBitsToTrack(GetReservedTrackbits(next) & tracks));

				}

			}

		}

		SetPresentSignals(tile, GetPresentSignals(tile) & ~SignalOnTrack(track));

		/* removed last signal from tile? */

		if (GetPresentSignals(tile) == 0) {

			SetSignalStates(tile, 0);

			SetHasSignals(tile, false);

			SetSignalVariant(tile, INVALID_TRACK, SIG_ELECTRIC); // remove any possible semaphores

		}

		AddTrackToSignalBuffer(tile, track, GetTileOwner(tile));

		YapfNotifyTrackLayoutChange(tile, track);

		if (v != NULL) TryPathReserve(v, false);

		MarkTileDirtyByTile(tile);

	}

	return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_SIGNALS]);

}

/**

 * Remove signals on a stretch of track.

 * Stub for the unified signal builder/remover

 * @param tile start tile of drag

 * @param flags operation to perform

 * @param p1  end tile of drag

 * @param p2 various bitstuffed elements

 * - p2 = (bit  0- 2) - track-orientation, valid values: 0-5 (Track enum)

 * - p2 = (bit  3)    - 1 = override signal/semaphore, or pre/exit/combo signal (CTRL-toggle)

 * - p2 = (bit  4)    - 0 = signals, 1 = semaphores

 * - p2 = (bit  5)    - 0 = build, 1 = remove signals

 * - p2 = (bit  6)    - 0 = selected stretch, 1 = auto fill

 * - p2 = (bit  7- 9) - default signal type

 * - p2 = (bit 24-31) - user defined signals_density

 * @param text unused

 * @return the cost of this operation or an error

 * @see CmdSignalTrackHelper

 */

CommandCost CmdRemoveSignalTrack(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	return CmdSignalTrackHelper(tile, flags, p1, SetBit(p2, 5), text); // bit 5 is remove bit

}

/** Update power of train under which is the railtype being converted */

static Vehicle *UpdateTrainPowerProc(Vehicle *v, void *data)

{

	if (v->type != VEH_TRAIN) return NULL;

	TrainList *affected_trains = static_cast<TrainList*>(data);

	affected_trains->Include(Train::From(v)->First());

	return NULL;

}

/**

 * Convert one rail type to the other. You can convert normal rail to

 * monorail/maglev easily or vice-versa.

 * @param tile end tile of rail conversion drag

 * @param flags operation to perform

 * @param p1 start tile of drag

 * @param p2 new railtype to convert to

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdConvertRail(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	RailType totype = Extract<RailType, 0, 4>(p2);

	if (!ValParamRailtype(totype)) return CMD_ERROR;

	if (p1 >= MapSize()) return CMD_ERROR;

	uint ex = TileX(tile);

	uint ey = TileY(tile);

	uint sx = TileX(p1);

	uint sy = TileY(p1);

	/* make sure sx,sy are smaller than ex,ey */

	if (ex < sx) Swap(ex, sx);

	if (ey < sy) Swap(ey, sy);

	TrainList affected_trains;

	CommandCost cost(EXPENSES_CONSTRUCTION);

	CommandCost error = CommandCost(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK); // by default, there is no track to convert.

	for (uint x = sx; x <= ex; ++x) {

		for (uint y = sy; y <= ey; ++y) {

			TileIndex tile = TileXY(x, y);

			TileType tt = GetTileType(tile);

			/* Check if there is any track on tile */

			switch (tt) {

				case MP_RAILWAY:

					break;

				case MP_STATION:

					if (!HasStationRail(tile)) continue;

					break;

				case MP_ROAD:

					if (!IsLevelCrossing(tile)) continue;

					if (RailNoLevelCrossings(totype)) {

						error.MakeError(STR_ERROR_CROSSING_DISALLOWED);

						continue;

					}

					break;

				case MP_TUNNELBRIDGE:

					if (GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL) continue;

					break;

				default: continue;

			}

			/* Original railtype we are converting from */

			RailType type = GetRailType(tile);

			/* Converting to the same type or converting 'hidden' elrail -> rail */

			if (type == totype || (_settings_game.vehicle.disable_elrails && totype == RAILTYPE_RAIL && type == RAILTYPE_ELECTRIC)) continue;

			/* Trying to convert other's rail */

			CommandCost ret = CheckTileOwnership(tile);

			if (ret.Failed()) {

				error = ret;

				continue;

			}

			SmallVector<Train *, 2> vehicles_affected;

			/* Vehicle on the tile when not converting Rail <-> ElRail

			 * Tunnels and bridges have special check later */

			if (tt != MP_TUNNELBRIDGE) {

				if (!IsCompatibleRail(type, totype)) {

					CommandCost ret = EnsureNoVehicleOnGround(tile);

					if (ret.Failed()) {

						error = ret;

						continue;

					}

				}

				if (flags & DC_EXEC) { // we can safely convert, too

					TrackBits reserved = GetReservedTrackbits(tile);

					Track     track;

					while ((track = RemoveFirstTrack(&reserved)) != INVALID_TRACK) {

						Train *v = GetTrainForReservation(tile, track);

						if (v != NULL && !HasPowerOnRail(v->railtype, totype)) {

							/* No power on new rail type, reroute. */

							FreeTrainTrackReservation(v);

							*vehicles_affected.Append() = v;

						}

				case MP_RAILWAY:

					switch (GetRailTileType(tile)) {

						case RAIL_TILE_DEPOT:

							if (flags & DC_EXEC) {

								/* notify YAPF about the track layout change */

								YapfNotifyTrackLayoutChange(tile, GetRailDepotTrack(tile));

								/* Update build vehicle window related to this depot */

								InvalidateWindowData(WC_VEHICLE_DEPOT, tile);

								InvalidateWindowData(WC_BUILD_VEHICLE, tile);

							}

							cost.AddCost(RailConvertCost(type, totype));

							break;

						default: // RAIL_TILE_NORMAL, RAIL_TILE_SIGNALS

							if (flags & DC_EXEC) {

								/* notify YAPF about the track layout change */

								TrackBits tracks = GetTrackBits(tile);

								while (tracks != TRACK_BIT_NONE) {

									YapfNotifyTrackLayoutChange(tile, RemoveFirstTrack(&tracks));

								}

							}

							cost.AddCost(RailConvertCost(type, totype) * CountBits(GetTrackBits(tile)));

							break;

					}

					break;

				case MP_TUNNELBRIDGE: {

					TileIndex endtile = GetOtherTunnelBridgeEnd(tile);

					/* If both ends of tunnel/bridge are in the range, do not try to convert twice -

					 * it would cause assert because of different test and exec runs */

					if (endtile < tile && TileX(endtile) >= sx && TileX(endtile) <= ex &&

							TileY(endtile) >= sy && TileY(endtile) <= ey) continue;

					/* When not coverting rail <-> el. rail, any vehicle cannot be in tunnel/bridge */

					if (!IsCompatibleRail(GetRailType(tile), totype)) {

						CommandCost ret = TunnelBridgeIsFree(tile, endtile);

						if (ret.Failed()) {

							error = ret;

							continue;

						}

					}

					if (flags & DC_EXEC) {

						Track track = DiagDirToDiagTrack(GetTunnelBridgeDirection(tile));

						if (HasTunnelBridgeReservation(tile)) {

							Train *v = GetTrainForReservation(tile, track);

							if (v != NULL && !HasPowerOnRail(v->railtype, totype)) {

								/* No power on new rail type, reroute. */

								FreeTrainTrackReservation(v);

								*vehicles_affected.Append() = v;

							}

						}

						SetRailType(tile, totype);

						SetRailType(endtile, totype);

						FindVehicleOnPos(tile, &affected_trains, &UpdateTrainPowerProc);

						FindVehicleOnPos(endtile, &affected_trains, &UpdateTrainPowerProc);

						YapfNotifyTrackLayoutChange(tile, track);

						YapfNotifyTrackLayoutChange(endtile, track);

						MarkTileDirtyByTile(tile);

						MarkTileDirtyByTile(endtile);

						if (IsBridge(tile)) {

							TileIndexDiff delta = TileOffsByDiagDir(GetTunnelBridgeDirection(tile));

							TileIndex t = tile + delta;

							for (; t != endtile; t += delta) MarkTileDirtyByTile(t); // TODO encapsulate this into a function

						}

					}

					cost.AddCost((GetTunnelBridgeLength(tile, endtile) + 2) * RailConvertCost(type, totype));

					break;

				}

				default: // MP_STATION, MP_ROAD

					if (flags & DC_EXEC) {

						Track track = ((tt == MP_STATION) ? GetRailStationTrack(tile) : GetCrossingRailTrack(tile));

						YapfNotifyTrackLayoutChange(tile, track);

					}

					cost.AddCost(RailConvertCost(type, totype));

					break;

			}

			for (uint i = 0; i < vehicles_affected.Length(); ++i) {

				TryPathReserve(vehicles_affected[i], true);

			}

		}

	}

	if (flags & DC_EXEC) {

		/* Railtype changed, update trains as when entering different track */

		for (Train **v = affected_trains.Begin(); v != affected_trains.End(); v++) {

		}

	}

	return (cost.GetCost() == 0) ? error : cost;

}

static CommandCost RemoveTrainDepot(TileIndex tile, DoCommandFlag flags)

{

	if (_current_company != OWNER_WATER) {

		CommandCost ret = CheckTileOwnership(tile);

		if (ret.Failed()) return ret;

	}

	CommandCost ret = EnsureNoVehicleOnGround(tile);

	if (ret.Failed()) return ret;

	if (flags & DC_EXEC) {

		/* read variables before the depot is removed */

		DiagDirection dir = GetRailDepotDirection(tile);

		Owner owner = GetTileOwner(tile);

		Train *v = NULL;

		if (HasDepotReservation(tile)) {

			v = GetTrainForReservation(tile, DiagDirToDiagTrack(dir));

			if (v != NULL) FreeTrainTrackReservation(v);

		}

		delete Depot::GetByTile(tile);

		DoClearSquare(tile);

		AddSideToSignalBuffer(tile, dir, owner);

		YapfNotifyTrackLayoutChange(tile, DiagDirToDiagTrack(dir));

		if (v != NULL) TryPathReserve(v, true);

	}

	return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_TRAIN]);

}

static CommandCost ClearTile_Track(TileIndex tile, DoCommandFlag flags)

{

	CommandCost cost(EXPENSES_CONSTRUCTION);

	if (flags & DC_AUTO) {

		if (!IsTileOwner(tile, _current_company)) {

			return_cmd_error(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER);

		}

		if (IsPlainRail(tile)) {

			return_cmd_error(STR_ERROR_MUST_REMOVE_RAILROAD_TRACK);

		} else {

			return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);

		}

	}

	switch (GetRailTileType(tile)) {

		case RAIL_TILE_SIGNALS:

		case RAIL_TILE_NORMAL: {

			Slope tileh = GetTileSlope(tile, NULL);

			/* Is there flat water on the lower halftile, that gets cleared expensively? */

			bool water_ground = (GetRailGroundType(tile) == RAIL_GROUND_WATER && IsSlopeWithOneCornerRaised(tileh));

			TrackBits tracks = GetTrackBits(tile);

			while (tracks != TRACK_BIT_NONE) {

				Track track = RemoveFirstTrack(&tracks);

				CommandCost ret = DoCommand(tile, 0, track, flags, CMD_REMOVE_SINGLE_RAIL);

				if (ret.Failed()) return ret;

				cost.AddCost(ret);

			}

			/* when bankrupting, don't make water dirty, there could be a ship on lower halftile */

			if (water_ground && !(flags & DC_BANKRUPT)) {

				CommandCost ret = EnsureNoVehicleOnGround(tile);

				if (ret.Failed()) return ret;

				/* The track was removed, and left a coast tile. Now also clear the water. */

				if (flags & DC_EXEC) DoClearSquare(tile);

				cost.AddCost(_price[PR_CLEAR_WATER]);

			}

			return cost;

		}

		case RAIL_TILE_DEPOT:

			return RemoveTrainDepot(tile, flags);

		default:

			return CMD_ERROR;

	}

}

/**

 * Get surface height in point (x,y)

 * On tiles with halftile foundations move (x,y) to a safe point wrt. track

 */

static uint GetSaveSlopeZ(uint x, uint y, Track track)

{

	switch (track) {

	TFP_STUCK  = 1,    ///< Proceed till next signal, but ignore being stuck till then. This includes force leaving depots.

	TFP_SIGNAL = 2,    ///< Ignore next signal, after the signal ignore being stucked.

};

typedef SimpleTinyEnumT<TrainForceProceeding, byte> TrainForceProceedingByte;

byte FreightWagonMult(CargoID cargo);

void CheckTrainsLengths();

void FreeTrainTrackReservation(const Train *v, TileIndex origin = INVALID_TILE, Trackdir orig_td = INVALID_TRACKDIR);

bool TryPathReserve(Train *v, bool mark_as_stuck = false, bool first_tile_okay = false);

int GetTrainStopLocation(StationID station_id, TileIndex tile, const Train *v, int *station_ahead, int *station_length);

/** Variables that are cached to improve performance and such */

struct TrainCache {

	/* Cached wagon override spritegroup */

	const struct SpriteGroup *cached_override;

	uint16 last_speed; // NOSAVE: only used in UI

	/* cached values, recalculated on load and each time a vehicle is added to/removed from the consist. */

	uint16 cached_total_length; ///< Length of the whole train, valid only for first engine.