virtual ~Aircraft() { this->PreDestructor(); }

	void MarkDirty();

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_AIRCRAFT_INC : EXPENSES_AIRCRAFT_RUN; }

	bool IsPrimaryVehicle() const                  { return this->IsNormalAircraft(); }

	void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const;

#include "safeguards.h"

{

	this->x_offs = -1;

	this->y_offs = -1;

		u->engine_type = e->index;

		v->subtype = (avi->subtype & AIR_CTOL ? AIR_AIRCRAFT : AIR_HELICOPTER);

		u->subtype = AIR_SHADOW;

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

			w->random_bits = VehicleRandomBits();

			/* Use rotor's air.state to store the rotor animation frame */

			w->state = HRS_ROTOR_STOPPED;

			u->SetNext(w);

			w->UpdatePosition();

 */

static void AircraftLandAirplane(Aircraft *v)

{

	if (!PlayVehicleSound(v, VSE_TOUCHDOWN)) {

		SndPlayVehicleFx(SND_17_SKID_PLANE, v);

static void AircraftEventHandler_StartTakeOff(Aircraft *v, const AirportFTAClass *apc)

{

	v->state = ENDTAKEOFF;

}

static void AircraftEventHandler_EndTakeOff(Aircraft *v, const AirportFTAClass *apc)

static void AircraftEventHandler_HeliTakeOff(Aircraft *v, const AirportFTAClass *apc)

{

	v->state = FLYING;

	/* get the next position to go to, differs per airport */

	AircraftNextAirportPos_and_Order(v);

static void AircraftEventHandler_HeliLanding(Aircraft *v, const AirportFTAClass *apc)

{

	v->state = HELIENDLANDING;

}

static void AircraftEventHandler_EndLanding(Aircraft *v, const AirportFTAClass *apc)

	this->direction = direction;

	this->tile = TileVirtXY(x, y);

	this->subtype = subtype;

	this->owner = OWNER_NONE;

	this->image_override = 0;

	this->current_order.Free();

	}

}

{

	this->x_offs        = -1;

	this->y_offs        = -1;

	virtual ~DisasterVehicle() {}

	void UpdatePosition(int x, int y, int z);

	void UpdateImage();

	bool Tick();

};

	v->y_pos = y;

	v->z_pos = z;

	v->tile = 0;

	v->vehstatus = VS_UNCLICKABLE;

	_effect_init_procs[type](v);

	return _effect_tick_procs[this->subtype](this);

}

{

	this->x_offs        = 0;

	this->y_offs        = 0;

	/** We want to 'destruct' the right class. */

	virtual ~EffectVehicle() {}

	bool Tick();

	TransparencyOption GetTransparencyOption() const;

};

	friend struct GroundVehicle<RoadVehicle, VEH_ROAD>; // GroundVehicle needs to use the acceleration functions defined at RoadVehicle.

	void MarkDirty();

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_ROADVEH_INC : EXPENSES_ROADVEH_RUN; }

	bool IsPrimaryVehicle() const { return this->IsFrontEngine(); }

	void GetImage(Direction direction, EngineImageType image_type, VehicleSpriteSeq *result) const;

	this->CargoChanged();

}

{

	static const int8 _delta_xy_table[8][10] = {

		/* y_extent, x_extent, y_offs, x_offs, y_bb_offs, x_bb_offs, y_extent_shorten, x_extent_shorten, y_bb_offs_shorten, x_bb_offs_shorten */

	};

	int shorten = VEHICLE_LENGTH - this->gcache.cached_veh_length;

	this->x_bb_offs     = bb[5] + bb[9] * shorten;

	this->y_bb_offs     = bb[4] + bb[8] * shorten;;

	this->x_offs        = bb[3];

			default: break;

		}

		v->coord.left = INVALID_COORD;

		v->UpdatePosition();

		v->UpdateViewport(false);

	virtual ~Ship() { this->PreDestructor(); }

	void MarkDirty();

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_SHIP_INC : EXPENSES_SHIP_RUN; }

	void PlayLeaveStationSound() const;

	bool IsPrimaryVehicle() const { return true; }

	}

}

{

	static const int8 _delta_xy_table[8][4] = {

		/* y_extent, x_extent, y_offs, x_offs */

		{32,  6, -16,  -3}, // NW

	};

	this->x_offs        = bb[3];

	this->y_offs        = bb[2];

	this->x_extent      = bb[1];

		v->y_pos = y;

		v->z_pos = GetSlopePixelZ(x, y);

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

		v->spritenum = svi->image_index;

	friend struct GroundVehicle<Train, VEH_TRAIN>; // GroundVehicle needs to use the acceleration functions defined at Train.

	void MarkDirty();

	ExpensesType GetExpenseType(bool income) const { return income ? EXPENSES_TRAIN_INC : EXPENSES_TRAIN_RUN; }

	void PlayLeaveStationSound() const;

	bool IsPrimaryVehicle() const { return this->IsFrontEngine(); }

	return cost;

}

{

	/* Set common defaults. */

	this->x_offs    = -1;

	this->x_bb_offs =  0;

	this->y_bb_offs =  0;

		static const int _sign_table[] =

		{

			/* x, y */

		int half_shorten = (VEHICLE_LENGTH - this->gcache.cached_veh_length) / 2;

		/* For all straight directions, move the bound box to the centre of the vehicle, but keep the size. */

		this->x_extent += this->x_bb_offs = half_shorten * _sign_table[direction];

		this->y_extent += this->y_bb_offs = half_shorten * _sign_table[direction + 1];

	} else {

				/* Shorten southern corner of the bounding box according the vehicle length

				 * and center the bounding box on the vehicle. */

			case DIR_NE:

		}

		/* update image of train, as well as delta XY */

		v->x_pos = gp.x;

		v->y_pos = gp.y;

	/**

	 * Updates the x and y offsets and the size of the sprite used

	 * for this vehicle.

	 */

	/**

	 * Determines the effective direction-specific vehicle movement speed.

		/* Explicitly choose method to call to prevent vtable dereference -

		 * it gives ~3% runtime improvements in games with many vehicles */

		VehicleSpriteSeq seq;

		((T *)this)->T::GetImage(this->direction, EIT_ON_MAP, &seq);

		if (force_update || this->sprite_seq != seq) {