STR_CONFIG_PATCHES_ALLOW_EXCLUSIVE                              :{LTBLUE}Allow buying exclusive transport rights: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_ALLOW_GIVE_MONEY                             :{LTBLUE}Allow sending money to other companies: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_NONUNIFORM_STATIONS                          :{LTBLUE}Nonuniform stations: {ORANGE}{STRING1}

STR_CONFIG_PATCHES_FREIGHT_TRAINS                               :{LTBLUE}Weight multiplier for freight to simulate heavy trains: {ORANGE}{STRING}

STR_CONFIG_PATCHES_STOP_ON_TOWN_ROAD                            :{LTBLUE}Allow drive-through road stops on town owned roads: {ORANGE}{STRING}

STR_CONFIG_PATCHES_ADJACENT_STATIONS                            :{LTBLUE}Allow building adjacent stations: {ORANGE}{STRING}

STR_CONFIG_PATCHES_QUERY_CAPT                                   :{WHITE}Change setting value

STR_CONFIG_PATCHES_SERVICE_INTERVAL_INCOMPATIBLE                :{WHITE}Some or all of the default service interval(s) below are incompatible with the chosen setting! 5-90% and 30-800 days are valid

STR_TEMPERATE_LANDSCAPE                                         :Temperate landscape

STR_SUB_ARCTIC_LANDSCAPE                                        :Sub-arctic landscape

				}

			}

		}

	}

	return InitializeWindowsAndCaches();

	if (!HasOrderPoolFree(1)) return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

		const Order *prev = NULL;

		uint n = 0;

{

	TileIndex tile = v->tile;

		Depot* ret = YapfFindNearestRoadDepot(v);

		return ret;

		NPFFoundTargetData ftd;

		/* See where we are now */

		Trackdir trackdir = GetVehicleTrackdir(v);

			return NULL; /* Target not found */

		}

		/* We do not search in two directions here, why should we? We can't reverse right now can we? */

		RoadFindDepotData rfdd;

		rfdd.owner = v->owner;

		return_track(FindFirstBit2x64(trackdirs));

	}

		Trackdir trackdir = YapfChooseRoadTrack(v, tile, enterdir);

		if (trackdir != INVALID_TRACKDIR) return_track(trackdir);

		return_track(PickRandomBit(trackdirs));

		NPFFindStationOrTileData fstd;

		NPFFoundTargetData ftd;

		Trackdir trackdir;

			to the tile closest to our target. */

			return_track(ftd.best_trackdir);

		}

		DiagDirection dir;

		if (IsTileType(desttile, MP_ROAD)) {

static uint RoadFindPathToStop(const Vehicle *v, TileIndex tile)

{

	uint dist;

		/* use YAPF */

		dist = YapfRoadVehDistanceToTile(v, tile);

	} else {

#include "table/strings.h"

uint16 _sl_version;       ///< the major savegame version identifier

byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

	SDT_BOOL(Patches, mammoth_trains,                0,NN,  true,                    STR_CONFIG_PATCHES_MAMMOTHTRAINS,        NULL),

	SDT_BOOL(Patches, gotodepot,                     0, 0,  true,                    STR_CONFIG_PATCHES_GOTODEPOT,            NULL),

	SDT_BOOL(Patches, roadveh_queue,                 0, 0,  true,                    STR_CONFIG_PATCHES_ROADVEH_QUEUE,        NULL),

	SDT_BOOL(Patches, train_income_warn,             S, 0,  true,                    STR_CONFIG_PATCHES_WARN_INCOME_LESS,     NULL),

	 SDT_VAR(Patches, order_review_system,SLE_UINT8, S,MS,     2,     0,       2, 0, STR_CONFIG_PATCHES_ORDER_REVIEW,         NULL),

	"mammoth_trains",

	"gotodepot",

	"roadveh_queue",

	"train_income_warn",

	"order_review_system",

	"never_expire_vehicles",

	uint16 servint_aircraft;            ///< service interval for aircraft

	uint16 servint_ships;               ///< service interval for ships

	bool autorenew;

	int16 autorenew_months;

	int32 autorenew_money;

	TileIndex tile;

	TileIndex tile2 = v->tile;

		NPFFoundTargetData ftd;

		Trackdir trackdir = GetVehicleTrackdir(v);

		ftd = NPFRouteToDepotTrialError(v->tile, trackdir, false, TRANSPORT_WATER, 0, v->owner, INVALID_RAILTYPES);

		} else {

			best_depot = NULL; /* Did not find target */

		}

		FOR_ALL_DEPOTS(depot) {

			tile = depot->xy;

			if (IsTileDepotType(tile, TRANSPORT_WATER) && IsTileOwner(tile, v->owner)) {

{

	assert(enterdir >= 0 && enterdir <= 3);

		Trackdir trackdir = YapfChooseShipTrack(v, tile, enterdir, tracks);

		return (trackdir != INVALID_TRACKDIR) ? TrackdirToTrack(trackdir) : INVALID_TRACK;

		NPFFindStationOrTileData fstd;

		NPFFoundTargetData ftd;

		Trackdir trackdir = GetVehicleTrackdir(v);

		} else {

			return INVALID_TRACK; /* Already at target, reverse? */

		}

		uint tot_dist, dist;

		Track track;

		TileIndex tile2;

		return tfdd;

	}

		bool found = YapfFindNearestRailDepotTwoWay(v, max_distance, NPF_INFINITE_PENALTY, &tfdd.tile, &tfdd.reverse);

		tfdd.best_length = found ? max_distance / 2 : -1; // some fake distance or NOT_FOUND

		Vehicle* last = GetLastVehicleInChain(v);

		Trackdir trackdir = GetVehicleTrackdir(v);

		Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));

			tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;

			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;

		}

		/* search in the forward direction first. */

		DiagDirection i = TrainExitDir(v->direction, v->u.rail.track);

		NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);

	/* quick return in case only one possible track is available */

	if (KillFirstBit(tracks) == TRACK_BIT_NONE) return FindFirstTrack(tracks);

		Trackdir trackdir = YapfChooseRailTrack(v, tile, enterdir, tracks, &path_not_found);

		if (trackdir != INVALID_TRACKDIR) {

			best_track = TrackdirToTrack(trackdir);

		} else {

			best_track = FindFirstTrack(tracks);

		}

		void* perf = NpfBeginInterval();

		NPFFindStationOrTileData fstd;

		int time = NpfEndInterval(perf);

		DEBUG(yapf, 4, "[NPFT] %d us - %d rounds - %d open - %d closed -- ", time, 0, _aystar_stats_open_size, _aystar_stats_closed_size);

		void* perf = NpfBeginInterval();

		TrainTrackFollowerData fd;

	int i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];

		reverse_best = YapfCheckReverseTrain(v);

		NPFFindStationOrTileData fstd;

		NPFFoundTargetData ftd;

		Trackdir trackdir, trackdir_rev;

				reverse_best = false;

			}

		}

		int best_track = -1;

		uint reverse = 0;

		uint best_bird_dist  = 0;

				 * the signal status. */

				uint32 tracks = ts | (ts >> 8);

				TrackBits bits = (TrackBits)(tracks & TRACK_BIT_MASK);

					/* We allow wagons to make 90 deg turns, because forbid_90_deg

					 * can be switched on halfway a turn */

					bits &= ~TrackCrossesTracks(FindFirstTrack(v->u.rail.track));

	/* mask unreachable track bits if we are forbidden to do 90deg turns */

	TrackBits bits = (TrackBits)((ts | (ts >> 8)) & TRACK_BIT_MASK);

		bits &= ~TrackCrossesTracks(FindFirstTrack(v->u.rail.track));

	}

	EV_BUBBLE          = 9

};

#endif /* VEHICLE_TYPE_H */