(svn r8033) [cpp] - Prepare for merge from branches/cpp (all .c files renamed to .cpp)

1 files changed, 0 insertions, 3228 deletions

diff --git a/src/vehicle.c b/src/vehicle.c
deleted file mode 100644
index c7b5365e4..000000000
--- a/src/vehicle.c
+++ /dev/null
@@ -1,3228 +0,0 @@
-/* $Id$ */
-
-#include "stdafx.h"
-#include "openttd.h"
-#include "road_map.h"
-#include "roadveh.h"
-#include "ship.h"
-#include "spritecache.h"
-#include "table/sprites.h"
-#include "table/strings.h"
-#include "functions.h"
-#include "map.h"
-#include "tile.h"
-#include "vehicle.h"
-#include "gfx.h"
-#include "viewport.h"
-#include "news.h"
-#include "command.h"
-#include "saveload.h"
-#include "player.h"
-#include "engine.h"
-#include "sound.h"
-#include "debug.h"
-#include "vehicle_gui.h"
-#include "depot.h"
-#include "station.h"
-#include "rail.h"
-#include "train.h"
-#include "aircraft.h"
-#include "industry_map.h"
-#include "station_map.h"
-#include "water_map.h"
-#include "network/network.h"
-#include "yapf/yapf.h"
-#include "date.h"
-#include "newgrf_engine.h"
-#include "newgrf_sound.h"
-
-#define INVALID_COORD (-0x8000)
-#define GEN_HASH(x, y) ((GB((y), 6, 6) << 6) + GB((x), 7, 6))
-
-/*
- * These command macros are used to call vehicle type specific commands with non type specific commands
- * it should be used like: DoCommandP(x, y, p1, p2, flags, CMD_STARTSTOP_VEH(v->type))
- * that line will start/stop a vehicle nomatter what type it is
- * VEH_Train is used as an offset because the vehicle type values doesn't start with 0
- */
-
-#define CMD_BUILD_VEH(x) _veh_build_proc_table[ x - VEH_Train]
-#define CMD_SELL_VEH(x)  _veh_sell_proc_table [ x - VEH_Train]
-#define CMD_REFIT_VEH(x) _veh_refit_proc_table[ x - VEH_Train]
-
-static const uint32 _veh_build_proc_table[] = {
-	CMD_BUILD_RAIL_VEHICLE,
-	CMD_BUILD_ROAD_VEH,
-	CMD_BUILD_SHIP,
-	CMD_BUILD_AIRCRAFT,
-};
-static const uint32 _veh_sell_proc_table[] = {
-	CMD_SELL_RAIL_WAGON,
-	CMD_SELL_ROAD_VEH,
-	CMD_SELL_SHIP,
-	CMD_SELL_AIRCRAFT,
-};
-
-static const uint32 _veh_refit_proc_table[] = {
-	CMD_REFIT_RAIL_VEHICLE,
-	CMD_REFIT_ROAD_VEH,
-	CMD_REFIT_SHIP,
-	CMD_REFIT_AIRCRAFT,
-};
-
-const uint32 _send_to_depot_proc_table[] = {
-	CMD_SEND_TRAIN_TO_DEPOT,
-	CMD_SEND_ROADVEH_TO_DEPOT,
-	CMD_SEND_SHIP_TO_DEPOT,
-	CMD_SEND_AIRCRAFT_TO_HANGAR,
-};
-
-
-enum {
-	BLOCKS_FOR_SPECIAL_VEHICLES   = 2, ///< Blocks needed for special vehicles
-};
-
-/**
- * Called if a new block is added to the vehicle-pool
- */
-static void VehiclePoolNewBlock(uint start_item)
-{
-	Vehicle *v;
-
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
-	 * TODO - This is just a temporary stage, this will be removed. */
-	for (v = GetVehicle(start_item); v != NULL; v = (v->index + 1U < GetVehiclePoolSize()) ? GetVehicle(v->index + 1) : NULL) v->index = start_item++;
-}
-
-/* Initialize the vehicle-pool */
-DEFINE_OLD_POOL(Vehicle, Vehicle, VehiclePoolNewBlock, NULL)
-
-void VehicleServiceInDepot(Vehicle *v)
-{
-	v->date_of_last_service = _date;
-	v->breakdowns_since_last_service = 0;
-	v->reliability = GetEngine(v->engine_type)->reliability;
-	InvalidateWindow(WC_VEHICLE_DETAILS, v->index); // ensure that last service date and reliability are updated
-}
-
-bool VehicleNeedsService(const Vehicle *v)
-{
-	if (v->vehstatus & VS_CRASHED)
-		return false; /* Crashed vehicles don't need service anymore */
-
-	if (_patches.no_servicing_if_no_breakdowns && _opt.diff.vehicle_breakdowns == 0) {
-		return EngineHasReplacementForPlayer(GetPlayer(v->owner), v->engine_type);  /* Vehicles set for autoreplacing needs to go to a depot even if breakdowns are turned off */
-	}
-
-	return _patches.servint_ispercent ?
-		(v->reliability < GetEngine(v->engine_type)->reliability * (100 - v->service_interval) / 100) :
-		(v->date_of_last_service + v->service_interval < _date);
-}
-
-StringID VehicleInTheWayErrMsg(const Vehicle* v)
-{
-	switch (v->type) {
-		case VEH_Train:    return STR_8803_TRAIN_IN_THE_WAY;
-		case VEH_Road:     return STR_9000_ROAD_VEHICLE_IN_THE_WAY;
-		case VEH_Aircraft: return STR_A015_AIRCRAFT_IN_THE_WAY;
-		default:           return STR_980E_SHIP_IN_THE_WAY;
-	}
-}
-
-static void *EnsureNoVehicleProc(Vehicle *v, void *data)
-{
-	if (v->tile != *(const TileIndex*)data || v->type == VEH_Disaster)
-		return NULL;
-
-	_error_message = VehicleInTheWayErrMsg(v);
-	return v;
-}
-
-bool EnsureNoVehicle(TileIndex tile)
-{
-	return VehicleFromPos(tile, &tile, EnsureNoVehicleProc) == NULL;
-}
-
-static void *EnsureNoVehicleProcZ(Vehicle *v, void *data)
-{
-	const TileInfo *ti = data;
-
-	if (v->tile != ti->tile || v->type == VEH_Disaster) return NULL;
-	if (v->z_pos > ti->z) return NULL;
-
-	_error_message = VehicleInTheWayErrMsg(v);
-	return v;
-}
-
-
-bool EnsureNoVehicleOnGround(TileIndex tile)
-{
-	TileInfo ti;
-
-	ti.tile = tile;
-	ti.z = GetTileMaxZ(tile);
-	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ) == NULL;
-}
-
-Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z)
-{
-	TileInfo ti;
-
-	ti.tile = tile;
-	ti.z = z;
-
-	return VehicleFromPos(tile, &ti, EnsureNoVehicleProcZ);
-}
-
-Vehicle *FindVehicleBetween(TileIndex from, TileIndex to, byte z)
-{
-	int x1 = TileX(from);
-	int y1 = TileY(from);
-	int x2 = TileX(to);
-	int y2 = TileY(to);
-	Vehicle *veh;
-
-	/* Make sure x1 < x2 or y1 < y2 */
-	if (x1 > x2 || y1 > y2) {
-		intswap(x1,x2);
-		intswap(y1,y2);
-	}
-	FOR_ALL_VEHICLES(veh) {
-		if ((veh->type == VEH_Train || veh->type == VEH_Road) && (z==0xFF || veh->z_pos == z)) {
-			if ((veh->x_pos>>4) >= x1 && (veh->x_pos>>4) <= x2 &&
-					(veh->y_pos>>4) >= y1 && (veh->y_pos>>4) <= y2) {
-				return veh;
-			}
-		}
-	}
-	return NULL;
-}
-
-
-static void UpdateVehiclePosHash(Vehicle* v, int x, int y);
-
-void VehiclePositionChanged(Vehicle *v)
-{
-	int img = v->cur_image;
-	Point pt = RemapCoords(v->x_pos + v->x_offs, v->y_pos + v->y_offs, v->z_pos);
-	const Sprite* spr = GetSprite(img);
-
-	pt.x += spr->x_offs;
-	pt.y += spr->y_offs;
-
-	UpdateVehiclePosHash(v, pt.x, pt.y);
-
-	v->left_coord = pt.x;
-	v->top_coord = pt.y;
-	v->right_coord = pt.x + spr->width + 2;
-	v->bottom_coord = pt.y + spr->height + 2;
-}
-
-// Called after load to update coordinates
-void AfterLoadVehicles(void)
-{
-	Vehicle *v;
-
-	FOR_ALL_VEHICLES(v) {
-		v->first = NULL;
-		if (v->type == VEH_Train) v->u.rail.first_engine = INVALID_ENGINE;
-	}
-
-	FOR_ALL_VEHICLES(v) {
-		if (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v)))
-			TrainConsistChanged(v);
-	}
-
-	FOR_ALL_VEHICLES(v) {
-		switch (v->type) {
-			case VEH_Train: v->cur_image = GetTrainImage(v, v->direction); break;
-			case VEH_Road: v->cur_image = GetRoadVehImage(v, v->direction); break;
-			case VEH_Ship: v->cur_image = GetShipImage(v, v->direction); break;
-			case VEH_Aircraft:
-				if (v->subtype == 0 || v->subtype == 2) {
-					v->cur_image = GetAircraftImage(v, v->direction);
-					if (v->next != NULL) v->next->cur_image = v->cur_image;
-				}
-				break;
-			default: break;
-		}
-
-		v->left_coord = INVALID_COORD;
-		VehiclePositionChanged(v);
-	}
-}
-
-static Vehicle *InitializeVehicle(Vehicle *v)
-{
-	VehicleID index = v->index;
-	memset(v, 0, sizeof(Vehicle));
-	v->index = index;
-
-	assert(v->orders == NULL);
-
-	v->left_coord = INVALID_COORD;
-	v->first = NULL;
-	v->next = NULL;
-	v->next_hash = NULL;
-	v->string_id = 0;
-	v->next_shared = NULL;
-	v->prev_shared = NULL;
-	v->depot_list  = NULL;
-	v->random_bits = 0;
-	return v;
-}
-
-/**
- * Get a value for a vehicle's random_bits.
- * @return A random value from 0 to 255.
- */
-byte VehicleRandomBits(void)
-{
-	return GB(Random(), 0, 8);
-}
-
-Vehicle *ForceAllocateSpecialVehicle(void)
-{
-	/* This stays a strange story.. there should always be room for special
-	 * vehicles (special effects all over the map), but with 65k of vehicles
-	 * is this realistic to double-check for that? For now we just reserve
-	 * BLOCKS_FOR_SPECIAL_VEHICLES times block_size vehicles that may only
-	 * be used for special vehicles.. should work nicely :) */
-
-	Vehicle *v;
-
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
-	 * TODO - This is just a temporary stage, this will be removed. */
-	for (v = GetVehicle(0); v != NULL; v = (v->index + 1U < GetVehiclePoolSize()) ? GetVehicle(v->index + 1) : NULL) {
-		/* No more room for the special vehicles, return NULL */
-		if (v->index >= (1 << Vehicle_POOL_BLOCK_SIZE_BITS) * BLOCKS_FOR_SPECIAL_VEHICLES)
-			return NULL;
-
-		if (!IsValidVehicle(v)) return InitializeVehicle(v);
-	}
-
-	return NULL;
-}
-
-/*
- * finds a free vehicle in the memory or allocates a new one
- * returns a pointer to the first free vehicle or NULL if all vehicles are in use
- * *skip_vehicles is an offset to where in the array we should begin looking
- * this is to avoid looping though the same vehicles more than once after we learned that they are not free
- * this feature is used by AllocateVehicles() since it need to allocate more than one and when
- * another block is added to _Vehicle_pool, since we only do that when we know it's already full
- */
-static Vehicle *AllocateSingleVehicle(VehicleID *skip_vehicles)
-{
-	/* See note by ForceAllocateSpecialVehicle() why we skip the
-	 * first blocks */
-	Vehicle *v;
-	const int offset = (1 << Vehicle_POOL_BLOCK_SIZE_BITS) * BLOCKS_FOR_SPECIAL_VEHICLES;
-
-	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.
-	 * TODO - This is just a temporary stage, this will be removed. */
-	if (*skip_vehicles < (_Vehicle_pool.total_items - offset)) { // make sure the offset in the array is not larger than the array itself
-		for (v = GetVehicle(offset + *skip_vehicles); v != NULL; v = (v->index + 1U < GetVehiclePoolSize()) ? GetVehicle(v->index + 1) : NULL) {
-			(*skip_vehicles)++;
-			if (!IsValidVehicle(v)) return InitializeVehicle(v);
-		}
-	}
-
-	/* Check if we can add a block to the pool */
-	if (AddBlockToPool(&_Vehicle_pool))
-		return AllocateSingleVehicle(skip_vehicles);
-
-	return NULL;
-}
-
-
-Vehicle *AllocateVehicle(void)
-{
-	VehicleID counter = 0;
-	return AllocateSingleVehicle(&counter);
-}
-
-
-/** Allocates a lot of vehicles and frees them again
- * @param vl pointer to an array of vehicles to get allocated. Can be NULL if the vehicles aren't needed (makes it test only)
- * @param num number of vehicles to allocate room for
- * @return true if there is room to allocate all the vehicles
- */
-bool AllocateVehicles(Vehicle **vl, int num)
-{
-	int i;
-	Vehicle *v;
-	VehicleID counter = 0;
-
-	for (i = 0; i != num; i++) {
-		v = AllocateSingleVehicle(&counter);
-		if (v == NULL) {
-			return false;
-		}
-		if (vl != NULL) {
-			vl[i] = v;
-		}
-	}
-
-	return true;
-}
-
-
-static Vehicle *_vehicle_position_hash[0x1000];
-
-void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
-{
-	Point pt = RemapCoords(TileX(tile) * TILE_SIZE, TileY(tile) * TILE_SIZE, 0);
-
-	// The hash area to scan
-	const int xl = GB(pt.x - 174, 7, 6);
-	const int xu = GB(pt.x + 104, 7, 6);
-	const int yl = GB(pt.y - 294, 6, 6) << 6;
-	const int yu = GB(pt.y +  56, 6, 6) << 6;
-
-	int x;
-	int y;
-
-	for (y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) {
-		for (x = xl;; x = (x + 1) & 0x3F) {
-			Vehicle *v = _vehicle_position_hash[(x + y) & 0xFFFF];
-
-			while (v != NULL) {
-				void* a = proc(v, data);
-
-				if (a != NULL) return a;
-				v = v->next_hash;
-			}
-
-			if (x == xu) break;
-		}
-
-		if (y == yu) break;
-	}
-	return NULL;
-}
-
-
-static void UpdateVehiclePosHash(Vehicle* v, int x, int y)
-{
-	Vehicle **old_hash, **new_hash;
-	int old_x = v->left_coord;
-	int old_y = v->top_coord;
-
-	new_hash = (x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(x,y)];
-	old_hash = (old_x == INVALID_COORD) ? NULL : &_vehicle_position_hash[GEN_HASH(old_x, old_y)];
-
-	if (old_hash == new_hash) return;
-
-	/* remove from hash table? */
-	if (old_hash != NULL) {
-		Vehicle *last = NULL;
-		Vehicle *u = *old_hash;
-		while (u != v) {
-			last = u;
-			u = u->next_hash;
-			assert(u != NULL);
-		}
-
-		if (last == NULL) {
-			*old_hash = v->next_hash;
-		} else {
-			last->next_hash = v->next_hash;
-		}
-	}
-
-	/* insert into hash table? */
-	if (new_hash != NULL) {
-		v->next_hash = *new_hash;
-		*new_hash = v;
-	}
-}
-
-void ResetVehiclePosHash(void)
-{
-	memset(_vehicle_position_hash, 0, sizeof(_vehicle_position_hash));
-}
-
-void InitializeVehicles(void)
-{
-	uint i;
-
-	/* Clean the vehicle pool, and reserve enough blocks
-	 *  for the special vehicles, plus one for all the other
-	 *  vehicles (which is increased on-the-fly) */
-	CleanPool(&_Vehicle_pool);
-	AddBlockToPool(&_Vehicle_pool);
-	for (i = 0; i < BLOCKS_FOR_SPECIAL_VEHICLES; i++) {
-		AddBlockToPool(&_Vehicle_pool);
-	}
-
-	ResetVehiclePosHash();
-}
-
-Vehicle *GetLastVehicleInChain(Vehicle *v)
-{
-	while (v->next != NULL) v = v->next;
-	return v;
-}
-
-/** Finds the previous vehicle in a chain, by a brute force search.
- * This old function is REALLY slow because it searches through all vehicles to
- * find the previous vehicle, but if v->first has not been set, then this function
- * will need to be used to find the previous one. This function should never be
- * called by anything but GetFirstVehicleInChain
- */
-static Vehicle *GetPrevVehicleInChain_bruteforce(const Vehicle *v)
-{
-	Vehicle *u;
-
-	FOR_ALL_VEHICLES(u) if (u->type == VEH_Train && u->next == v) return u;
-
-	return NULL;
-}
-
-/** Find the previous vehicle in a chain, by using the v->first cache.
- * While this function is fast, it cannot be used in the GetFirstVehicleInChain
- * function, otherwise you'll end up in an infinite loop call
- */
-Vehicle *GetPrevVehicleInChain(const Vehicle *v)
-{
-	Vehicle *u;
-	assert(v != NULL);
-
-	u = GetFirstVehicleInChain(v);
-
-	// Check to see if this is the first
-	if (v == u) return NULL;
-
-	for (; u->next != v; u = u->next) assert(u->next != NULL);
-
-	return u;
-}
-
-/** Finds the first vehicle in a chain.
- * This function reads out the v->first cache. Should the cache be dirty,
- * it determines the first vehicle in a chain, and updates the cache.
- */
-Vehicle *GetFirstVehicleInChain(const Vehicle *v)
-{
-	Vehicle* u;
-
-	assert(v != NULL);
-
-	if (v->first != NULL) {
-		if (IsFrontEngine(v->first) || IsFreeWagon(v->first)) return v->first;
-
-		DEBUG(misc, 0, "v->first cache faulty. We shouldn't be here, rebuilding cache!");
-	}
-
-	/* It is the fact (currently) that newly built vehicles do not have
-	 * their ->first pointer set. When this is the case, go up to the
-	 * first engine and set the pointers correctly. Also the first pointer
-	 * is not saved in a savegame, so this has to be fixed up after loading */
-
-	/* Find the 'locomotive' or the first wagon in a chain */
-	while ((u = GetPrevVehicleInChain_bruteforce(v)) != NULL) v = u;
-
-	/* Set the first pointer of all vehicles in that chain to the first wagon */
-	if (IsFrontEngine(v) || IsFreeWagon(v))
-		for (u = (Vehicle *)v; u != NULL; u = u->next) u->first = (Vehicle *)v;
-
-	return (Vehicle*)v;
-}
-
-uint CountVehiclesInChain(const Vehicle* v)
-{
-	uint count = 0;
-	do count++; while ((v = v->next) != NULL);
-	return count;
-}
-
-/** Check if a vehicle is counted in num_engines in each player struct
- * @param *v Vehicle to test
- * @return true if the vehicle is counted in num_engines
- */
-bool IsEngineCountable(const Vehicle *v)
-{
-	switch (v->type) {
-		case VEH_Aircraft: return (v->subtype <= 2); // don't count plane shadows and helicopter rotors
-		case VEH_Train:
-			return !IsArticulatedPart(v) && // tenders and other articulated parts
-			(!IsMultiheaded(v) || IsTrainEngine(v)); // rear parts of multiheaded engines
-		case VEH_Road:
-		case VEH_Ship:
-			return true;
-		default: return false; // Only count player buildable vehicles
-	}
-}
-
-void DestroyVehicle(Vehicle *v)
-{
-	if (IsEngineCountable(v)) GetPlayer(v->owner)->num_engines[v->engine_type]--;
-
-	DeleteVehicleNews(v->index, INVALID_STRING_ID);
-
-	DeleteName(v->string_id);
-	if (v->type == VEH_Road) ClearSlot(v);
-
-	if (v->type != VEH_Train || (v->type == VEH_Train && (IsFrontEngine(v) || IsFreeWagon(v)))) {
-		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
-	}
-
-	UpdateVehiclePosHash(v, INVALID_COORD, 0);
-	v->next_hash = NULL;
-	if (v->orders != NULL) DeleteVehicleOrders(v);
-
-	/* Now remove any artic part. This will trigger an other
-	 *  destroy vehicle, which on his turn can remove any
-	 *  other artic parts. */
-	if (EngineHasArticPart(v)) DeleteVehicle(v->next);
-}
-
-void DeleteVehicleChain(Vehicle *v)
-{
-	do {
-		Vehicle *u = v;
-		v = GetNextVehicle(v);
-		DeleteVehicle(u);
-	} while (v != NULL);
-}
-
-
-void Aircraft_Tick(Vehicle *v);
-void RoadVeh_Tick(Vehicle *v);
-void Ship_Tick(Vehicle *v);
-void Train_Tick(Vehicle *v);
-static void EffectVehicle_Tick(Vehicle *v);
-void DisasterVehicle_Tick(Vehicle *v);
-static int32 MaybeReplaceVehicle(Vehicle *v, bool check, bool display_costs);
-
-// head of the linked list to tell what vehicles that visited a depot in a tick
-static Vehicle* _first_veh_in_depot_list;
-
-/** Adds a vehicle to the list of vehicles, that visited a depot this tick
- * @param *v vehicle to add
- */
-void VehicleEnteredDepotThisTick(Vehicle *v)
-{
-	// we need to set v->leave_depot_instantly as we have no control of it's contents at this time
-	if (HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT) && !HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS) && v->current_order.type == OT_GOTO_DEPOT) {
-		// we keep the vehicle in the depot since the user ordered it to stay
-		v->leave_depot_instantly = false;
-	} else {
-		// the vehicle do not plan on stopping in the depot, so we stop it to ensure that it will not reserve the path
-		// out of the depot before we might autoreplace it to a different engine. The new engine would not own the reserved path
-		// we store that we stopped the vehicle, so autoreplace can start it again
-		v->vehstatus |= VS_STOPPED;
-		v->leave_depot_instantly = true;
-	}
-
-	if (_first_veh_in_depot_list == NULL) {
-		_first_veh_in_depot_list = v;
-	} else {
-		Vehicle *w = _first_veh_in_depot_list;
-		while (w->depot_list != NULL) w = w->depot_list;
-		w->depot_list = v;
-	}
-}
-
-typedef void VehicleTickProc(Vehicle*);
-static VehicleTickProc* _vehicle_tick_procs[] = {
-	Train_Tick,
-	RoadVeh_Tick,
-	Ship_Tick,
-	Aircraft_Tick,
-	EffectVehicle_Tick,
-	DisasterVehicle_Tick,
-};
-
-void CallVehicleTicks(void)
-{
-	Vehicle *v;
-
-#ifdef ENABLE_NETWORK
-	// hotfix for desync problem:
-	//  for MP games invalidate the YAPF cache every tick to keep it exactly the same on the server and all clients
-	if (_networking) {
-		YapfNotifyTrackLayoutChange(0, 0);
-	}
-#endif //ENABLE_NETWORK
-
-	_first_veh_in_depot_list = NULL; // now we are sure it's initialized at the start of each tick
-
-	FOR_ALL_VEHICLES(v) {
-		_vehicle_tick_procs[v->type - 0x10](v);
-
-		switch (v->type) {
-			case VEH_Train:
-			case VEH_Road:
-			case VEH_Aircraft:
-			case VEH_Ship:
-				if (v->type == VEH_Train && IsTrainWagon(v)) continue;
-				if (v->type == VEH_Aircraft && v->subtype > 0) continue;
-
-				v->motion_counter += (v->direction & 1) ? (v->cur_speed * 3) / 4 : v->cur_speed;
-				/* Play a running sound if the motion counter passes 256 (Do we not skip sounds?) */
-				if (GB(v->motion_counter, 0, 8) < v->cur_speed) PlayVehicleSound(v, VSE_RUNNING);
-
-				/* Play an alterate running sound every 16 ticks */
-				if (GB(v->tick_counter, 0, 4) == 0) PlayVehicleSound(v, v->cur_speed > 0 ? VSE_RUNNING_16 : VSE_STOPPED_16);
-		}
-	}
-
-	// now we handle all the vehicles that entered a depot this tick
-	v = _first_veh_in_depot_list;
-	while (v != NULL) {
-		Vehicle *w = v->depot_list;
-		v->depot_list = NULL; // it should always be NULL at the end of each tick
-		MaybeReplaceVehicle(v, false, true);
-		v = w;
-	}
-}
-
-static bool CanFillVehicle_FullLoadAny(Vehicle *v)
-{
-	uint32 full = 0, not_full = 0;
-	bool keep_loading = false;
-	const GoodsEntry *ge = GetStation(v->last_station_visited)->goods;
-
-	//special handling of aircraft
-
-	//if the aircraft carries passengers and is NOT full, then
-	//continue loading, no matter how much mail is in
-	if (v->type == VEH_Aircraft &&
-			v->cargo_type == CT_PASSENGERS &&
-			v->cargo_cap != v->cargo_count) {
-		return true;
-	}
-
-	// patch should return "true" to continue loading, i.e. when there is no cargo type that is fully loaded.
-	do {
-		//Should never happen, but just in case future additions change this
-		assert(v->cargo_type<32);
-
-		if (v->cargo_cap != 0) {
-			uint32 mask = 1 << v->cargo_type;
-
-			if (v->cargo_cap == v->cargo_count) {
-				full |= mask;
-			} else if (GB(ge[v->cargo_type].waiting_acceptance, 0, 12) > 0 ||
-					(HASBIT(v->load_status, LS_CARGO_UNLOADING) && (ge[v->cargo_type].waiting_acceptance & 0x8000))) {
-				/* If there is any cargo waiting, or this vehicle is still unloading
-				 * and the station accepts the cargo, don't leave the station. */
-				keep_loading = true;
-			} else {
-				not_full |= mask;
-			}
-		}
-	} while ((v = v->next) != NULL);
-
-	// continue loading if there is a non full cargo type and no cargo type that is full
-	return keep_loading || (not_full && (full & ~not_full) == 0);
-}
-
-bool CanFillVehicle(Vehicle *v)
-{
-	TileIndex tile = v->tile;
-
-	if (IsTileType(tile, MP_STATION) ||
-			(v->type == VEH_Ship && (
-				IsTileType(TILE_ADDXY(tile,  1,  0), MP_STATION) ||
-				IsTileType(TILE_ADDXY(tile, -1,  0), MP_STATION) ||
-				IsTileType(TILE_ADDXY(tile,  0,  1), MP_STATION) ||
-				IsTileType(TILE_ADDXY(tile,  0, -1), MP_STATION) ||
-				IsTileType(TILE_ADDXY(tile, -2,  0), MP_STATION)
-			))) {
-
-		// If patch is active, use alternative CanFillVehicle-function
-		if (_patches.full_load_any && v->current_order.flags & OF_FULL_LOAD) return CanFillVehicle_FullLoadAny(v);
-
-		do {
-			if (v->cargo_count != v->cargo_cap) return true;
-		} while ((v = v->next) != NULL);
-	}
-	return false;
-}
-
-/** Check if a given engine type can be refitted to a given cargo
- * @param engine_type Engine type to check
- * @param cid_to check refit to this cargo-type
- * @return true if it is possible, false otherwise
- */
-bool CanRefitTo(EngineID engine_type, CargoID cid_to)
-{
-	CargoID cid = _global_cargo_id[_opt_ptr->landscape][cid_to];
-	return HASBIT(EngInfo(engine_type)->refit_mask, cid);
-}
-
-/** Find the first cargo type that an engine can be refitted to.
- * @param engine Which engine to find cargo for.
- * @return A climate dependent cargo type. CT_INVALID is returned if not refittable.
- */
-CargoID FindFirstRefittableCargo(EngineID engine_type)
-{
-	CargoID cid;
-	uint32 refit_mask = EngInfo(engine_type)->refit_mask;
-
-	if (refit_mask != 0) {
-		for (cid = CT_PASSENGERS; cid < NUM_CARGO; cid++) {
-			if (HASBIT(refit_mask, _global_cargo_id[_opt_ptr->landscape][cid])) return cid;
-		}
-	}
-
-	return CT_INVALID;
-}
-
-/** Learn the price of refitting a certain engine
-* @param engine Which engine to refit
-* @return Price for refitting
-*/
-int32 GetRefitCost(EngineID engine_type)
-{
-	int32 base_cost = 0;
-
-	switch (GetEngine(engine_type)->type) {
-		case VEH_Ship: base_cost = _price.ship_base; break;
-		case VEH_Road: base_cost = _price.roadveh_base; break;
-		case VEH_Aircraft: base_cost = _price.aircraft_base; break;
-		case VEH_Train:
-			base_cost = 2 * ((RailVehInfo(engine_type)->flags & RVI_WAGON) ?
-							 _price.build_railwagon : _price.build_railvehicle);
-			break;
-		default: NOT_REACHED(); break;
-	}
-	return (EngInfo(engine_type)->refit_cost * base_cost) >> 10;
-}
-
-static void DoDrawVehicle(const Vehicle *v)
-{
-	uint32 image = v->cur_image;
-
-	if (v->vehstatus & VS_SHADOW) {
-		MAKE_TRANSPARENT(image);
-	} else if (v->vehstatus & VS_DEFPAL) {
-		image |= (v->vehstatus & VS_CRASHED) ? PALETTE_CRASH : GetVehiclePalette(v);
-	}
-
-	AddSortableSpriteToDraw(image, v->x_pos + v->x_offs, v->y_pos + v->y_offs,
-		v->sprite_width, v->sprite_height, v->z_height, v->z_pos);
-}
-
-void ViewportAddVehicles(DrawPixelInfo *dpi)
-{
-	// The bounding rectangle
-	const int l = dpi->left;
-	const int r = dpi->left + dpi->width;
-	const int t = dpi->top;
-	const int b = dpi->top + dpi->height;
-
-	// The hash area to scan
-	const int xl = GB(l - 70, 7, 6);
-	const int xu = GB(r,      7, 6);
-	const int yl = GB(t - 70, 6, 6) << 6;
-	const int yu = GB(b,      6, 6) << 6;
-
-	int x;
-	int y;
-
-	for (y = yl;; y = (y + (1 << 6)) & (0x3F << 6)) {
-		for (x = xl;; x = (x + 1) & 0x3F) {
-			const Vehicle *v = _vehicle_position_hash[(x + y) & 0xFFFF];
-
-			while (v != NULL) {
-				if (!(v->vehstatus & VS_HIDDEN) &&
-						l <= v->right_coord &&
-						t <= v->bottom_coord &&
-						r >= v->left_coord &&
-						b >= v->top_coord) {
-					DoDrawVehicle(v);
-				}
-				v = v->next_hash;
-			}
-
-			if (x == xu) break;
-		}
-
-		if (y == yu) break;
-	}
-}
-
-static void ChimneySmokeInit(Vehicle *v)
-{
-	uint32 r = Random();
-	v->cur_image = SPR_CHIMNEY_SMOKE_0 + GB(r, 0, 3);
-	v->progress = GB(r, 16, 3);
-}
-
-static void ChimneySmokeTick(Vehicle *v)
-{
-	if (v->progress > 0) {
-		v->progress--;
-	} else {
-		TileIndex tile;
-
-		BeginVehicleMove(v);
-
-		tile = TileVirtXY(v->x_pos, v->y_pos);
-		if (!IsTileType(tile, MP_INDUSTRY)) {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-			return;
-		}
-
-		if (v->cur_image != SPR_CHIMNEY_SMOKE_7) {
-			v->cur_image++;
-		} else {
-			v->cur_image = SPR_CHIMNEY_SMOKE_0;
-		}
-		v->progress = 7;
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	}
-}
-
-static void SteamSmokeInit(Vehicle *v)
-{
-	v->cur_image = SPR_STEAM_SMOKE_0;
-	v->progress = 12;
-}
-
-static void SteamSmokeTick(Vehicle *v)
-{
-	bool moved = false;
-
-	BeginVehicleMove(v);
-
-	v->progress++;
-
-	if ((v->progress & 7) == 0) {
-		v->z_pos++;
-		moved = true;
-	}
-
-	if ((v->progress & 0xF) == 4) {
-		if (v->cur_image != SPR_STEAM_SMOKE_4) {
-			v->cur_image++;
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-			return;
-		}
-		moved = true;
-	}
-
-	if (moved) {
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	}
-}
-
-static void DieselSmokeInit(Vehicle *v)
-{
-	v->cur_image = SPR_DIESEL_SMOKE_0;
-	v->progress = 0;
-}
-
-static void DieselSmokeTick(Vehicle *v)
-{
-	v->progress++;
-
-	if ((v->progress & 3) == 0) {
-		BeginVehicleMove(v);
-		v->z_pos++;
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	} else if ((v->progress & 7) == 1) {
-		BeginVehicleMove(v);
-		if (v->cur_image != SPR_DIESEL_SMOKE_5) {
-			v->cur_image++;
-			VehiclePositionChanged(v);
-			EndVehicleMove(v);
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-		}
-	}
-}
-
-static void ElectricSparkInit(Vehicle *v)
-{
-	v->cur_image = SPR_ELECTRIC_SPARK_0;
-	v->progress = 1;
-}
-
-static void ElectricSparkTick(Vehicle *v)
-{
-	if (v->progress < 2) {
-		v->progress++;
-	} else {
-		v->progress = 0;
-		BeginVehicleMove(v);
-		if (v->cur_image != SPR_ELECTRIC_SPARK_5) {
-			v->cur_image++;
-			VehiclePositionChanged(v);
-			EndVehicleMove(v);
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-		}
-	}
-}
-
-static void SmokeInit(Vehicle *v)
-{
-	v->cur_image = SPR_SMOKE_0;
-	v->progress = 12;
-}
-
-static void SmokeTick(Vehicle *v)
-{
-	bool moved = false;
-
-	BeginVehicleMove(v);
-
-	v->progress++;
-
-	if ((v->progress & 3) == 0) {
-		v->z_pos++;
-		moved = true;
-	}
-
-	if ((v->progress & 0xF) == 4) {
-		if (v->cur_image != SPR_SMOKE_4) {
-			v->cur_image++;
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-			return;
-		}
-		moved = true;
-	}
-
-	if (moved) {
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	}
-}
-
-static void ExplosionLargeInit(Vehicle *v)
-{
-	v->cur_image = SPR_EXPLOSION_LARGE_0;
-	v->progress = 0;
-}
-
-static void ExplosionLargeTick(Vehicle *v)
-{
-	v->progress++;
-	if ((v->progress & 3) == 0) {
-		BeginVehicleMove(v);
-		if (v->cur_image != SPR_EXPLOSION_LARGE_F) {
-			v->cur_image++;
-			VehiclePositionChanged(v);
-			EndVehicleMove(v);
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-		}
-	}
-}
-
-static void BreakdownSmokeInit(Vehicle *v)
-{
-	v->cur_image = SPR_BREAKDOWN_SMOKE_0;
-	v->progress = 0;
-}
-
-static void BreakdownSmokeTick(Vehicle *v)
-{
-	v->progress++;
-	if ((v->progress & 7) == 0) {
-		BeginVehicleMove(v);
-		if (v->cur_image != SPR_BREAKDOWN_SMOKE_3) {
-			v->cur_image++;
-		} else {
-			v->cur_image = SPR_BREAKDOWN_SMOKE_0;
-		}
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	}
-
-	v->u.special.unk0--;
-	if (v->u.special.unk0 == 0) {
-		BeginVehicleMove(v);
-		EndVehicleMove(v);
-		DeleteVehicle(v);
-	}
-}
-
-static void ExplosionSmallInit(Vehicle *v)
-{
-	v->cur_image = SPR_EXPLOSION_SMALL_0;
-	v->progress = 0;
-}
-
-static void ExplosionSmallTick(Vehicle *v)
-{
-	v->progress++;
-	if ((v->progress & 3) == 0) {
-		BeginVehicleMove(v);
-		if (v->cur_image != SPR_EXPLOSION_SMALL_B) {
-			v->cur_image++;
-			VehiclePositionChanged(v);
-			EndVehicleMove(v);
-		} else {
-			EndVehicleMove(v);
-			DeleteVehicle(v);
-		}
-	}
-}
-
-static void BulldozerInit(Vehicle *v)
-{
-	v->cur_image = SPR_BULLDOZER_NE;
-	v->progress = 0;
-	v->u.special.unk0 = 0;
-	v->u.special.unk2 = 0;
-}
-
-typedef struct BulldozerMovement {
-	byte direction:2;
-	byte image:2;
-	byte duration:3;
-} BulldozerMovement;
-
-static const BulldozerMovement _bulldozer_movement[] = {
-	{ 0, 0, 4 },
-	{ 3, 3, 4 },
-	{ 2, 2, 7 },
-	{ 0, 2, 7 },
-	{ 1, 1, 3 },
-	{ 2, 2, 7 },
-	{ 0, 2, 7 },
-	{ 1, 1, 3 },
-	{ 2, 2, 7 },
-	{ 0, 2, 7 },
-	{ 3, 3, 6 },
-	{ 2, 2, 6 },
-	{ 1, 1, 7 },
-	{ 3, 1, 7 },
-	{ 0, 0, 3 },
-	{ 1, 1, 7 },
-	{ 3, 1, 7 },
-	{ 0, 0, 3 },
-	{ 1, 1, 7 },
-	{ 3, 1, 7 }
-};
-
-static const struct {
-	int8 x;
-	int8 y;
-} _inc_by_dir[] = {
-	{ -1,  0 },
-	{  0,  1 },
-	{  1,  0 },
-	{  0, -1 }
-};
-
-static void BulldozerTick(Vehicle *v)
-{
-	v->progress++;
-	if ((v->progress & 7) == 0) {
-		const BulldozerMovement* b = &_bulldozer_movement[v->u.special.unk0];
-
-		BeginVehicleMove(v);
-
-		v->cur_image = SPR_BULLDOZER_NE + b->image;
-
-		v->x_pos += _inc_by_dir[b->direction].x;
-		v->y_pos += _inc_by_dir[b->direction].y;
-
-		v->u.special.unk2++;
-		if (v->u.special.unk2 >= b->duration) {
-			v->u.special.unk2 = 0;
-			v->u.special.unk0++;
-			if (v->u.special.unk0 == lengthof(_bulldozer_movement)) {
-				EndVehicleMove(v);
-				DeleteVehicle(v);
-				return;
-			}
-		}
-		VehiclePositionChanged(v);
-		EndVehicleMove(v);
-	}
-}
-
-static void BubbleInit(Vehicle *v)
-{
-	v->cur_image = SPR_BUBBLE_GENERATE_0;
-	v->spritenum = 0;
-	v->progress = 0;
-}
-
-typedef struct BubbleMovement {
-	int8 x:4;
-	int8 y:4;
-	int8 z:4;
-	byte image:4;
-} BubbleMovement;
-
-#define MK(x, y, z, i) { x, y, z, i }
-#define ME(i) { i, 4, 0, 0 }
-
-static const BubbleMovement _bubble_float_sw[] = {
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 2),
-	ME(1)
-};
-
-
-static const BubbleMovement _bubble_float_ne[] = {
-	MK( 0, 0, 1, 0),
-	MK(-1, 0, 1, 1),
-	MK( 0, 0, 1, 0),
-	MK(-1, 0, 1, 2),
-	ME(1)
-};
-
-static const BubbleMovement _bubble_float_se[] = {
-	MK(0, 0, 1, 0),
-	MK(0, 1, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 1, 1, 2),
-	ME(1)
-};
-
-static const BubbleMovement _bubble_float_nw[] = {
-	MK(0,  0, 1, 0),
-	MK(0, -1, 1, 1),
-	MK(0,  0, 1, 0),
-	MK(0, -1, 1, 2),
-	ME(1)
-};
-
-static const BubbleMovement _bubble_burst[] = {
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 7),
-	MK(0, 0, 1, 8),
-	MK(0, 0, 1, 9),
-	ME(0)
-};
-
-static const BubbleMovement _bubble_absorb[] = {
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(0, 0, 1, 1),
-	MK(2, 1, 3, 0),
-	MK(1, 1, 3, 1),
-	MK(2, 1, 3, 0),
-	MK(1, 1, 3, 2),
-	MK(2, 1, 3, 0),
-	MK(1, 1, 3, 1),
-	MK(2, 1, 3, 0),
-	MK(1, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 2),
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 1),
-	MK(0, 0, 1, 0),
-	MK(1, 0, 1, 2),
-	ME(2),
-	MK(0, 0, 0, 0xA),
-	MK(0, 0, 0, 0xB),
-	MK(0, 0, 0, 0xC),
-	MK(0, 0, 0, 0xD),
-	MK(0, 0, 0, 0xE),
-	ME(0)
-};
-#undef ME
-#undef MK
-
-static const BubbleMovement * const _bubble_movement[] = {
-	_bubble_float_sw,
-	_bubble_float_ne,
-	_bubble_float_se,
-	_bubble_float_nw,
-	_bubble_burst,
-	_bubble_absorb,
-};
-
-static void BubbleTick(Vehicle *v)
-{
-	/*
-	 * Warning: those effects can NOT use Random(), and have to use
-	 *  InteractiveRandom(), because somehow someone forgot to save
-	 *  spritenum to the savegame, and so it will cause desyncs in
-	 *  multiplayer!! (that is: in ToyLand)
-	 */
-	uint et;
-	const BubbleMovement *b;
-
-	v->progress++;
-	if ((v->progress & 3) != 0)
-		return;
-
-	BeginVehicleMove(v);
-
-	if (v->spritenum == 0) {
-		v->cur_image++;
-		if (v->cur_image < SPR_BUBBLE_GENERATE_3) {
-			VehiclePositionChanged(v);
-			EndVehicleMove(v);
-			return;
-		}
-		if (v->u.special.unk2 != 0) {
-			v->spritenum = GB(InteractiveRandom(), 0, 2) + 1;
-		} else {
-			v->spritenum = 6;
-		}
-		et = 0;
-	} else {
-		et = v->engine_type + 1;
-	}
-
-	b = &_bubble_movement[v->spritenum - 1][et];
-
-	if (b->y == 4 && b->x == 0) {
-		EndVehicleMove(v);
-		DeleteVehicle(v);
-		return;
-	}
-
-	if (b->y == 4 && b->x == 1) {
-		if (v->z_pos > 180 || CHANCE16I(1, 96, InteractiveRandom())) {
-			v->spritenum = 5;
-			SndPlayVehicleFx(SND_2F_POP, v);
-		}
-		et = 0;
-	}
-
-	if (b->y == 4 && b->x == 2) {
-		TileIndex tile;
-
-		et++;
-		SndPlayVehicleFx(SND_31_EXTRACT, v);
-
-		tile = TileVirtXY(v->x_pos, v->y_pos);
-		if (IsTileType(tile, MP_INDUSTRY) && GetIndustryGfx(tile) == 0xA2) AddAnimatedTile(tile);
-	}
-
-	v->engine_type = et;
-	b = &_bubble_movement[v->spritenum - 1][et];
-
-	v->x_pos += b->x;
-	v->y_pos += b->y;
-	v->z_pos += b->z;
-	v->cur_image = SPR_BUBBLE_0 + b->image;
-
-	VehiclePositionChanged(v);
-	EndVehicleMove(v);
-}
-
-
-typedef void EffectInitProc(Vehicle *v);
-typedef void EffectTickProc(Vehicle *v);
-
-static EffectInitProc * const _effect_init_procs[] = {
-	ChimneySmokeInit,
-	SteamSmokeInit,
-	DieselSmokeInit,
-	ElectricSparkInit,
-	SmokeInit,
-	ExplosionLargeInit,
-	BreakdownSmokeInit,
-	ExplosionSmallInit,
-	BulldozerInit,
-	BubbleInit,
-};
-
-static EffectTickProc * const _effect_tick_procs[] = {
-	ChimneySmokeTick,
-	SteamSmokeTick,
-	DieselSmokeTick,
-	ElectricSparkTick,
-	SmokeTick,
-	ExplosionLargeTick,
-	BreakdownSmokeTick,
-	ExplosionSmallTick,
-	BulldozerTick,
-	BubbleTick,
-};
-
-
-Vehicle *CreateEffectVehicle(int x, int y, int z, EffectVehicle type)
-{
-	Vehicle *v;
-
-	v = ForceAllocateSpecialVehicle();
-	if (v != NULL) {
-		v->type = VEH_Special;
-		v->subtype = type;
-		v->x_pos = x;
-		v->y_pos = y;
-		v->z_pos = z;
-		v->z_height = v->sprite_width = v->sprite_height = 1;
-		v->x_offs = v->y_offs = 0;
-		v->tile = 0;
-		v->vehstatus = VS_UNCLICKABLE;
-
-		_effect_init_procs[type](v);
-
-		VehiclePositionChanged(v);
-		BeginVehicleMove(v);
-		EndVehicleMove(v);
-	}
-	return v;
-}
-
-Vehicle *CreateEffectVehicleAbove(int x, int y, int z, EffectVehicle type)
-{
-	int safe_x = clamp(x, 0, MapMaxX() * TILE_SIZE);
-	int safe_y = clamp(y, 0, MapMaxY() * TILE_SIZE);
-	return CreateEffectVehicle(x, y, GetSlopeZ(safe_x, safe_y) + z, type);
-}
-
-Vehicle *CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicle type)
-{
-	return CreateEffectVehicle(v->x_pos + x, v->y_pos + y, v->z_pos + z, type);
-}
-
-static void EffectVehicle_Tick(Vehicle *v)
-{
-	_effect_tick_procs[v->subtype](v);
-}
-
-Vehicle *CheckClickOnVehicle(const ViewPort *vp, int x, int y)
-{
-	Vehicle *found = NULL, *v;
-	uint dist, best_dist = (uint)-1;
-
-	if ( (uint)(x -= vp->left) >= (uint)vp->width ||
-			 (uint)(y -= vp->top) >= (uint)vp->height)
-				return NULL;
-
-	x = (x << vp->zoom) + vp->virtual_left;
-	y = (y << vp->zoom) + vp->virtual_top;
-
-	FOR_ALL_VEHICLES(v) {
-		if ((v->vehstatus & (VS_HIDDEN|VS_UNCLICKABLE)) == 0 &&
-				x >= v->left_coord && x <= v->right_coord &&
-				y >= v->top_coord && y <= v->bottom_coord) {
-
-			dist = max(
-				myabs( ((v->left_coord + v->right_coord)>>1) - x ),
-				myabs( ((v->top_coord + v->bottom_coord)>>1) - y )
-			);
-
-			if (dist < best_dist) {
-				found = v;
-				best_dist = dist;
-			}
-		}
-	}
-
-	return found;
-}
-
-
-void DecreaseVehicleValue(Vehicle *v)
-{
-	v->value -= v->value >> 8;
-	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
-}
-
-static const byte _breakdown_chance[64] = {
-	  3,   3,   3,   3,   3,   3,   3,   3,
-	  4,   4,   5,   5,   6,   6,   7,   7,
-	  8,   8,   9,   9,  10,  10,  11,  11,
-	 12,  13,  13,  13,  13,  14,  15,  16,
-	 17,  19,  21,  25,  28,  31,  34,  37,
-	 40,  44,  48,  52,  56,  60,  64,  68,
-	 72,  80,  90, 100, 110, 120, 130, 140,
-	150, 170, 190, 210, 230, 250, 250, 250,
-};
-
-void CheckVehicleBreakdown(Vehicle *v)
-{
-	int rel, rel_old;
-	uint32 r;
-	int chance;
-
-	/* decrease reliability */
-	v->reliability = rel = max((rel_old = v->reliability) - v->reliability_spd_dec, 0);
-	if ((rel_old >> 8) != (rel >> 8))
-		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
-
-	if (v->breakdown_ctr != 0 || v->vehstatus & VS_STOPPED ||
-			v->cur_speed < 5 || _game_mode == GM_MENU) {
-		return;
-	}
-
-	r = Random();
-
-	/* increase chance of failure */
-	chance = v->breakdown_chance + 1;
-	if (CHANCE16I(1,25,r)) chance += 25;
-	v->breakdown_chance = min(255, chance);
-
-	/* calculate reliability value to use in comparison */
-	rel = v->reliability;
-	if (v->type == VEH_Ship) rel += 0x6666;
-
-	/* disabled breakdowns? */
-	if (_opt.diff.vehicle_breakdowns < 1) return;
-
-	/* reduced breakdowns? */
-	if (_opt.diff.vehicle_breakdowns == 1) rel += 0x6666;
-
-	/* check if to break down */
-	if (_breakdown_chance[(uint)min(rel, 0xffff) >> 10] <= v->breakdown_chance) {
-		v->breakdown_ctr    = GB(r, 16, 6) + 0x3F;
-		v->breakdown_delay  = GB(r, 24, 7) + 0x80;
-		v->breakdown_chance = 0;
-	}
-}
-
-static const StringID _vehicle_type_names[4] = {
-	STR_019F_TRAIN,
-	STR_019C_ROAD_VEHICLE,
-	STR_019E_SHIP,
-	STR_019D_AIRCRAFT,
-};
-
-static void ShowVehicleGettingOld(Vehicle *v, StringID msg)
-{
-	if (v->owner != _local_player) return;
-
-	// Do not show getting-old message if autorenew is active
-	if (GetPlayer(v->owner)->engine_renew) return;
-
-	SetDParam(0, _vehicle_type_names[v->type - 0x10]);
-	SetDParam(1, v->unitnumber);
-	AddNewsItem(msg, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);
-}
-
-void AgeVehicle(Vehicle *v)
-{
-	int age;
-
-	if (v->age < 65535)
-		v->age++;
-
-	age = v->age - v->max_age;
-	if (age == 366*0 || age == 366*1 || age == 366*2 || age == 366*3 || age == 366*4)
-		v->reliability_spd_dec <<= 1;
-
-	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
-
-	if (age == -366) {
-		ShowVehicleGettingOld(v, STR_01A0_IS_GETTING_OLD);
-	} else if (age == 0) {
-		ShowVehicleGettingOld(v, STR_01A1_IS_GETTING_VERY_OLD);
-	} else if (age == 366*1 || age == 366*2 || age == 366*3 || age == 366*4 || age == 366*5) {
-		ShowVehicleGettingOld(v, STR_01A2_IS_GETTING_VERY_OLD_AND);
-	}
-}
-
-/** Starts or stops a lot of vehicles
- * @param tile Tile of the depot where the vehicles are started/stopped (only used for depots)
- * @param p1 Station/Order/Depot ID (only used for vehicle list windows)
- * @param p2 bitmask
- *   - bit 0-4 Vehicle type
- *   - bit 5 false = start vehicles, true = stop vehicles
- *   - bit 6 if set, then it's a vehicle list window, not a depot and Tile is ignored in this case
- *   - bit 8-11 Vehicle List Window type (ignored unless bit 1 is set)
- */
-int32 CmdMassStartStopVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle **vl = NULL;
-	uint16 engine_list_length = 0;
-	uint16 engine_count = 0;
-	int32 return_value = CMD_ERROR;
-	uint i;
-	uint stop_command;
-	byte vehicle_type = GB(p2, 0, 5);
-	bool start_stop = HASBIT(p2, 5);
-	bool vehicle_list_window = HASBIT(p2, 6);
-
-	switch (vehicle_type) {
-		case VEH_Train:    stop_command = CMD_START_STOP_TRAIN;    break;
-		case VEH_Road:     stop_command = CMD_START_STOP_ROADVEH;  break;
-		case VEH_Ship:     stop_command = CMD_START_STOP_SHIP;     break;
-		case VEH_Aircraft: stop_command = CMD_START_STOP_AIRCRAFT; break;
-		default: return CMD_ERROR;
-	}
-
-	if (vehicle_list_window) {
-		uint16 id = GB(p1, 0, 16);
-		uint16 window_type = p2 & VLW_MASK;
-
-		engine_count = GenerateVehicleSortList((const Vehicle***)&vl, &engine_list_length, vehicle_type, _current_player, id, id, id, window_type);
-	} else {
-		/* Get the list of vehicles in the depot */
-		BuildDepotVehicleList(vehicle_type, tile, &vl, &engine_list_length, &engine_count, NULL, NULL, NULL);
-	}
-
-	for (i = 0; i < engine_count; i++) {
-		const Vehicle *v = vl[i];
-		int32 ret;
-
-		if (!!(v->vehstatus & VS_STOPPED) != start_stop) continue;
-
-		if (!vehicle_list_window) {
-			if (vehicle_type == VEH_Train) {
-				if (CheckTrainInDepot(v, false) == -1) continue;
-			} else {
-				if (!(v->vehstatus & VS_HIDDEN)) continue;
-			}
-		}
-
-		ret = DoCommand(tile, v->index, 0, flags, stop_command);
-
-		if (!CmdFailed(ret)) {
-			return_value = 0;
-			/* We know that the command is valid for at least one vehicle.
-			 * If we haven't set DC_EXEC, then there is no point in continueing because it will be valid */
-			if (!(flags & DC_EXEC)) break;
-		}
-	}
-
-	free(vl);
-	return return_value;
-}
-
-/** Sells all vehicles in a depot
-* @param tile Tile of the depot where the depot is
-* @param p1 Vehicle type
-* @param p2 unused
-*/
-int32 CmdDepotSellAllVehicles(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle **engines = NULL;
-	Vehicle **wagons = NULL;
-	uint16 engine_list_length = 0;
-	uint16 engine_count = 0;
-	uint16 wagon_list_length = 0;
-	uint16 wagon_count = 0;
-
-	int32 cost = 0;
-	uint i, sell_command, total_number_vehicles;
-	byte vehicle_type = GB(p1, 0, 8);
-
-	switch (vehicle_type) {
-		case VEH_Train:    sell_command = CMD_SELL_RAIL_WAGON; break;
-		case VEH_Road:     sell_command = CMD_SELL_ROAD_VEH;   break;
-		case VEH_Ship:     sell_command = CMD_SELL_SHIP;       break;
-		case VEH_Aircraft: sell_command = CMD_SELL_AIRCRAFT;   break;
-		default: return CMD_ERROR;
-	}
-
-	/* Get the list of vehicles in the depot */
-	BuildDepotVehicleList(vehicle_type, tile, &engines, &engine_list_length, &engine_count,
-						                      &wagons,  &wagon_list_length,  &wagon_count);
-
-	total_number_vehicles = engine_count + wagon_count;
-	for (i = 0; i < total_number_vehicles; i++) {
-		const Vehicle *v;
-		int32 ret;
-
-		if (i < engine_count) {
-			v = engines[i];
-		} else {
-			v = wagons[i - engine_count];
-		}
-
-		ret = DoCommand(tile, v->index, 1, flags, sell_command);
-
-		if (!CmdFailed(ret)) cost += ret;
-	}
-
-	free(engines);
-	free(wagons);
-	if (cost == 0) return CMD_ERROR; // no vehicles to sell
-	return cost;
-}
-
-/** Autoreplace all vehicles in the depot
-* @param tile Tile of the depot where the vehicles are
-* @param p1 Type of vehicle
-* @param p2 Unused
-*/
-int32 CmdDepotMassAutoReplace(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle **vl = NULL;
-	uint16 engine_list_length = 0;
-	uint16 engine_count = 0;
-	uint i, x = 0, y = 0, z = 0;
-	int32 cost = 0;
-	byte vehicle_type = GB(p1, 0, 8);
-
-
-	if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
-
-	/* Get the list of vehicles in the depot */
-	BuildDepotVehicleList(vehicle_type, tile, &vl, &engine_list_length, &engine_count, NULL, NULL, NULL);
-
-
-	for (i = 0; i < engine_count; i++) {
-		Vehicle *v = vl[i];
-		bool stopped = !(v->vehstatus & VS_STOPPED);
-		int32 ret;
-
-		/* Ensure that the vehicle completely in the depot */
-		if (!IsVehicleInDepot(v)) continue;
-
-		x = v->x_pos;
-		y = v->y_pos;
-		z = v->z_pos;
-
-		if (stopped) {
-			v->vehstatus |= VS_STOPPED; // Stop the vehicle
-			v->leave_depot_instantly = true;
-		}
-		ret = MaybeReplaceVehicle(v, !(flags & DC_EXEC), false);
-
-		if (!CmdFailed(ret)) {
-			cost += ret;
-			if (!(flags & DC_EXEC)) break;
-			/* There is a problem with autoreplace and newgrf
-			 * It's impossible to tell the length of a train after it's being replaced before it's actually done
-			 * Because of this, we can't estimate costs due to wagon removal and we will have to always return 0 and pay manually
-			 * Since we pay after each vehicle is replaced and MaybeReplaceVehicle() check if the player got enough money
-			 * we should never reach a condition where the player will end up with negative money from doing this */
-			SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-			SubtractMoneyFromPlayer(ret);
-		}
-	}
-
-	if (cost == 0) {
-		cost = CMD_ERROR;
-	} else {
-		if (flags & DC_EXEC) {
-			/* Display the cost animation now that DoCommandP() can't do it for us (see previous comments) */
-			if (IsLocalPlayer()) ShowCostOrIncomeAnimation(x, y, z, cost);
-		}
-		cost = 0;
-	}
-
-	free(vl);
-	return cost;
-}
-
-/** Clone a vehicle. If it is a train, it will clone all the cars too
- * @param tile tile of the depot where the cloned vehicle is build
- * @param p1 the original vehicle's index
- * @param p2 1 = shared orders, else copied orders
- */
-int32 CmdCloneVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle *v_front, *v;
-	Vehicle *w_front, *w, *w_rear;
-	int cost, total_cost = 0;
-	uint32 build_argument = 2;
-
-	if (!IsValidVehicleID(p1)) return CMD_ERROR;
-	v = GetVehicle(p1);
-	v_front = v;
-	w = NULL;
-	w_front = NULL;
-	w_rear = NULL;
-
-
-	/*
-	 * v_front is the front engine in the original vehicle
-	 * v is the car/vehicle of the original vehicle, that is currently being copied
-	 * w_front is the front engine of the cloned vehicle
-	 * w is the car/vehicle currently being cloned
-	 * w_rear is the rear end of the cloned train. It's used to add more cars and is only used by trains
-	 */
-
-	if (!CheckOwnership(v->owner)) return CMD_ERROR;
-
-	if (v->type == VEH_Train && (!IsFrontEngine(v) || v->u.rail.crash_anim_pos >= 4400)) return CMD_ERROR;
-
-	// check that we can allocate enough vehicles
-	if (!(flags & DC_EXEC)) {
-		int veh_counter = 0;
-		do {
-			veh_counter++;
-		} while ((v = v->next) != NULL);
-
-		if (!AllocateVehicles(NULL, veh_counter)) {
-			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
-		}
-	}
-
-	v = v_front;
-
-	do {
-
-		if (IsMultiheaded(v) && !IsTrainEngine(v)) {
-			/* we build the rear ends of multiheaded trains with the front ones */
-			continue;
-		}
-
-		cost = DoCommand(tile, v->engine_type, build_argument, flags, CMD_BUILD_VEH(v->type));
-		build_argument = 3; // ensure that we only assign a number to the first engine
-
-		if (CmdFailed(cost)) return cost;
-
-		total_cost += cost;
-
-		if (flags & DC_EXEC) {
-			w = GetVehicle(_new_vehicle_id);
-
-			if (v->cargo_type != w->cargo_type || v->cargo_subtype != w->cargo_subtype) {
-				// we can't pay for refitting because we can't estimate refitting costs for a vehicle before it's build
-				// if we pay for it anyway, the cost and the estimated cost will not be the same and we will have an assert
-				DoCommand(0, w->index, v->cargo_type | (v->cargo_subtype << 8), flags, CMD_REFIT_VEH(v->type));
-			}
-			if (v->type == VEH_Train && HASBIT(v->u.rail.flags, VRF_REVERSE_DIRECTION)) {
-				SETBIT(w->u.rail.flags, VRF_REVERSE_DIRECTION);
-			}
-
-			if (v->type == VEH_Train && !IsFrontEngine(v)) {
-				// this s a train car
-				// add this unit to the end of the train
-				DoCommand(0, (w_rear->index << 16) | w->index, 1, flags, CMD_MOVE_RAIL_VEHICLE);
-			} else {
-				// this is a front engine or not a train. It need orders
-				w_front = w;
-				w->service_interval = v->service_interval;
-				DoCommand(0, (v->index << 16) | w->index, p2 & 1 ? CO_SHARE : CO_COPY, flags, CMD_CLONE_ORDER);
-			}
-			w_rear = w; // trains needs to know the last car in the train, so they can add more in next loop
-		}
-	} while (v->type == VEH_Train && (v = GetNextVehicle(v)) != NULL);
-
-	if (flags & DC_EXEC && v_front->type == VEH_Train) {
-		// for trains this needs to be the front engine due to the callback function
-		_new_vehicle_id = w_front->index;
-	}
-
-	/* Set the expense type last as refitting will make the cost go towards
-	 * running costs... */
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-	return total_cost;
-}
-
-/*
- * move the cargo from one engine to another if possible
- */
-static void MoveVehicleCargo(Vehicle *dest, Vehicle *source)
-{
-	Vehicle *v = dest;
-	int units_moved;
-
-	do {
-		do {
-			if (source->cargo_type != dest->cargo_type)
-				continue; // cargo not compatible
-
-			if (dest->cargo_count == dest->cargo_cap)
-				continue; // the destination vehicle is already full
-
-			units_moved = min(source->cargo_count, dest->cargo_cap - dest->cargo_count);
-			source->cargo_count -= units_moved;
-			dest->cargo_count   += units_moved;
-			dest->cargo_source   = source->cargo_source;
-
-			// copy the age of the cargo
-			dest->cargo_days   = source->cargo_days;
-			dest->day_counter  = source->day_counter;
-			dest->tick_counter = source->tick_counter;
-
-		} while (source->cargo_count > 0 && (dest = dest->next) != NULL);
-		dest = v;
-	} while ((source = source->next) != NULL);
-}
-
-static bool VerifyAutoreplaceRefitForOrders(const Vehicle *v, const EngineID engine_type)
-{
-	const Order *o;
-	const Vehicle *u;
-
-	if (v->type == VEH_Train) {
-		u = GetFirstVehicleInChain(v);
-	} else {
-		u = v;
-	}
-
-	FOR_VEHICLE_ORDERS(u, o) {
-		if (!(o->refit_cargo < NUM_CARGO)) continue;
-		if (!CanRefitTo(v->engine_type, o->refit_cargo)) continue;
-		if (!CanRefitTo(engine_type, o->refit_cargo)) return false;
-	}
-
-	return true;
-}
-
-/**
- * Function to find what type of cargo to refit to when autoreplacing
- * @param *v Original vehicle, that is being replaced
- * @param engine_type The EngineID of the vehicle that is being replaced to
- * @return The cargo type to replace to
- *    CT_NO_REFIT is returned if no refit is needed
- *    CT_INVALID is returned when both old and new vehicle got cargo capacity and refitting the new one to the old one's cargo type isn't possible
- */
-static CargoID GetNewCargoTypeForReplace(Vehicle *v, EngineID engine_type)
-{
-	bool new_cargo_capacity = true;
-	CargoID new_cargo_type = CT_INVALID;
-
-	switch (v->type) {
-		case VEH_Train:
-			new_cargo_capacity = (RailVehInfo(engine_type)->capacity > 0);
-			new_cargo_type     = RailVehInfo(engine_type)->cargo_type;
-			break;
-
-		case VEH_Road:
-			new_cargo_capacity = (RoadVehInfo(engine_type)->capacity > 0);
-			new_cargo_type     = RoadVehInfo(engine_type)->cargo_type;
-			break;
-		case VEH_Ship:
-			new_cargo_capacity = (ShipVehInfo(engine_type)->capacity > 0);
-			new_cargo_type     = ShipVehInfo(engine_type)->cargo_type;
-			break;
-
-		case VEH_Aircraft:
-			/* all aircraft starts as passenger planes with cargo capacity
-			 * new_cargo_capacity is always true for aircraft, which is the init value. No need to set it here */
-			new_cargo_type     = CT_PASSENGERS;
-			break;
-
-		default: NOT_REACHED(); break;
-	}
-
-	if (!new_cargo_capacity) return CT_NO_REFIT; // Don't try to refit an engine with no cargo capacity
-
-	if (v->cargo_type == new_cargo_type || CanRefitTo(engine_type, v->cargo_type)) {
-		if (VerifyAutoreplaceRefitForOrders(v, engine_type)) {
-			return v->cargo_type == new_cargo_type ? CT_NO_REFIT : v->cargo_type;
-		} else {
-			return CT_INVALID;
-		}
-	}
-	if (v->type != VEH_Train) return CT_INVALID; // We can't refit the vehicle to carry the cargo we want
-
-	/* Below this line it's safe to assume that the vehicle in question is a train */
-
-	if (v->cargo_cap != 0) return CT_INVALID; // trying to replace a vehicle with cargo capacity into another one with incompatible cargo type
-
-	/* the old engine didn't have cargo capacity, but the new one does
-	 * now we will figure out what cargo the train is carrying and refit to fit this */
-	v = GetFirstVehicleInChain(v);
-	do {
-		if (v->cargo_cap == 0) continue;
-		/* Now we found a cargo type being carried on the train and we will see if it is possible to carry to this one */
-		if (v->cargo_type == new_cargo_type) return CT_NO_REFIT;
-		if (CanRefitTo(engine_type, v->cargo_type)) return v->cargo_type;
-	} while ((v=v->next) != NULL);
-	return CT_NO_REFIT; // We failed to find a cargo type on the old vehicle and we will not refit the new one
-}
-
-/* Replaces a vehicle (used to be called autorenew)
- * This function is only called from MaybeReplaceVehicle()
- * Must be called with _current_player set to the owner of the vehicle
- * @param w Vehicle to replace
- * @param flags is the flags to use when calling DoCommand(). Mainly DC_EXEC counts
- * @return value is cost of the replacement or CMD_ERROR
- */
-static int32 ReplaceVehicle(Vehicle **w, byte flags, int32 total_cost)
-{
-	int32 cost;
-	int32 sell_value;
-	Vehicle *old_v = *w;
-	const Player *p = GetPlayer(old_v->owner);
-	EngineID new_engine_type;
-	const UnitID cached_unitnumber = old_v->unitnumber;
-	bool new_front = false;
-	Vehicle *new_v = NULL;
-	char vehicle_name[32];
-	CargoID replacement_cargo_type;
-
-	new_engine_type = EngineReplacementForPlayer(p, old_v->engine_type);
-	if (new_engine_type == INVALID_ENGINE) new_engine_type = old_v->engine_type;
-
-	replacement_cargo_type = GetNewCargoTypeForReplace(old_v, new_engine_type);
-
-	/* check if we can't refit to the needed type, so no replace takes place to prevent the vehicle from altering cargo type */
-	if (replacement_cargo_type == CT_INVALID) return 0;
-
-	sell_value = DoCommand(0, old_v->index, 0, DC_QUERY_COST, CMD_SELL_VEH(old_v->type));
-
-	/* We give the player a loan of the same amount as the sell value.
-	 * This is needed in case he needs the income from the sale to build the new vehicle.
-	 * We take it back if building fails or when we really sell the old engine */
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-	SubtractMoneyFromPlayer(sell_value);
-
-	cost = DoCommand(old_v->tile, new_engine_type, 3, flags, CMD_BUILD_VEH(old_v->type));
-	if (CmdFailed(cost)) {
-		SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-		SubtractMoneyFromPlayer(-sell_value); // Take back the money we just gave the player
-		return cost;
-	}
-
-	if (replacement_cargo_type != CT_NO_REFIT) cost += GetRefitCost(new_engine_type); // add refit cost
-
-	if (flags & DC_EXEC) {
-		new_v = GetVehicle(_new_vehicle_id);
-		*w = new_v; //we changed the vehicle, so MaybeReplaceVehicle needs to work on the new one. Now we tell it what the new one is
-
-		/* refit if needed */
-		if (replacement_cargo_type != CT_NO_REFIT) {
-			if (CmdFailed(DoCommand(0, new_v->index, replacement_cargo_type, DC_EXEC, CMD_REFIT_VEH(new_v->type)))) {
-				/* Being here shows a failure, which most likely is in GetNewCargoTypeForReplace() or incorrect estimation costs */
-				error("Autoreplace failed to refit. Replace engine %d to %d and refit to cargo %d", old_v->engine_type, new_v->engine_type, replacement_cargo_type);
-			}
-		}
-
-		if (new_v->type == VEH_Train && HASBIT(old_v->u.rail.flags, VRF_REVERSE_DIRECTION) && !IsMultiheaded(new_v) && !(new_v->next != NULL && IsArticulatedPart(new_v->next))) {
-			// we are autorenewing to a single engine, so we will turn it as the old one was turned as well
-			SETBIT(new_v->u.rail.flags, VRF_REVERSE_DIRECTION);
-		}
-
-		if (old_v->type == VEH_Train && !IsFrontEngine(old_v)) {
-			/* this is a railcar. We need to move the car into the train
-			 * We add the new engine after the old one instead of replacing it. It will give the same result anyway when we
-			 * sell the old engine in a moment
-			 */
-			DoCommand(0, (GetPrevVehicleInChain(old_v)->index << 16) | new_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
-			/* Now we move the old one out of the train */
-			DoCommand(0, (INVALID_VEHICLE << 16) | old_v->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
-		} else {
-			// copy/clone the orders
-			DoCommand(0, (old_v->index << 16) | new_v->index, IsOrderListShared(old_v) ? CO_SHARE : CO_COPY, DC_EXEC, CMD_CLONE_ORDER);
-			new_v->cur_order_index = old_v->cur_order_index;
-			ChangeVehicleViewWindow(old_v, new_v);
-			new_v->profit_this_year = old_v->profit_this_year;
-			new_v->profit_last_year = old_v->profit_last_year;
-			new_v->service_interval = old_v->service_interval;
-			new_front = true;
-			new_v->unitnumber = old_v->unitnumber; // use the same unit number
-
-			new_v->current_order = old_v->current_order;
-			if (old_v->type == VEH_Train && GetNextVehicle(old_v) != NULL){
-				Vehicle *temp_v = GetNextVehicle(old_v);
-
-				// move the entire train to the new engine, excluding the old engine
-				if (IsMultiheaded(old_v) && temp_v == old_v->u.rail.other_multiheaded_part) {
-					// we got front and rear of a multiheaded engine right after each other. We should work with the next in line instead
-					temp_v = GetNextVehicle(temp_v);
-				}
-
-				if (temp_v != NULL) {
-					DoCommand(0, (new_v->index << 16) | temp_v->index, 1, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
-				}
-			}
-		}
-		/* We are done setting up the new vehicle. Now we move the cargo from the old one to the new one */
-		MoveVehicleCargo(new_v->type == VEH_Train ? GetFirstVehicleInChain(new_v) : new_v, old_v);
-
-		// Get the name of the old vehicle if it has a custom name.
-		if (!IsCustomName(old_v->string_id)) {
-			vehicle_name[0] = '\0';
-		} else {
-			GetName(vehicle_name, old_v->string_id & 0x7FF, lastof(vehicle_name));
-		}
-	} else { // flags & DC_EXEC not set
-		/* Ensure that the player will not end up having negative money while autoreplacing
-		 * This is needed because the only other check is done after the income from selling the old vehicle is substracted from the cost */
-		if (p->money64 < (cost + total_cost)) {
-			SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-			SubtractMoneyFromPlayer(-sell_value); // Pay back the loan
-			return CMD_ERROR;
-		}
-	}
-
-	/* Take back the money we just gave the player just before building the vehicle
-	 * The player will get the same amount now that the sale actually takes place */
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
-	SubtractMoneyFromPlayer(-sell_value);
-
-	/* sell the engine/ find out how much you get for the old engine (income is returned as negative cost) */
-	cost += DoCommand(0, old_v->index, 0, flags, CMD_SELL_VEH(old_v->type));
-
-	if (new_front) {
-		/* now we assign the old unitnumber to the new vehicle */
-		new_v->unitnumber = cached_unitnumber;
-	}
-
-	/* Transfer the name of the old vehicle */
-	if ((flags & DC_EXEC) && vehicle_name[0] != '\0') {
-		_cmd_text = vehicle_name;
-		DoCommand(0, new_v->index, 0, DC_EXEC, CMD_NAME_VEHICLE);
-	}
-
-	return cost;
-}
-
-/** replaces a vehicle if it's set for autoreplace or is too old
- * (used to be called autorenew)
- * @param v The vehicle to replace
- * if the vehicle is a train, v needs to be the front engine
- * @param check Checks if the replace is valid. No action is done at all
- * @param display_costs If set, a cost animation is shown (only if check is false)
- * @return CMD_ERROR if something went wrong. Otherwise the price of the replace
- */
-static int32 MaybeReplaceVehicle(Vehicle *v, bool check, bool display_costs)
-{
-	Vehicle *w;
-	const Player *p = GetPlayer(v->owner);
-	byte flags = 0;
-	int32 cost, temp_cost = 0;
-	bool stopped = false;
-
-	/* Remember the length in case we need to trim train later on
-	 * If it's not a train, the value is unused
-	 * round up to the length of the tiles used for the train instead of the train length instead
-	 * Useful when newGRF uses custom length */
-	uint16 old_total_length = (v->type == VEH_Train ?
-		(v->u.rail.cached_total_length + TILE_SIZE - 1) / TILE_SIZE * TILE_SIZE :
-		-1
-	);
-
-
-	_current_player = v->owner;
-
-	assert(v->type == VEH_Train || v->type == VEH_Road || v->type == VEH_Ship || v->type == VEH_Aircraft);
-
-	assert(v->vehstatus & VS_STOPPED); // the vehicle should have been stopped in VehicleEnteredDepotThisTick() if needed
-
-	if (v->leave_depot_instantly) {
-		// we stopped the vehicle to do this, so we have to remember to start it again when we are done
-		// we need to store this info as the engine might be replaced and lose this info
-		stopped = true;
-	}
-
-	for (;;) {
-		cost = 0;
-		w = v;
-		do {
-			if (w->type == VEH_Train && IsMultiheaded(w) && !IsTrainEngine(w)) {
-				/* we build the rear ends of multiheaded trains with the front ones */
-				continue;
-			}
-
-			// check if the vehicle should be replaced
-			if (!p->engine_renew ||
-					w->age - w->max_age < (p->engine_renew_months * 30) || // replace if engine is too old
-					w->max_age == 0) { // rail cars got a max age of 0
-				if (!EngineHasReplacementForPlayer(p, w->engine_type)) // updates to a new model
-					continue;
-			}
-
-			/* Now replace the vehicle */
-			temp_cost = ReplaceVehicle(&w, flags, cost);
-
-			if (flags & DC_EXEC &&
-					(w->type != VEH_Train || w->u.rail.first_engine == INVALID_ENGINE)) {
-				/* now we bought a new engine and sold the old one. We need to fix the
-				 * pointers in order to avoid pointing to the old one for trains: these
-				 * pointers should point to the front engine and not the cars
-				 */
-				v = w;
-			}
-
-			if (!CmdFailed(temp_cost)) {
-				cost += temp_cost;
-			}
-		} while (w->type == VEH_Train && (w = GetNextVehicle(w)) != NULL);
-
-		if (!(flags & DC_EXEC) && (p->money64 < (int32)(cost + p->engine_renew_money) || cost == 0)) {
-			if (!check && p->money64 < (int32)(cost + p->engine_renew_money) && ( _local_player == v->owner ) && cost != 0) {
-				StringID message;
-				SetDParam(0, v->unitnumber);
-				switch (v->type) {
-					case VEH_Train:    message = STR_TRAIN_AUTORENEW_FAILED;       break;
-					case VEH_Road:     message = STR_ROADVEHICLE_AUTORENEW_FAILED; break;
-					case VEH_Ship:     message = STR_SHIP_AUTORENEW_FAILED;        break;
-					case VEH_Aircraft: message = STR_AIRCRAFT_AUTORENEW_FAILED;    break;
-						// This should never happen
-					default: NOT_REACHED(); message = 0; break;
-				}
-
-				AddNewsItem(message, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);
-			}
-			if (stopped) v->vehstatus &= ~VS_STOPPED;
-			if (display_costs) _current_player = OWNER_NONE;
-			return CMD_ERROR;
-		}
-
-		if (flags & DC_EXEC) {
-			break; // we are done replacing since the loop ran once with DC_EXEC
-		} else if (check) {
-			/* It's a test only and we know that we can do this
-			 * NOTE: payment for wagon removal is NOT included in this price */
-			return cost;
-		}
-		// now we redo the loop, but this time we actually do stuff since we know that we can do it
-		flags |= DC_EXEC;
-	}
-
-	/* If setting is on to try not to exceed the old length of the train with the replacement */
-	if (v->type == VEH_Train && p->renew_keep_length) {
-		Vehicle *temp;
-		w = v;
-
-		while (v->u.rail.cached_total_length > old_total_length) {
-			// the train is too long. We will remove cars one by one from the start of the train until it's short enough
-			while (w != NULL && !(RailVehInfo(w->engine_type)->flags&RVI_WAGON) ) {
-				w = GetNextVehicle(w);
-			}
-			if (w == NULL) {
-				// we failed to make the train short enough
-				SetDParam(0, v->unitnumber);
-				AddNewsItem(STR_TRAIN_TOO_LONG_AFTER_REPLACEMENT, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);
-				break;
-			}
-			temp = w;
-			w = GetNextVehicle(w);
-			DoCommand(0, (INVALID_VEHICLE << 16) | temp->index, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
-			MoveVehicleCargo(v, temp);
-			cost += DoCommand(0, temp->index, 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
-		}
-	}
-
-	if (stopped) v->vehstatus &= ~VS_STOPPED;
-	if (display_costs) {
-		if (IsLocalPlayer()) ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost);
-		_current_player = OWNER_NONE;
-	}
-	return cost;
-}
-
-/* Extend the list size for BuildDepotVehicleList() */
-static inline void ExtendVehicleListSize(const Vehicle ***engine_list, uint16 *engine_list_length, uint16 step_size)
-{
-	*engine_list_length = min(*engine_list_length + step_size, GetMaxVehicleIndex() + 1);
-	*engine_list = realloc((void*)*engine_list, (*engine_list_length) * sizeof((*engine_list)[0]));
-}
-
-/** Generates a list of vehicles inside a depot
- * Will enlarge allocated space for the list if they are too small, so it's ok to call with (pointer to NULL array, pointer to uninitised uint16, pointer to 0)
- * If one of the lists is not needed (say wagons when finding ships), all the pointers regarding that list should be set to NULL
- * @param Type type of vehicle
- * @param tile The tile the depot is located in
- * @param ***engine_list Pointer to a pointer to an array of vehicles in the depot (old list is freed and a new one is malloced)
- * @param *engine_list_length Allocated size of engine_list. Needs to be set to 0 when engine_list points to a NULL array
- * @param *engine_count The number of engines stored in the list
- * @param ***wagon_list Pointer to a pointer to an array of free wagons in the depot (old list is freed and a new one is malloced)
- * @param *wagon_list_length Allocated size of wagon_list. Needs to be set to 0 when wagon_list points to a NULL array
- * @param *wagon_count The number of engines stored in the list
- */
-void BuildDepotVehicleList(byte type, TileIndex tile, Vehicle ***engine_list, uint16 *engine_list_length, uint16 *engine_count, Vehicle ***wagon_list, uint16 *wagon_list_length, uint16 *wagon_count)
-{
-	Vehicle *v;
-
-	/* This function should never be called without an array to store results */
-	assert(!(engine_list == NULL && type != VEH_Train));
-	assert(!(type == VEH_Train && engine_list == NULL && wagon_list == NULL));
-
-	/* Both array and the length should either be NULL to disable the list or both should not be NULL */
-	assert((engine_list == NULL && engine_list_length == NULL) || (engine_list != NULL && engine_list_length != NULL));
-	assert((wagon_list == NULL && wagon_list_length == NULL) || (wagon_list != NULL && wagon_list_length != NULL));
-
-	assert(!(engine_list != NULL && engine_count == NULL));
-	assert(!(wagon_list != NULL && wagon_count == NULL));
-
-	if (engine_count != NULL) *engine_count = 0;
-	if (wagon_count != NULL) *wagon_count = 0;
-
-	switch (type) {
-		case VEH_Train:
-			FOR_ALL_VEHICLES(v) {
-				if (v->tile == tile && v->type == VEH_Train && v->u.rail.track == 0x80) {
-					if (IsFrontEngine(v)) {
-						if (engine_list == NULL) continue;
-						if (*engine_count == *engine_list_length) ExtendVehicleListSize((const Vehicle***)engine_list, engine_list_length, 25);
-						(*engine_list)[(*engine_count)++] = v;
-					} else if (IsFreeWagon(v)) {
-						if (wagon_list == NULL) continue;
-						if (*wagon_count == *wagon_list_length) ExtendVehicleListSize((const Vehicle***)wagon_list, wagon_list_length, 25);
-						(*wagon_list)[(*wagon_count)++] = v;
-					}
-				}
-			}
-			break;
-
-		case VEH_Road:
-			FOR_ALL_VEHICLES(v) {
-				if (v->tile == tile && v->type == VEH_Road && IsRoadVehInDepot(v)) {
-					if (*engine_count == *engine_list_length) ExtendVehicleListSize((const Vehicle***)engine_list, engine_list_length, 25);
-					(*engine_list)[(*engine_count)++] = v;
-				}
-			}
-			break;
-
-		case VEH_Ship:
-			FOR_ALL_VEHICLES(v) {
-				if (v->tile == tile && v->type == VEH_Ship && IsShipInDepot(v)) {
-					if (*engine_count == *engine_list_length) ExtendVehicleListSize((const Vehicle***)engine_list, engine_list_length, 25);
-					(*engine_list)[(*engine_count)++] = v;
-				}
-			}
-			break;
-
-		case VEH_Aircraft:
-			FOR_ALL_VEHICLES(v) {
-				if (v->tile == tile &&
-						v->type == VEH_Aircraft &&
-						v->subtype <= 2 &&
-						v->vehstatus & VS_HIDDEN) {
-					if (*engine_count == *engine_list_length) ExtendVehicleListSize((const Vehicle***)engine_list, engine_list_length, 25);
-					(*engine_list)[(*engine_count)++] = v;
-				}
-			}
-			break;
-
-		default: NOT_REACHED();
-	}
-}
-
-/**
-* @param sort_list list to store the list in. Either NULL or the length length_of_array tells
-* @param length_of_array informs the length allocated for sort_list. This is not the same as the number of vehicles in the list. Needs to be 0 when sort_list is NULL
-* @param type type of vehicle
-* @param owner PlayerID of owner to generate a list for
-* @param station index of station to generate a list for. INVALID_STATION when not used
-* @param order index of oder to generate a list for. INVALID_ORDER when not used
-* @param window_type tells what kind of window the list is for. Use the VLW flags in vehicle_gui.h
-* @return the number of vehicles added to the list
-*/
-uint GenerateVehicleSortList(const Vehicle ***sort_list, uint16 *length_of_array, byte type, PlayerID owner, StationID station, OrderID order, uint16 depot_airport_index, uint16 window_type)
-{
-	const uint subtype = (type != VEH_Aircraft) ? Train_Front : 2;
-	uint n = 0;
-	const Vehicle *v;
-
-	switch (window_type) {
-		case VLW_STATION_LIST: {
-			FOR_ALL_VEHICLES(v) {
-				if (v->type == type && (
-					(type == VEH_Train && IsFrontEngine(v)) ||
-					(type != VEH_Train && v->subtype <= subtype))) {
-					const Order *order;
-
-					FOR_VEHICLE_ORDERS(v, order) {
-						if (order->type == OT_GOTO_STATION && order->dest == station) {
-							if (n == *length_of_array) ExtendVehicleListSize(sort_list, length_of_array, 50);
-							(*sort_list)[n++] = v;
-							break;
-						}
-					}
-				}
-			}
-			break;
-		}
-
-		case VLW_SHARED_ORDERS: {
-			FOR_ALL_VEHICLES(v) {
-				/* Find a vehicle with the order in question */
-				if (v->orders != NULL && v->orders->index == order) break;
-			}
-
-			if (v != NULL && v->orders != NULL && v->orders->index == order) {
-				/* Only try to make the list if we found a vehicle using the order in question */
-				for (v = GetFirstVehicleFromSharedList(v); v != NULL; v = v->next_shared) {
-					if (n == *length_of_array) ExtendVehicleListSize(sort_list, length_of_array, 25);
-					(*sort_list)[n++] = v;
-				}
-			}
-			break;
-		}
-
-		case VLW_STANDARD: {
-			FOR_ALL_VEHICLES(v) {
-				if (v->type == type && v->owner == owner && (
-					(type == VEH_Train && IsFrontEngine(v)) ||
-					(type != VEH_Train && v->subtype <= subtype))) {
-					/* TODO find a better estimate on the total number of vehicles for current player */
-					if (n == *length_of_array) ExtendVehicleListSize(sort_list, length_of_array, GetNumVehicles()/4);
-					(*sort_list)[n++] = v;
-				}
-			}
-			break;
-		}
-
-		case VLW_DEPOT_LIST: {
-			FOR_ALL_VEHICLES(v) {
-				if (v->type == type && (
-					(type == VEH_Train && IsFrontEngine(v)) ||
-					(type != VEH_Train && v->subtype <= subtype))) {
-					const Order *order;
-
-					FOR_VEHICLE_ORDERS(v, order) {
-						if (order->type == OT_GOTO_DEPOT && order->dest == depot_airport_index) {
-							if (n == *length_of_array) ExtendVehicleListSize(sort_list, length_of_array, 25);
-							(*sort_list)[n++] = v;
-							break;
-						}
-					}
-				}
-			}
-			break;
-		}
-
-		default: NOT_REACHED(); break;
-	}
-
-	if ((n + 100) < *length_of_array) {
-		/* We allocated way too much for sort_list.
-		 * Now we will reduce how much we allocated.
-		 * We will still make it have room for 50 extra vehicles to prevent having
-		 * to move the whole array if just one vehicle is added later */
-		*length_of_array = n + 50;
-		*sort_list = realloc((void*)*sort_list, (*length_of_array) * sizeof((*sort_list)[0]));
-	}
-
-	return n;
-}
-
-/** send all vehicles of type to depots
- * @param type type of vehicle
- * @param flags the flags used for DoCommand()
- * @param service should the vehicles only get service in the depots
- * @param owner PlayerID of owner of the vehicles to send
- * @param VLW_flag tells what kind of list requested the goto depot
- * @return 0 for success and CMD_ERROR if no vehicle is able to go to depot
- */
-int32 SendAllVehiclesToDepot(byte type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id)
-{
-	const Vehicle **sort_list = NULL;
-	uint n, i;
-	uint16 array_length = 0;
-
-	n = GenerateVehicleSortList(&sort_list, &array_length, type, owner, id, id, id, vlw_flag);
-
-	/* Send all the vehicles to a depot */
-	for (i = 0; i < n; i++) {
-		const Vehicle *v = sort_list[i];
-		int32 ret = DoCommand(v->tile, v->index, service | DEPOT_DONT_CANCEL, flags, CMD_SEND_TO_DEPOT(type));
-
-		/* Return 0 if DC_EXEC is not set this is a valid goto depot command)
-			* In this case we know that at least one vehicle can be sent to a depot
-			* and we will issue the command. We can now safely quit the loop, knowing
-			* it will succeed at least once. With DC_EXEC we really need to send them to the depot */
-		if (!CmdFailed(ret) && !(flags & DC_EXEC)) {
-			free((void*)sort_list);
-			return 0;
-		}
-	}
-
-	free((void*)sort_list);
-	return (flags & DC_EXEC) ? 0 : CMD_ERROR;
-}
-
-bool IsVehicleInDepot(const Vehicle *v)
-{
-	switch (v->type) {
-		case VEH_Train:    return CheckTrainInDepot(v, false) != -1;
-		case VEH_Road:     return IsRoadVehInDepot(v);
-		case VEH_Ship:     return IsShipInDepot(v);
-		case VEH_Aircraft: return IsAircraftInHangar(v);
-		default: NOT_REACHED();
-	}
-	return false;
-}
-
-void VehicleEnterDepot(Vehicle *v)
-{
-	switch (v->type) {
-		case VEH_Train:
-			InvalidateWindowClasses(WC_TRAINS_LIST);
-			if (!IsFrontEngine(v)) v = GetFirstVehicleInChain(v);
-			UpdateSignalsOnSegment(v->tile, GetRailDepotDirection(v->tile));
-			v->load_unload_time_rem = 0;
-			break;
-
-		case VEH_Road:
-			InvalidateWindowClasses(WC_ROADVEH_LIST);
-			v->u.road.state = 254;
-			break;
-
-		case VEH_Ship:
-			InvalidateWindowClasses(WC_SHIPS_LIST);
-			v->u.ship.state = 0x80;
-			RecalcShipStuff(v);
-			break;
-
-		case VEH_Aircraft:
-			InvalidateWindowClasses(WC_AIRCRAFT_LIST);
-			HandleAircraftEnterHangar(v);
-			break;
-		default: NOT_REACHED();
-	}
-
-	if (v->type != VEH_Train) {
-		/* Trains update the vehicle list when the first unit enters the depot and calls VehicleEnterDepot() when the last unit enters.
-		 * We only increase the number of vehicles when the first one enters, so we will not need to search for more vehicles in the depot */
-		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
-	}
-	InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
-
-	v->vehstatus |= VS_HIDDEN;
-	v->cur_speed = 0;
-
-	VehicleServiceInDepot(v);
-
-	TriggerVehicle(v, VEHICLE_TRIGGER_DEPOT);
-
-	if (v->current_order.type == OT_GOTO_DEPOT) {
-		Order t;
-
-		InvalidateWindow(WC_VEHICLE_VIEW, v->index);
-
-		t = v->current_order;
-		v->current_order.type = OT_DUMMY;
-		v->current_order.flags = 0;
-
-		if (t.refit_cargo < NUM_CARGO) {
-			int32 cost;
-
-			_current_player = v->owner;
-			cost = DoCommand(v->tile, v->index, t.refit_cargo | t.refit_subtype << 8, DC_EXEC, CMD_REFIT_VEH(v->type));
-
-			if (CmdFailed(cost)) {
-				v->leave_depot_instantly = false; // We ensure that the vehicle stays in the depot
-				if (v->owner == _local_player) {
-					/* Notify the user that we stopped the vehicle */
-					SetDParam(0, _vehicle_type_names[v->type - 0x10]);
-					SetDParam(1, v->unitnumber);
-					AddNewsItem(STR_ORDER_REFIT_FAILED, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);
-				}
-			} else if (v->owner == _local_player && cost != 0) {
-				ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost);
-			}
-		}
-
-		if (HASBIT(t.flags, OFB_PART_OF_ORDERS)) {
-			/* Part of orders */
-			if (v->type == VEH_Train) v->u.rail.days_since_order_progr = 0;
-			v->cur_order_index++;
-		} else if (HASBIT(t.flags, OFB_HALT_IN_DEPOT)) {
-			/* Force depot visit */
-			v->vehstatus |= VS_STOPPED;
-			if (v->owner == _local_player) {
-				StringID string;
-
-				switch (v->type) {
-					case VEH_Train:    string = STR_8814_TRAIN_IS_WAITING_IN_DEPOT; break;
-					case VEH_Road:     string = STR_9016_ROAD_VEHICLE_IS_WAITING;   break;
-					case VEH_Ship:     string = STR_981C_SHIP_IS_WAITING_IN_DEPOT;  break;
-					case VEH_Aircraft: string = STR_A014_AIRCRAFT_IS_WAITING_IN;    break;
-					default: NOT_REACHED(); string = STR_EMPTY; // Set the string to something to avoid a compiler warning
-				}
-
-				SetDParam(0, v->unitnumber);
-				AddNewsItem(string, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),	v->index, 0);
-			}
-		}
-	}
-}
-
-/** Give a custom name to your vehicle
- * @param tile unused
- * @param p1 vehicle ID to name
- * @param p2 unused
- */
-int32 CmdNameVehicle(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle *v;
-	StringID str;
-
-	if (!IsValidVehicleID(p1) || _cmd_text[0] == '\0') return CMD_ERROR;
-
-	v = GetVehicle(p1);
-
-	if (!CheckOwnership(v->owner)) return CMD_ERROR;
-
-	str = AllocateNameUnique(_cmd_text, 2);
-	if (str == 0) return CMD_ERROR;
-
-	if (flags & DC_EXEC) {
-		StringID old_str = v->string_id;
-		v->string_id = str;
-		DeleteName(old_str);
-		ResortVehicleLists();
-		MarkWholeScreenDirty();
-	} else {
-		DeleteName(str);
-	}
-
-	return 0;
-}
-
-
-/** Change the service interval of a vehicle
- * @param tile unused
- * @param p1 vehicle ID that is being service-interval-changed
- * @param p2 new service interval
- */
-int32 CmdChangeServiceInt(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
-{
-	Vehicle* v;
-	uint16 serv_int = GetServiceIntervalClamped(p2); /* Double check the service interval from the user-input */
-
-	if (serv_int != p2 || !IsValidVehicleID(p1)) return CMD_ERROR;
-
-	v = GetVehicle(p1);
-
-	if (!CheckOwnership(v->owner)) return CMD_ERROR;
-
-	if (flags & DC_EXEC) {
-		v->service_interval = serv_int;
-		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
-	}
-
-	return 0;
-}
-
-
-static Rect _old_vehicle_coords;
-
-void BeginVehicleMove(Vehicle *v) {
-	_old_vehicle_coords.left = v->left_coord;
-	_old_vehicle_coords.top = v->top_coord;
-	_old_vehicle_coords.right = v->right_coord;
-	_old_vehicle_coords.bottom = v->bottom_coord;
-}
-
-void EndVehicleMove(Vehicle *v)
-{
-	MarkAllViewportsDirty(
-		min(_old_vehicle_coords.left,v->left_coord),
-		min(_old_vehicle_coords.top,v->top_coord),
-		max(_old_vehicle_coords.right,v->right_coord)+1,
-		max(_old_vehicle_coords.bottom,v->bottom_coord)+1
-	);
-}
-
-/* returns true if staying in the same tile */
-bool GetNewVehiclePos(const Vehicle *v, GetNewVehiclePosResult *gp)
-{
-	static const int8 _delta_coord[16] = {
-		-1,-1,-1, 0, 1, 1, 1, 0, /* x */
-		-1, 0, 1, 1, 1, 0,-1,-1, /* y */
-	};
-
-	int x = v->x_pos + _delta_coord[v->direction];
-	int y = v->y_pos + _delta_coord[v->direction + 8];
-
-	gp->x = x;
-	gp->y = y;
-	gp->old_tile = v->tile;
-	gp->new_tile = TileVirtXY(x, y);
-	return gp->old_tile == gp->new_tile;
-}
-
-static const Direction _new_direction_table[] = {
-	DIR_N , DIR_NW, DIR_W ,
-	DIR_NE, DIR_SE, DIR_SW,
-	DIR_E , DIR_SE, DIR_S
-};
-
-Direction GetDirectionTowards(const Vehicle* v, int x, int y)
-{
-	Direction dir;
-	DirDiff dirdiff;
-	int i = 0;
-
-	if (y >= v->y_pos) {
-		if (y != v->y_pos) i+=3;
-		i+=3;
-	}
-
-	if (x >= v->x_pos) {
-		if (x != v->x_pos) i++;
-		i++;
-	}
-
-	dir = v->direction;
-
-	dirdiff = DirDifference(_new_direction_table[i], dir);
-	if (dirdiff == DIRDIFF_SAME) return dir;
-	return ChangeDir(dir, dirdiff > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
-}
-
-Trackdir GetVehicleTrackdir(const Vehicle* v)
-{
-	if (v->vehstatus & VS_CRASHED) return 0xFF;
-
-	switch (v->type) {
-		case VEH_Train:
-			if (v->u.rail.track == 0x80) /* We'll assume the train is facing outwards */
-				return DiagdirToDiagTrackdir(GetRailDepotDirection(v->tile)); /* Train in depot */
-
-			if (v->u.rail.track == 0x40) /* train in tunnel, so just use his direction and assume a diagonal track */
-				return DiagdirToDiagTrackdir(DirToDiagDir(v->direction));
-
-			return TrackDirectionToTrackdir(FIND_FIRST_BIT(v->u.rail.track),v->direction);
-
-		case VEH_Ship:
-			if (IsShipInDepot(v))
-				/* We'll assume the ship is facing outwards */
-				return DiagdirToDiagTrackdir(GetShipDepotDirection(v->tile));
-
-			return TrackDirectionToTrackdir(FIND_FIRST_BIT(v->u.ship.state),v->direction);
-
-		case VEH_Road:
-			if (IsRoadVehInDepot(v)) /* We'll assume the road vehicle is facing outwards */
-				return DiagdirToDiagTrackdir(GetRoadDepotDirection(v->tile));
-
-			if (IsRoadStopTile(v->tile)) /* We'll assume the road vehicle is facing outwards */
-				return DiagdirToDiagTrackdir(GetRoadStopDir(v->tile)); /* Road vehicle in a station */
-
-			/* If vehicle's state is a valid track direction (vehicle is not turning around) return it */
-			if ((v->u.road.state & 7) < 6) return v->u.road.state;
-
-			/* Vehicle is turning around, get the direction from vehicle's direction */
-			return DiagdirToDiagTrackdir(DirToDiagDir(v->direction));
-
-		/* case VEH_Aircraft: case VEH_Special: case VEH_Disaster: */
-		default: return 0xFF;
-	}
-}
-/* Return value has bit 0x2 set, when the vehicle enters a station. Then,
- * result << 8 contains the id of the station entered. If the return value has
- * bit 0x8 set, the vehicle could not and did not enter the tile. Are there
- * other bits that can be set? */
-uint32 VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y)
-{
-	return _tile_type_procs[GetTileType(tile)]->vehicle_enter_tile_proc(v, tile, x, y);
-}
-
-UnitID GetFreeUnitNumber(byte type)
-{
-	UnitID unit, max = 0;
-	const Vehicle *u;
-	static bool *cache = NULL;
-	static UnitID gmax = 0;
-
-	switch (type) {
-		case VEH_Train:    max = _patches.max_trains; break;
-		case VEH_Road:     max = _patches.max_roadveh; break;
-		case VEH_Ship:     max = _patches.max_ships; break;
-		case VEH_Aircraft: max = _patches.max_aircraft; break;
-		default: NOT_REACHED();
-	}
-
-	if (max == 0) {
-		/* we can't build any of this kind of vehicle, so we just return 1 instead of looking for a free number
-		 * a max of 0 will cause the following code to write to a NULL pointer
-		 * We know that 1 is bigger than the max allowed vehicle number, so it's the same as returning something, that is too big
-		 */
-		return 1;
-	}
-
-	if (max > gmax) {
-		gmax = max;
-		free(cache);
-		cache = malloc((max + 1) * sizeof(*cache));
-	}
-
-	// Clear the cache
-	memset(cache, 0, (max + 1) * sizeof(*cache));
-
-	// Fill the cache
-	FOR_ALL_VEHICLES(u) {
-		if (u->type == type && u->owner == _current_player && u->unitnumber != 0 && u->unitnumber <= max)
-			cache[u->unitnumber] = true;
-	}
-
-	// Find the first unused unit number
-	for (unit = 1; unit <= max; unit++) {
-		if (!cache[unit]) break;
-	}
-
-	return unit;
-}
-
-static PalSpriteID GetEngineColourMap(EngineID engine_type, PlayerID player, EngineID parent_engine_type, CargoID cargo_type)
-{
-	SpriteID map;
-	const Player *p = GetPlayer(player);
-	LiveryScheme scheme = LS_DEFAULT;
-
-	/* The default livery is always available for use, but its in_use flag determines
-	 * whether any _other_ liveries are in use. */
-	if (p->livery[LS_DEFAULT].in_use && (_patches.liveries == 2 || (_patches.liveries == 1 && player == _local_player))) {
-		/* Determine the livery scheme to use */
-		switch (GetEngine(engine_type)->type) {
-			case VEH_Train: {
-				switch (_engine_info[engine_type].railtype) {
-					case RAILTYPE_RAIL:
-					case RAILTYPE_ELECTRIC:
-					{
-						const RailVehicleInfo *rvi = RailVehInfo(engine_type);
-
-						if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type;
-						if (rvi->flags & RVI_WAGON) {
-							if (cargo_type == CT_PASSENGERS || cargo_type == CT_MAIL || cargo_type == CT_VALUABLES) {
-								if (parent_engine_type == INVALID_ENGINE) {
-									scheme = LS_PASSENGER_WAGON_STEAM;
-								} else {
-									switch (RailVehInfo(parent_engine_type)->engclass) {
-										case 0: scheme = LS_PASSENGER_WAGON_STEAM; break;
-										case 1: scheme = LS_PASSENGER_WAGON_DIESEL; break;
-										case 2: scheme = LS_PASSENGER_WAGON_ELECTRIC; break;
-									}
-								}
-							} else {
-								scheme = LS_FREIGHT_WAGON;
-							}
-						} else {
-							bool is_mu = HASBIT(_engine_info[engine_type].misc_flags, EF_RAIL_IS_MU);
-
-							switch (rvi->engclass) {
-								case 0: scheme = LS_STEAM; break;
-								case 1: scheme = is_mu ? LS_DMU : LS_DIESEL; break;
-								case 2: scheme = is_mu ? LS_EMU : LS_ELECTRIC; break;
-							}
-						}
-						break;
-					}
-
-					case RAILTYPE_MONO: scheme = LS_MONORAIL; break;
-					case RAILTYPE_MAGLEV: scheme = LS_MAGLEV; break;
-				}
-				break;
-			}
-
-			case VEH_Road: {
-				const RoadVehicleInfo *rvi = RoadVehInfo(engine_type);
-				if (cargo_type == CT_INVALID) cargo_type = rvi->cargo_type;
-				scheme = (cargo_type == CT_PASSENGERS) ? LS_BUS : LS_TRUCK;
-				break;
-			}
-
-			case VEH_Ship: {
-				const ShipVehicleInfo *svi = ShipVehInfo(engine_type);
-				if (cargo_type == CT_INVALID) cargo_type = svi->cargo_type;
-				scheme = (cargo_type == CT_PASSENGERS) ? LS_PASSENGER_SHIP : LS_FREIGHT_SHIP;
-				break;
-			}
-
-			case VEH_Aircraft: {
-				const AircraftVehicleInfo *avi = AircraftVehInfo(engine_type);
-				if (cargo_type == CT_INVALID) cargo_type = CT_PASSENGERS;
-				switch (avi->subtype) {
-					case 0: scheme = LS_HELICOPTER; break;
-					case 1: scheme = LS_SMALL_PLANE; break;
-					case 3: scheme = LS_LARGE_PLANE; break;
-				}
-				break;
-			}
-		}
-
-		/* Switch back to the default scheme if the resolved scheme is not in use */
-		if (!p->livery[scheme].in_use) scheme = LS_DEFAULT;
-	}
-
-	map = HASBIT(EngInfo(engine_type)->misc_flags, EF_USES_2CC) ?
-		(SPR_2CCMAP_BASE + p->livery[scheme].colour1 + p->livery[scheme].colour2 * 16) :
-		(PALETTE_RECOLOR_START + p->livery[scheme].colour1);
-
-	return SPRITE_PALETTE(map << PALETTE_SPRITE_START);
-}
-
-PalSpriteID GetEnginePalette(EngineID engine_type, PlayerID player)
-{
-	return GetEngineColourMap(engine_type, player, INVALID_ENGINE, CT_INVALID);
-}
-
-PalSpriteID GetVehiclePalette(const Vehicle *v)
-{
-	if (v->type == VEH_Train) {
-		return GetEngineColourMap(
-			(v->u.rail.first_engine != INVALID_ENGINE && (IsArticulatedPart(v) || UsesWagonOverride(v))) ?
-				v->u.rail.first_engine : v->engine_type,
-			v->owner,
-			v->u.rail.first_engine,
-			v->cargo_type);
-	}
-
-	return GetEngineColourMap(v->engine_type, v->owner, INVALID_ENGINE, v->cargo_type);
-}
-
-// Save and load of vehicles
-const SaveLoad _common_veh_desc[] = {
-	    SLE_VAR(Vehicle, subtype,              SLE_UINT8),
-
-	    SLE_REF(Vehicle, next,                 REF_VEHICLE_OLD),
-	    SLE_VAR(Vehicle, string_id,            SLE_STRINGID),
-	SLE_CONDVAR(Vehicle, unitnumber,           SLE_FILE_U8  | SLE_VAR_U16,  0, 7),
-	SLE_CONDVAR(Vehicle, unitnumber,           SLE_UINT16,                  8, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, owner,                SLE_UINT8),
-	SLE_CONDVAR(Vehicle, tile,                 SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, tile,                 SLE_UINT32,                  6, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, dest_tile,            SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, dest_tile,            SLE_UINT32,                  6, SL_MAX_VERSION),
-
-	SLE_CONDVAR(Vehicle, x_pos,                SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, x_pos,                SLE_UINT32,                  6, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, y_pos,                SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, y_pos,                SLE_UINT32,                  6, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, z_pos,                SLE_UINT8),
-	    SLE_VAR(Vehicle, direction,            SLE_UINT8),
-
-	    SLE_VAR(Vehicle, cur_image,            SLE_UINT16),
-	    SLE_VAR(Vehicle, spritenum,            SLE_UINT8),
-	    SLE_VAR(Vehicle, sprite_width,         SLE_UINT8),
-	    SLE_VAR(Vehicle, sprite_height,        SLE_UINT8),
-	    SLE_VAR(Vehicle, z_height,             SLE_UINT8),
-	    SLE_VAR(Vehicle, x_offs,               SLE_INT8),
-	    SLE_VAR(Vehicle, y_offs,               SLE_INT8),
-	    SLE_VAR(Vehicle, engine_type,          SLE_UINT16),
-
-	    SLE_VAR(Vehicle, max_speed,            SLE_UINT16),
-	    SLE_VAR(Vehicle, cur_speed,            SLE_UINT16),
-	    SLE_VAR(Vehicle, subspeed,             SLE_UINT8),
-	    SLE_VAR(Vehicle, acceleration,         SLE_UINT8),
-	    SLE_VAR(Vehicle, progress,             SLE_UINT8),
-
-	    SLE_VAR(Vehicle, vehstatus,            SLE_UINT8),
-	SLE_CONDVAR(Vehicle, last_station_visited, SLE_FILE_U8  | SLE_VAR_U16,  0, 4),
-	SLE_CONDVAR(Vehicle, last_station_visited, SLE_UINT16,                  5, SL_MAX_VERSION),
-
-	    SLE_VAR(Vehicle, cargo_type,           SLE_UINT8),
-	SLE_CONDVAR(Vehicle, cargo_subtype,        SLE_UINT8,                  35, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, cargo_days,           SLE_UINT8),
-	SLE_CONDVAR(Vehicle, cargo_source,         SLE_FILE_U8  | SLE_VAR_U16,  0, 6),
-	SLE_CONDVAR(Vehicle, cargo_source,         SLE_UINT16,                  7, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, cargo_cap,            SLE_UINT16),
-	    SLE_VAR(Vehicle, cargo_count,          SLE_UINT16),
-
-	    SLE_VAR(Vehicle, day_counter,          SLE_UINT8),
-	    SLE_VAR(Vehicle, tick_counter,         SLE_UINT8),
-
-	    SLE_VAR(Vehicle, cur_order_index,      SLE_UINT8),
-	    SLE_VAR(Vehicle, num_orders,           SLE_UINT8),
-
-	/* This next line is for version 4 and prior compatibility.. it temporarily reads
-	    type and flags (which were both 4 bits) into type. Later on this is
-	    converted correctly */
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, type), SLE_UINT8,                 0, 4),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, dest), SLE_FILE_U8 | SLE_VAR_U16, 0, 4),
-
-	/* Orders for version 5 and on */
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, type),  SLE_UINT8,  5, SL_MAX_VERSION),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, flags), SLE_UINT8,  5, SL_MAX_VERSION),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, dest),  SLE_UINT16, 5, SL_MAX_VERSION),
-
-	/* Refit in current order */
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, refit_cargo),    SLE_UINT8, 36, SL_MAX_VERSION),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, refit_subtype),  SLE_UINT8, 36, SL_MAX_VERSION),
-
-	    SLE_REF(Vehicle, orders,               REF_ORDER),
-
-	SLE_CONDVAR(Vehicle, age,                  SLE_FILE_U16 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, age,                  SLE_INT32,                  31, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, max_age,              SLE_FILE_U16 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, max_age,              SLE_INT32,                  31, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, date_of_last_service, SLE_FILE_U16 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, date_of_last_service, SLE_INT32,                  31, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, service_interval,     SLE_FILE_U16 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, service_interval,     SLE_INT32,                  31, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, reliability,          SLE_UINT16),
-	    SLE_VAR(Vehicle, reliability_spd_dec,  SLE_UINT16),
-	    SLE_VAR(Vehicle, breakdown_ctr,        SLE_UINT8),
-	    SLE_VAR(Vehicle, breakdown_delay,      SLE_UINT8),
-	    SLE_VAR(Vehicle, breakdowns_since_last_service, SLE_UINT8),
-	    SLE_VAR(Vehicle, breakdown_chance,     SLE_UINT8),
-	SLE_CONDVAR(Vehicle, build_year,           SLE_FILE_U8 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, build_year,           SLE_INT32,                 31, SL_MAX_VERSION),
-
-	    SLE_VAR(Vehicle, load_unload_time_rem, SLE_UINT16),
-	SLE_CONDVAR(Vehicle, load_status,          SLE_UINT8,                 40, SL_MAX_VERSION),
-
-	    SLE_VAR(Vehicle, profit_this_year,     SLE_INT32),
-	    SLE_VAR(Vehicle, profit_last_year,     SLE_INT32),
-	    SLE_VAR(Vehicle, value,                SLE_UINT32),
-
-	    SLE_VAR(Vehicle, random_bits,          SLE_UINT8),
-	    SLE_VAR(Vehicle, waiting_triggers,     SLE_UINT8),
-
-	    SLE_REF(Vehicle, next_shared,          REF_VEHICLE),
-	    SLE_REF(Vehicle, prev_shared,          REF_VEHICLE),
-
-	// reserve extra space in savegame here. (currently 10 bytes)
-	SLE_CONDNULL(10,                                                       2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-
-static const SaveLoad _train_desc[] = {
-	SLE_WRITEBYTE(Vehicle, type, VEH_Train, 0), // Train type. VEH_Train in mem, 0 in file.
-	SLE_INCLUDEX(0, INC_VEHICLE_COMMON),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRail, crash_anim_pos),         SLE_UINT16),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRail, force_proceed),          SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRail, railtype),               SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRail, track),                  SLE_UINT8),
-
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleRail, flags),                  SLE_UINT8,  2, SL_MAX_VERSION),
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleRail, days_since_order_progr), SLE_UINT16, 2, SL_MAX_VERSION),
-
-	SLE_CONDNULL(2, 2, 19),
-	// reserve extra space in savegame here. (currently 11 bytes)
-	SLE_CONDNULL(11, 2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-static const SaveLoad _roadveh_desc[] = {
-	SLE_WRITEBYTE(Vehicle, type, VEH_Road, 1), // Road type. VEH_Road in mem, 1 in file.
-	SLE_INCLUDEX(0, INC_VEHICLE_COMMON),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, state),          SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, frame),          SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, blocked_ctr),    SLE_UINT16),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, overtaking),     SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, overtaking_ctr), SLE_UINT8),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, crashed_ctr),    SLE_UINT16),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, reverse_ctr),    SLE_UINT8),
-
-	SLE_CONDREFX(offsetof(Vehicle, u) + offsetof(VehicleRoad, slot),     REF_ROADSTOPS, 6, SL_MAX_VERSION),
-	SLE_CONDNULL(1,                                                                     6, SL_MAX_VERSION),
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleRoad, slot_age), SLE_UINT8,     6, SL_MAX_VERSION),
-	// reserve extra space in savegame here. (currently 16 bytes)
-	SLE_CONDNULL(16,                                                                    2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-static const SaveLoad _ship_desc[] = {
-	SLE_WRITEBYTE(Vehicle, type, VEH_Ship, 2), // Ship type. VEH_Ship in mem, 2 in file.
-	SLE_INCLUDEX(0, INC_VEHICLE_COMMON),
-	SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleShip, state), SLE_UINT8),
-
-	// reserve extra space in savegame here. (currently 16 bytes)
-	SLE_CONDNULL(16, 2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-static const SaveLoad _aircraft_desc[] = {
-	SLE_WRITEBYTE(Vehicle, type, VEH_Aircraft, 3), // Aircraft type. VEH_Aircraft in mem, 3 in file.
-	SLE_INCLUDEX(0, INC_VEHICLE_COMMON),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleAir, crashed_counter), SLE_UINT16),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleAir, pos),             SLE_UINT8),
-
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleAir, targetairport),   SLE_FILE_U8 | SLE_VAR_U16, 0, 4),
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleAir, targetairport),   SLE_UINT16,                5, SL_MAX_VERSION),
-
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleAir, state),           SLE_UINT8),
-
-	SLE_CONDVARX(offsetof(Vehicle, u) + offsetof(VehicleAir, previous_pos),    SLE_UINT8,                 2, SL_MAX_VERSION),
-
-	// reserve extra space in savegame here. (currently 15 bytes)
-	SLE_CONDNULL(15,                                                                                      2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-static const SaveLoad _special_desc[] = {
-	SLE_WRITEBYTE(Vehicle,type,VEH_Special, 4),
-
-	    SLE_VAR(Vehicle, subtype,       SLE_UINT8),
-
-	SLE_CONDVAR(Vehicle, tile,          SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
-	SLE_CONDVAR(Vehicle, tile,          SLE_UINT32,                 6, SL_MAX_VERSION),
-
-	SLE_CONDVAR(Vehicle, x_pos,         SLE_FILE_I16 | SLE_VAR_I32, 0, 5),
-	SLE_CONDVAR(Vehicle, x_pos,         SLE_INT32,                  6, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, y_pos,         SLE_FILE_I16 | SLE_VAR_I32, 0, 5),
-	SLE_CONDVAR(Vehicle, y_pos,         SLE_INT32,                  6, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, z_pos,         SLE_UINT8),
-
-	    SLE_VAR(Vehicle, cur_image,     SLE_UINT16),
-	    SLE_VAR(Vehicle, sprite_width,  SLE_UINT8),
-	    SLE_VAR(Vehicle, sprite_height, SLE_UINT8),
-	    SLE_VAR(Vehicle, z_height,      SLE_UINT8),
-	    SLE_VAR(Vehicle, x_offs,        SLE_INT8),
-	    SLE_VAR(Vehicle, y_offs,        SLE_INT8),
-	    SLE_VAR(Vehicle, progress,      SLE_UINT8),
-	    SLE_VAR(Vehicle, vehstatus,     SLE_UINT8),
-
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleSpecial, unk0), SLE_UINT16),
-	    SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleSpecial, unk2), SLE_UINT8),
-
-	// reserve extra space in savegame here. (currently 16 bytes)
-	SLE_CONDNULL(16, 2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-static const SaveLoad _disaster_desc[] = {
-	SLE_WRITEBYTE(Vehicle, type, VEH_Disaster, 5),
-
-	    SLE_REF(Vehicle, next,          REF_VEHICLE_OLD),
-
-	    SLE_VAR(Vehicle, subtype,       SLE_UINT8),
-	SLE_CONDVAR(Vehicle, tile,          SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, tile,          SLE_UINT32,                  6, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, dest_tile,     SLE_FILE_U16 | SLE_VAR_U32,  0, 5),
-	SLE_CONDVAR(Vehicle, dest_tile,     SLE_UINT32,                  6, SL_MAX_VERSION),
-
-	SLE_CONDVAR(Vehicle, x_pos,         SLE_FILE_I16 | SLE_VAR_I32,  0, 5),
-	SLE_CONDVAR(Vehicle, x_pos,         SLE_INT32,                   6, SL_MAX_VERSION),
-	SLE_CONDVAR(Vehicle, y_pos,         SLE_FILE_I16 | SLE_VAR_I32,  0, 5),
-	SLE_CONDVAR(Vehicle, y_pos,         SLE_INT32,                   6, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, z_pos,         SLE_UINT8),
-	    SLE_VAR(Vehicle, direction,     SLE_UINT8),
-
-	    SLE_VAR(Vehicle, x_offs,        SLE_INT8),
-	    SLE_VAR(Vehicle, y_offs,        SLE_INT8),
-	    SLE_VAR(Vehicle, sprite_width,  SLE_UINT8),
-	    SLE_VAR(Vehicle, sprite_height, SLE_UINT8),
-	    SLE_VAR(Vehicle, z_height,      SLE_UINT8),
-	    SLE_VAR(Vehicle, owner,         SLE_UINT8),
-	    SLE_VAR(Vehicle, vehstatus,     SLE_UINT8),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, dest), SLE_FILE_U8 | SLE_VAR_U16, 0, 4),
-	SLE_CONDVARX(offsetof(Vehicle, current_order) + offsetof(Order, dest), SLE_UINT16,                5, SL_MAX_VERSION),
-
-	    SLE_VAR(Vehicle, cur_image,     SLE_UINT16),
-	SLE_CONDVAR(Vehicle, age,           SLE_FILE_U16 | SLE_VAR_I32,  0, 30),
-	SLE_CONDVAR(Vehicle, age,           SLE_INT32,                  31, SL_MAX_VERSION),
-	    SLE_VAR(Vehicle, tick_counter,  SLE_UINT8),
-
-	   SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleDisaster, image_override), SLE_UINT16),
-	   SLE_VARX(offsetof(Vehicle, u) + offsetof(VehicleDisaster, unk2),           SLE_UINT16),
-
-	// reserve extra space in savegame here. (currently 16 bytes)
-	SLE_CONDNULL(16,                                                 2, SL_MAX_VERSION),
-
-	SLE_END()
-};
-
-
-static const void *_veh_descs[] = {
-	_train_desc,
-	_roadveh_desc,
-	_ship_desc,
-	_aircraft_desc,
-	_special_desc,
-	_disaster_desc,
-};
-
-// Will be called when the vehicles need to be saved.
-static void Save_VEHS(void)
-{
-	Vehicle *v;
-	// Write the vehicles
-	FOR_ALL_VEHICLES(v) {
-		SlSetArrayIndex(v->index);
-		SlObject(v, _veh_descs[v->type - 0x10]);
-	}
-}
-
-// Will be called when vehicles need to be loaded.
-static void Load_VEHS(void)
-{
-	int index;
-	Vehicle *v;
-
-	while ((index = SlIterateArray()) != -1) {
-		Vehicle *v;
-
-		if (!AddBlockIfNeeded(&_Vehicle_pool, index))
-			error("Vehicles: failed loading savegame: too many vehicles");
-
-		v = GetVehicle(index);
-		SlObject(v, _veh_descs[SlReadByte()]);
-
-		/* Old savegames used 'last_station_visited = 0xFF' */
-		if (CheckSavegameVersion(5) && v->last_station_visited == 0xFF)
-			v->last_station_visited = INVALID_STATION;
-
-		if (CheckSavegameVersion(5)) {
-			/* Convert the current_order.type (which is a mix of type and flags, because
-			 *  in those versions, they both were 4 bits big) to type and flags */
-			v->current_order.flags = (v->current_order.type & 0xF0) >> 4;
-			v->current_order.type  =  v->current_order.type & 0x0F;
-		}
-	}
-
-	/* Check for shared order-lists (we now use pointers for that) */
-	if (CheckSavegameVersionOldStyle(5, 2)) {
-		FOR_ALL_VEHICLES(v) {
-			Vehicle *u;
-
-			FOR_ALL_VEHICLES_FROM(u, v->index + 1) {
-				/* If a vehicle has the same orders, add the link to eachother
-				 *  in both vehicles */
-				if (v->orders == u->orders) {
-					v->next_shared = u;
-					u->prev_shared = v;
-					break;
-				}
-			}
-		}
-	}
-}
-
-const ChunkHandler _veh_chunk_handlers[] = {
-	{ 'VEHS', Save_VEHS, Load_VEHS, CH_SPARSE_ARRAY | CH_LAST},
-};