assert(v->type == VEH_Aircraft);

	return v->vehstatus & VS_HIDDEN && IsHangarTile(v->tile);

}

static inline bool IsAircraftInHangarStopped(const Vehicle* v)

{

	return IsAircraftInHangar(v) && v->vehstatus & VS_STOPPED;

}

uint16 AircraftDefaultCargoCapacity(CargoID cid, EngineID engine_type);

void CcCloneAircraft(bool success, TileIndex tile, uint32 p1, uint32 p2);

#endif /* AIRCRAFT_H */

	u = u->next;

	if (u != NULL) {

		u->x_pos = x;

		u->y_pos = y;

		u->z_pos = z + 5;

		BeginVehicleMove(u);

		VehiclePositionChanged(u);

		EndVehicleMove(u);

	}

}

{

	Vehicle *u;

	v->subspeed = 0;

	v->progress = 0;

	u = v->next;

	u->vehstatus |= VS_HIDDEN;

	u = u->next;

	if (u != NULL) {

		u->vehstatus |= VS_HIDDEN;

		u->cur_speed = 0;

	}

	SetAircraftPosition(v, v->x_pos, v->y_pos, v->z_pos);

}

static void PlayAircraftSound(const Vehicle* v)

{

	if (!PlayVehicleSound(v, VSE_START)) {

		SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);

	}

}

static bool UpdateAircraftSpeed(Vehicle *v)

{

	uint spd = v->acceleration * 2;

			v->current_order.dest == v->last_station_visited) {

		v->current_order.flags =

			(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER)) | OF_NON_STOP;

	}

	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_INC);

	LoadUnloadVehicle(v);

	MarkAircraftDirty(v);

	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);

	InvalidateWindowClasses(WC_AIRCRAFT_LIST);

}

static void AircraftLand(Vehicle *v)

{

	v->sprite_width = v->sprite_height = 2;

}

static void AircraftLandAirplane(Vehicle *v)

{

	AircraftLand(v);

	if (!PlayVehicleSound(v, VSE_TOUCHDOWN)) {

		SndPlayVehicleFx(SND_17_SKID_PLANE, v);

	}

	MaybeCrashAirplane(v);

////////////////////////////////////////////////////////////////////////////////

///////////////////   AIRCRAFT MOVEMENT SCHEME  ////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

static void AircraftEventHandler_EnterTerminal(Vehicle *v, const AirportFTAClass *Airport)

{

	AircraftEntersTerminal(v);

	v->u.air.state = Airport->layout[v->u.air.pos].heading;

}

static void AircraftEventHandler_EnterHangar(Vehicle *v, const AirportFTAClass *Airport)

{

	v->u.air.state = Airport->layout[v->u.air.pos].heading;

}

// In an Airport Hangar

static void AircraftEventHandler_InHangar(Vehicle *v, const AirportFTAClass *Airport)

{

	// if we just arrived, execute EnterHangar first

	if (v->u.air.previous_pos != v->u.air.pos) {

		AircraftEventHandler_EnterHangar(v, Airport);

		return;

	}

	fract_coord = (x & 0xF) + ((y & 0xF) << 4);

	if (_fractcoords_behind[dir] == fract_coord) {

		/* make sure a train is not entering the tile from behind */

		return 8;

	} else if (_fractcoords_enter[dir] == fract_coord) {

		if (DiagDirToDir(ReverseDiagDir(dir)) == v->direction) {

			/* enter the depot */

			v->u.rail.track = 0x80,

			v->vehstatus |= VS_HIDDEN; /* hide it */

			v->direction = ReverseDir(v->direction);

			if (v->next == NULL)

			v->tile = tile;

			InvalidateWindow(WC_VEHICLE_DEPOT, tile);

			return 4;

		}

	} else if (fract_coord_leave == fract_coord) {

		if (DiagDirToDir(dir) == v->direction) {

			/* leave the depot? */

			if ((v = v->next) != NULL) {

				v->vehstatus &= ~VS_HIDDEN;

				v->u.rail.track = (DiagDirToAxis(dir) == AXIS_X ? 1 : 2);

			}

		}

#include "tile.h"

#include "town_map.h"

#include "vehicle.h"

#include "viewport.h"

#include "command.h"

#include "player.h"

#include "town.h"

#include "gfx.h"

#include "sound.h"

#include "yapf/yapf.h"

#include "depot.h"

static uint CountRoadBits(RoadBits r)

{

	uint count = 0;

	if (r & ROAD_NW) ++count;

	if (r & ROAD_SW) ++count;

	if (r & ROAD_SE) ++count;

	if (r & ROAD_NE) ++count;

	return count;

}

			if (v->type == VEH_Train && !IsCrossingBarred(tile)) {

				/* train crossing a road */

				SndPlayVehicleFx(SND_0E_LEVEL_CROSSING, v);

				BarCrossing(tile);

				MarkTileDirtyByTile(tile);

			}

			break;

		case ROAD_TILE_DEPOT:

			if (v->type == VEH_Road &&

					v->u.road.frame == 11 &&

					_roadveh_enter_depot_unk0[GetRoadDepotDirection(tile)] == v->u.road.state) {

				return 4;

			}

			break;

		default: break;

	}

	return 0;

}

static void ChangeTileOwner_Road(TileIndex tile, PlayerID old_player, PlayerID new_player)

{

	if (r & 8) {

		v->cur_speed = 0;

		return;

	}

	if ((r & 4) == 0) v->u.road.frame++;

	v->cur_image = GetRoadVehImage(v, v->direction);

	UpdateRoadVehDeltaXY(v);

	RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));

}

static void AgeRoadVehCargo(Vehicle *v)

{

	if (_age_cargo_skip_counter != 0) return;

	if (v->cargo_days != 255) v->cargo_days++;

}

void RoadVeh_Tick(Vehicle *v)

{

	AgeRoadVehCargo(v);

	RoadVehController(v);

}

/* $Id$ */

#ifndef SHIP_H

#define SHIP_H

#include "vehicle.h"

void CcCloneShip(bool success, TileIndex tile, uint32 p1, uint32 p2);

static inline bool IsShipInDepot(const Vehicle* v)

{

	assert(v->type == VEH_Ship);

	return v->u.ship.state == 0x80;

}

static inline bool IsShipInDepotStopped(const Vehicle* v)

{

	return IsShipInDepot(v) && v->vehstatus & VS_STOPPED;

}

		MKIT(-16,  -3, 32,  6),

		MKIT( -3,  -3,  6,  6),

		MKIT( -3, -16,  6, 32),

	};

#undef MKIT

	uint32 x = _delta_xy_table[dir];

	v->x_offs        = GB(x,  0, 8);

	v->y_offs        = GB(x,  8, 8);

	v->sprite_width  = GB(x, 16, 8);

	v->sprite_height = GB(x, 24, 8);

}

{

	UpdateShipDeltaXY(v, v->direction);

	v->cur_image = GetShipImage(v, v->direction);

	MarkShipDirty(v);

	InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);

}

static const TileIndexDiffC _ship_leave_depot_offs[] = {

	{-1,  0},

	{ 0, -1}

};

	if ((byte)++spd == 0) return true;

	v->progress = (t = v->progress) - (byte)spd;

	return (t < v->progress);

}

static int32 EstimateShipCost(EngineID engine_type)

{

	return ShipVehInfo(engine_type)->base_cost * (_price.ship_base>>3)>>5;

}

static void ShipArrivesAt(const Vehicle* v, Station* st)

{

	/* Check if station was ever visited before */

	if (!(st->had_vehicle_of_type & HVOT_SHIP)) {

		uint32 flags;

		st->had_vehicle_of_type |= HVOT_SHIP;

		SetDParam(0, st->index);

		flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);

		AddNewsItem(

			STR_9833_CITIZENS_CELEBRATE_FIRST,

						IsBuoyTile(v->dest_tile) &&

						DistanceManhattan(v->dest_tile, gp.new_tile) <= 3) {

					/* We got within 3 tiles of our target buoy, so let's skip to our

					 * next order */

					v->cur_order_index++;

					v->current_order.type = OT_DUMMY;

					InvalidateVehicleOrder(v);

				} else {

					/* Non-buoy orders really need to reach the tile */

					if (v->dest_tile == gp.new_tile) {

						if (v->current_order.type == OT_GOTO_DEPOT) {

							if ((gp.x&0xF)==8 && (gp.y&0xF)==8) {

								return;

							}

						} else if (v->current_order.type == OT_GOTO_STATION) {

							Station *st;

							v->last_station_visited = v->current_order.dest;

							/* Process station in the orderlist. */

							st = GetStation(v->current_order.dest);

							if (st->facilities & FACIL_DOCK) { /* ugly, ugly workaround for problem with ships able to drop off cargo at wrong stations */

								v->current_order.type = OT_LOADING;

								v->current_order.flags &= OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER;

		TrainLocoHandler(v, false);

		// make sure vehicle wasn't deleted.

		if (v->type == VEH_Train && IsFrontEngine(v))

			TrainLocoHandler(v, true);

	} else if (IsFreeWagon(v) && HASBITS(v->vehstatus, VS_CRASHED)) {

		// Delete flooded standalone wagon

		if (++v->u.rail.crash_anim_pos >= 4400)

			DeleteVehicle(v);

	}

}

#define MAX_ACCEPTABLE_DEPOT_DIST 16

static void CheckIfTrainNeedsService(Vehicle *v)

{

	const Depot* depot;

	TrainFindDepotData tfdd;

	if (_patches.servint_trains == 0)                   return;

	if (!VehicleNeedsService(v))                        return;

	if (v->vehstatus & VS_STOPPED)                      return;

	if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;

	 * TODO - This is just a temporary stage, this will be removed. */

	for (v = GetVehicle(start_item); v != NULL; v = (v->index + 1 < GetVehiclePoolSize()) ? GetVehicle(v->index + 1) : NULL) v->index = start_item++;

}

/* Initialize the vehicle-pool */

MemoryPool _vehicle_pool = { "Vehicle", VEHICLES_POOL_MAX_BLOCKS, VEHICLES_POOL_BLOCK_SIZE_BITS, sizeof(Vehicle), &VehiclePoolNewBlock, NULL, 0, 0, NULL };

void VehicleServiceInDepot(Vehicle *v)

{

	v->date_of_last_service = _date;

	v->breakdowns_since_last_service = 0;

	v->reliability = GetEngine(v->engine_type)->reliability;

}

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 ?

			* 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;

}

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

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z);

void InitializeTrains(void);

byte VehicleRandomBits(void);

bool CanFillVehicle(Vehicle *v);

bool CanRefitTo(EngineID engine_type, CargoID cid_to);

CargoID FindFirstRefittableCargo(EngineID engine_type);

int32 GetRefitCost(EngineID engine_type);

void ViewportAddVehicles(DrawPixelInfo *dpi);

/* train_cmd.h */

int GetTrainImage(const Vehicle* v, Direction direction);

int GetAircraftImage(const Vehicle* v, Direction direction);

int GetRoadVehImage(const Vehicle* v, Direction direction);

int GetShipImage(const Vehicle* v, Direction direction);

Vehicle *CreateEffectVehicle(int x, int y, int z, EffectVehicle type);

Vehicle *CreateEffectVehicleAbove(int x, int y, int z, EffectVehicle type);

Vehicle *CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicle type);

uint32 VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y);

void TrainConsistChanged(Vehicle *v);

void TrainPowerChanged(Vehicle *v);

int32 GetTrainRunningCost(const Vehicle *v);

int CheckTrainStoppedInDepot(const Vehicle *v);

bool VehicleNeedsService(const Vehicle *v);

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);

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);

int32 SendAllVehiclesToDepot(byte type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id);

/* Flags to add to p2 for goto depot commands */

/* Note: bits 8-10 are used for VLW flags */

enum {

	DEPOT_SERVICE       = (1 << 0),	// The vehicle will leave the depot right after arrival (serivce only)

	DEPOT_MASS_SEND     = (1 << 1), // Tells that it's a mass send to depot command (type in VLW flag)

	DEPOT_DONT_CANCEL   = (1 << 2), // Don't cancel current goto depot command if any

	DEPOT_LOCATE_HANGAR = (1 << 3), // Find another airport if the target one lacks a hangar

};

typedef struct GetNewVehiclePosResult {

	int x,y;