if (!IsValidVehicle(vehicle_id)) return -1;

	const Vehicle *v = ::Vehicle::Get(vehicle_id);

}

/* static */ VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id)

		 * and we run out of available vehicles, bail out. */

		if (!Vehicle::CanAllocateItem()) return;

		const Engine *e_artic = Engine::Get(engine_type);

		switch (type) {

			default: NOT_REACHED();

				t->subtype = 0;

				t->track = front->track;

				t->railtype = front->railtype;

				t->spritenum = e_artic->u.rail.image_index;

				if (e_artic->CanCarryCargo()) {

				v = rv;

				rv->subtype = 0;

				rv->state = RVSB_IN_DEPOT;

				rv->roadtype = front->roadtype;

	if (old_head->type == VEH_TRAIN) {

		/* Store the length of the old vehicle chain, rounded up to whole tiles */

		int num_units = 0; ///< Number of units in the chain

		for (Train *w = Train::From(old_head); w != NULL; w = w->GetNextUnit()) num_units++;

			}

			/* When wagon removal is enabled and the new engines without any wagons are already longer than the old, we have to fail */

			/* Append/insert wagons into the new vehicle chain

			 * We do this from back to front, so we can stop when wagon removal or maximum train length (i.e. from mammoth-train setting) is triggered.

						/* Insert wagon after 'last_engine' */

						CommandCost res = MoveVehicle(append, last_engine, DC_EXEC, false);

							MoveVehicle(append, NULL, DC_EXEC | DC_AUTOREPLACE, false);

							break;

						}

						this->sel, free_wagon ? 0 : this->hscroll->GetPosition(), this->vehicle_over);

				/* Number of wagons relative to a standard length wagon (rounded up) */

				DrawString(rtl ? left + WD_FRAMERECT_LEFT : right - this->count_width, rtl ? left + this->count_width : right - WD_FRAMERECT_RIGHT, y + (this->resize.step_height - FONT_HEIGHT_SMALL) / 2, STR_TINY_BLACK_COMA, TC_FROMSTRING, SA_RIGHT); // Draw the counter

				break;

			}

					this->sel = v->index;

					this->SetDirty();

					_cursor.vehchain = _ctrl_pressed;

				}

				break;

	if (v->type == VEH_TRAIN) {

		/* Each platform tile is worth 2 rail vehicles. */

		if (overhang > 0) {

			unloading_time <<= 1;

			unloading_time += (overhang * unloading_time) / 8;

	uint16 cached_max_track_speed;  ///< Maximum consist speed limited by track type (valid only for the first engine).

	uint32 cached_power;            ///< Total power of the consist (valid only for the first engine).

	uint32 cached_air_drag;         ///< Air drag coefficient of the vehicle (valid only for the first engine).

};

/** Ground vehicle flags. */

	if (v == NULL) {

		if (!Company::IsValidID(_current_company)) return 0;

		l = GetEngineLivery(engine, _current_company, INVALID_ENGINE, NULL, LIT_ALL);

	} else {

		l = GetEngineLivery(v->engine_type, v->owner, INVALID_ENGINE, v, LIT_ALL);

	}

			switch (variable - 0x80) {

				case 0x62: return t->track;

				case 0x66: return t->railtype;

				case 0x74: return t->gcache.cached_power;

				case 0x75: return GB(t->gcache.cached_power,  8, 24);

				case 0x76: return GB(t->gcache.cached_power, 16, 16);

	} else {

		cargo = v->cargo_type;

			 * to use may be different than the one cached. It happens for callback 0x15 (refit engine),

			 * as v->cargo_type is temporary changed to the new type */

			if (group != NULL) return group;

		}

	}

		VehicleCache       *veh_cache = CallocT<VehicleCache>(length);

		GroundVehicleCache *gro_cache = CallocT<GroundVehicleCache>(length);

		TrainCache         *tra_cache = CallocT<TrainCache>(length);

		length = 0;

		for (const Vehicle *u = v; u != NULL; u = u->Next()) {

					break;

				case VEH_ROAD:

					gro_cache[length] = RoadVehicle::From(u)->gcache;

					break;

				default:

					break;

					if (memcmp(&gro_cache[length], &RoadVehicle::From(u)->gcache, sizeof(GroundVehicleCache)) != 0) {

						DEBUG(desync, 2, "road vehicle ground vehicle cache mismatch: vehicle %i, company %i, unit number %i, wagon %i", v->index, (int)v->owner, v->unitnumber, length);

					}

					break;

				default:

					break;

		free(veh_cache);

		free(gro_cache);

		free(tra_cache);

	}

	/* Check whether the caches are still valid */

		const Train *v = Yapf().GetVehicle();

		assert(v != NULL);

		assert(v->type == VEH_TRAIN);

		if (missing_platform_length < 0) {

			/* apply penalty for longer platform than needed */

			cost += Yapf().PfGetSettings().rail_longer_platform_penalty + Yapf().PfGetSettings().rail_longer_platform_per_tile_penalty * -missing_platform_length;

int TicksToLeaveDepot(const Train *v)

{

	DiagDirection dir = GetRailDepotDirection(v->tile);

	switch (dir) {

		case DIAGDIR_NE: return  ((int)(v->x_pos & 0x0F) - ((_fractcoords_enter[dir] & 0x0F) - (length + 1)));

	/* calculate the point where the following wagon should be activated

	 * this depends on the length of the current vehicle */

	byte fract_coord_leave =

		((_fractcoords_enter[dir] & 0x0F) + // x

 */

void RoadStop::Entry::Leave(const RoadVehicle *rv)

{

	assert(this->occupied >= 0);

}

	/* we cannot assert on this->occupied < this->length because of the

	 * remote possibility that RVs are running through eachother when

	 * trying to prevention an infinite jam. */

}

/**

	this->occupied = 0;

	for (RVList::iterator it = rserh.vehicles.begin(); it != rserh.vehicles.end(); it++) {

	}

}

void RoadVehUpdateCache(RoadVehicle *v);

/**

 * Buses, trucks and trams belong to this class.

 */

struct RoadVehicle : public GroundVehicle<RoadVehicle, VEH_ROAD> {

	byte state;             ///< @see RoadVehicleStates

	byte frame;

	uint16 blocked_ctr;

		offset->x = reference_width / 2;

		offset->y = 0;

	}

}

static SpriteID GetRoadVehIcon(EngineID engine)

	v->InvalidateNewGRFCacheOfChain();

	for (RoadVehicle *u = v; u != NULL; u = u->Next()) {

		/* Check the v->first cache. */

		assert(u->First() == v);

		/* Update the 'first engine' */

		/* Update the length of the vehicle. */

		/* Update visual effect */

		v->UpdateVisualEffect();

		v->last_station_visited = INVALID_STATION;

		v->engine_type = e->index;

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

		v->roadtype = HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;

		v->compatible_roadtypes = RoadTypeToRoadTypes(v->roadtype);

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);

	 * it's on a depot tile, check if it's time to activate the next vehicle in

	 * the chain yet. */

	if (v->Next() != NULL && IsRoadDepotTile(v->tile)) {

			RoadVehLeaveDepot(v->Next(), false);

		}

	}

		if (part_of_load) v->fill_percent_te_id = INVALID_TE_ID;

		v->first = NULL;

	}

	/* AfterLoadVehicles may also be called in case of NewGRF reload, in this

	uint16 last_speed; // NOSAVE: only used in UI

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

	bool cached_tilt;           ///< train can tilt; feature provides a bonus in curves

	/* cached max. speed / acceleration data */

	int cached_max_curve_speed; ///< max consist speed limited by curves

};

/**

	{

		/* For powered wagons the engine defines the type of engine (i.e. railtype) */

		if (HasBit(this->flags, VRF_POWEREDWAGON) && HasPowerOnRail(head->railtype, GetRailType(this->tile))) {

		}

		return 0;

		/* Powered wagons have extra weight added. */

		if (HasBit(this->flags, VRF_POWEREDWAGON)) {

		}

		return weight;

			for (const Train *u = v, *w = v->Next(); w != NULL; u = w, w = w->Next()) {

				if (u->track != TRACK_BIT_DEPOT) {

					if ((w->track != TRACK_BIT_DEPOT &&

							(w->track == TRACK_BIT_DEPOT && TicksToLeaveDepot(u) <= 0)) {

						SetDParam(0, v->index);

						SetDParam(1, v->owner);

	const RailVehicleInfo *rvi_v = RailVehInfo(this->engine_type);

	EngineID first_engine = this->IsFrontEngine() ? this->engine_type : INVALID_ENGINE;

	this->compatible_railtypes = RAILTYPES_NONE;

	bool train_can_tilt = true;

		assert(u->First() == this);

		/* update the 'first engine' */

		u->railtype = rvi_u->railtype;

		if (u->IsEngine()) first_engine = u->engine_type;

		if (!HasBit(e_u->info.misc_flags, EF_RAIL_TILTS)) train_can_tilt = false;

		/* Cache wagon override sprite group. NULL is returned if there is none */

		/* Reset colour map */

		u->colourmap = PAL_NONE;

		veh_len = 8 - Clamp(veh_len, 0, 7);

		/* verify length hasn't changed */

		/* update vehicle length? */

		this->InvalidateNewGRFCache();

		u->InvalidateNewGRFCache();

	}

	/* Default to the middle of the station for stations stops that are not in

	 * the order list like intermediate stations when non-stop is disabled */

	OrderStopLocation osl = OSL_PLATFORM_MIDDLE;

		/* The train is longer than the station, make it stop at the far end of the platform */

		osl = OSL_PLATFORM_FAR_END;

	} else if (v->current_order.IsType(OT_GOTO_STATION) && v->current_order.GetDestination() == station_id) {

		default: NOT_REACHED();

		case OSL_PLATFORM_NEAR_END:

			break;

		case OSL_PLATFORM_MIDDLE:

			break;

		case OSL_PLATFORM_FAR_END:

	/* Subtract half the front vehicle length of the train so we get the real

	 * stop location of the train. */

}

		offset->x = reference_width / 2;

		offset->y = vehicle_pitch;

	}

}

static SpriteID GetDefaultTrainSprite(uint8 spritenum, Direction direction)

		v->spritenum = rvi->image_index;

		v->engine_type = e->index;

		DiagDirection dir = GetRailDepotDirection(tile);

		v->last_station_visited = INVALID_STATION;

		v->engine_type = e->index;

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

			allowed_len--; // We do not count articulated parts and rear heads either.

			/* Back up and clear the first_engine data to avoid using wagon override group */

			/* We don't want the cache to interfere. head's cache is cleared before

			 * the loop and after each callback does not need to be cleared here. */

			uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, head->engine_type, t, head);

			/* Restore original first_engine data */

			/* We do not want to remember any cached variables from the test run */

			t->InvalidateNewGRFCache();

		last = last->Previous();

		first = first->Next();

		/* do not update images now

		 * negative differential will be handled in AdvanceWagonsAfterSwap() */

		last = last->Previous();

		first = first->Next();

		/* do not update images now */

		for (int i = 0; i < differential; i++) TrainController(first, (nomove ? last->Next() : NULL));

	}

	/* do not reverse when approaching red signal */

		/* we are too near the tile end, reverse now */

		v->cur_speed = 0;

		ReverseTrainDirection(v);

PaletteID GetVehiclePalette(const Vehicle *v)

{

	}

	return GetEngineColourMap(v->engine_type, v->owner, INVALID_ENGINE, v);

/** Sort vehicles by their length */

static int CDECL VehicleLengthSorter(const Vehicle * const *a, const Vehicle * const *b)

{

	return (r != 0) ? r : VehicleNumberSorter(a, b);

}