return true;

		}

		v->current_order.SetDestination(1);

		RoadVehicle *u;

		FOR_ALL_ROADVEHICLES(u) {

				v->dest_tile = u->index;

				v->age = 0;

				return true;

			}

		}

		delete v;

		return false;

	} else {

		/* Target a vehicle */

		RoadVehicle *u = RoadVehicle::Get(v->dest_tile);

		uint dist = Delta(v->x_pos, u->x_pos) + Delta(v->y_pos, u->y_pos);

		if (dist < TILE_SIZE && !(u->vehstatus & VS_HIDDEN) && u->breakdown_ctr == 0) {

			u->breakdown_ctr = 3;

			u->breakdown_delay = 140;

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

	const char *GetTypeString() const { return "road vehicle"; }

	void MarkDirty();

	void UpdateDeltaXY(Direction direction);

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

	SpriteID GetImage(Direction direction) const;

	int GetDisplaySpeed() const { return this->cur_speed / 2; }

	int GetDisplayMaxSpeed() const { return this->vcache.cached_max_speed / 2; }

	Money GetRunningCost() const;

	int GetDisplayImageWidth(Point *offset = NULL) const;

	bool IsInDepot() const { return this->state == RVSB_IN_DEPOT; }

	int GetCurrentMaxSpeed() const;

	/**

	 * Check if vehicle is a front engine

	 * @return Returns true if vehicle is a front engine

	 */

	/**

	 * Set front engine state

	 */

	/**

	 * Check if vehicl is an articulated part of an engine

	 * @return Returns true if vehicle is an articulated part

	 */

	FORCEINLINE bool IsArticulatedPart() const { return this->subtype == RVST_ARTIC_PART; }

/**

 * Check whether a roadvehicle is a bus

 * @return true if bus

 */

bool RoadVehicle::IsBus() const

{

	return IsCargoInClass(this->cargo_type, CC_PASSENGERS);

}

/**

 * Get the width of a road vehicle image in the GUI.

 * @param offset Additional offset for positioning the sprite; set to NULL if not needed

	return length;

}

void RoadVehUpdateCache(RoadVehicle *v)

{

	assert(v->type == VEH_ROAD);

	v->InvalidateNewGRFCacheOfChain();

	v->gcache.cached_total_length = 0;

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

		v->date_of_last_service = _date;

		v->build_year = _cur_year;

		v->cur_image = SPR_IMG_QUERY;

		v->random_bits = VehicleRandomBits();

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

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

		v->gcache.cached_veh_length = 8;

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

bool RoadVehicle::IsStoppedInDepot() const

{

	TileIndex tile = this->tile;

	if (!IsRoadDepotTile(tile)) return false;

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

		if (v->state != RVSB_IN_DEPOT || v->tile != tile) return false;

	}

	return true;

}

			abs(v->y_pos - u->y_pos) <= 4) ? v : NULL;

}

uint RoadVehicle::Crash(bool flooded)

{

	uint pass = Vehicle::Crash(flooded);

		pass += 1; // driver

		/* If we're in a drive through road stop we ought to leave it */

		if (IsInsideMM(this->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END)) {

			RoadStop::GetByTile(this->tile, GetRoadStopType(this->tile))->Leave(this);

		}

	if (v->IsInDepot()) return true;

	if (v->state == RVSB_WORMHOLE) {

		/* Vehicle is entering a depot or is on a bridge or in a tunnel */

		GetNewVehiclePosResult gp = GetNewVehiclePos(v);

			const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);

			if (u != NULL) {

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

				return false;

			}

		}

		(_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)) ^ v->overtaking][v->frame + 1];

	if (rd.x & RDE_NEXT_TILE) {

		TileIndex tile = v->tile + TileOffsByDiagDir((DiagDirection)(rd.x & 3));

		Trackdir dir;

			/* If this is the front engine, look for the right path. */

			dir = RoadFindPathToDest(v, tile, (DiagDirection)(rd.x & 3));

		} else {

			dir = FollowPreviousRoadVehicle(v, prev, tile, (DiagDirection)(rd.x & 3), false);

		}

		if (dir == INVALID_TRACKDIR) {

			v->cur_speed = 0;

			return false;

		}

again:

		uint start_frame = RVC_DEFAULT_START_FRAME;

					case TRACKDIR_RVREV_NE: needed = ROAD_SW; break;

					case TRACKDIR_RVREV_SE: needed = ROAD_NW; break;

					case TRACKDIR_RVREV_SW: needed = ROAD_NE; break;

					case TRACKDIR_RVREV_NW: needed = ROAD_SE; break;

				}

				if ((v->Previous() != NULL && v->Previous()->tile == tile) ||

							(needed & GetRoadBits(tile, ROADTYPE_TRAM)) != ROAD_NONE)) {

					/*

					 * Taking the 'big' corner for trams only happens when:

					 * - The previous vehicle in this (articulated) tram chain is

					 *   already on the 'next' tile, we just follow them regardless of

					 *   anything. When it is NOT on the 'next' tile, the tram started

					 *   doing a reversing turn when the piece of tram track on the next

					 *   tile did not exist yet. Do not use the big tram loop as that is

					 *   going to cause the tram to split up.

					 * - Or the front of the tram can drive over the next tile.

					 */

					/*

					 * Taking the 'small' corner for trams only happens when:

					 * - We are not the from vehicle of an articulated tram.

					 * - Or when the company cannot build on the next tile.

					 *

					 * The 'small' corner means that the vehicle is on the end of a

		const RoadDriveEntry *rdp = _road_drive_data[v->roadtype][(dir + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)) ^ v->overtaking];

		int x = TileX(tile) * TILE_SIZE + rdp[start_frame].x;

		int y = TileY(tile) * TILE_SIZE + rdp[start_frame].y;

		Direction new_dir = RoadVehGetSlidingDirection(v, x, y);

			Vehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);

			if (u != NULL) {

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

				return false;

			}

		}

				case DIAGDIR_NW: dir = TRACKDIR_RVREV_SE; break;

				case DIAGDIR_NE: dir = TRACKDIR_RVREV_SW; break;

				case DIAGDIR_SE: dir = TRACKDIR_RVREV_NW; break;

				case DIAGDIR_SW: dir = TRACKDIR_RVREV_NE; break;

			}

		} else {

				/* If this is the front engine, look for the right path. */

				dir = RoadFindPathToDest(v, v->tile, (DiagDirection)(rd.x & 3));

			} else {

				dir = FollowPreviousRoadVehicle(v, prev, v->tile, (DiagDirection)(rd.x & 3), true);

			}

		}

		const RoadDriveEntry *rdp = _road_drive_data[v->roadtype][(_settings_game.vehicle.road_side << RVS_DRIVE_SIDE) + dir];

		int x = TileX(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].x;

		int y = TileY(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].y;

		Direction new_dir = RoadVehGetSlidingDirection(v, x, y);

		uint32 r = VehicleEnterTile(v, v->tile, x, y);

		if (HasBit(r, VETS_CANNOT_ENTER)) {

			v->cur_speed = 0;

			return false;

		}

	/* Calculate new position for the vehicle */

	int x = (v->x_pos & ~15) + (rd.x & 15);

	int y = (v->y_pos & ~15) + (rd.y & 15);

	Direction new_dir = RoadVehGetSlidingDirection(v, x, y);

		/* Vehicle is not in a road stop.

		 * Check for another vehicle to overtake */

		RoadVehicle *u = RoadVehFindCloseTo(v, x, y, new_dir);

		if (u != NULL) {

			u = u->First();

	/* If the vehicle is in a normal road stop and the frame equals the stop frame OR

	 * if the vehicle is in a drive-through road stop and this is the destination station

	 * and it's the correct type of stop (bus or truck) and the frame equals the stop frame...

	 * (the station test and stop type test ensure that other vehicles, using the road stop as

	 * a through route, do not stop) */

			_road_stop_stop_frame[v->state - RVSB_IN_ROAD_STOP + (_settings_game.vehicle.road_side << RVS_DRIVE_SIDE)] == v->frame) ||

			(IsInsideMM(v->state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&

			v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile)) &&

			v->owner == GetTileOwner(v->tile) &&

			GetRoadStopType(v->tile) == (v->IsBus() ? ROADSTOP_BUS : ROADSTOP_TRUCK) &&

			v->frame == RVC_DRIVE_THROUGH_STOP_FRAME))) {

	return GetPrice(e->u.road.running_cost_class, cost_factor, e->grf_prop.grffile);

}

bool RoadVehicle::Tick()

{

		if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;

		return RoadVehController(this);

	}

	return true;

}

	v->dest_tile = rfdd.tile;

	SetWindowWidgetDirty(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);

}

void RoadVehicle::OnNewDay()

{

	if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);

	if (this->blocked_ctr == 0) CheckVehicleBreakdown(this);

	AgeVehicle(this);

	CheckIfRoadVehNeedsService(this);

	if (IsSavegameVersionBefore(121)) {

		/* Delete small ufos heading for non-existing vehicles */

		Vehicle *v;

		FOR_ALL_DISASTERVEHICLES(v) {

			if (v->subtype == 2/*ST_SMALL_UFO*/ && v->current_order.GetDestination() != 0) {

				const Vehicle *u = Vehicle::GetIfValid(v->dest_tile);

					delete v;

				}

			}

		}

		/* We didn't store cargo payment yet, so make them for vehicles that are

				}

				break;

			}

			case VEH_ROAD: {

				RoadVehicle *rv = RoadVehicle::From(v);

					RoadVehUpdateCache(rv);

					if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {

						rv->CargoChanged();

					}

				}

				break;

 */

static bool RoadVehAccelerationModelChanged(int32 p1)

{

	if (_settings_game.vehicle.roadveh_acceleration_model != AM_ORIGINAL) {

		RoadVehicle *rv;

		FOR_ALL_ROADVEHICLES(rv) {

				rv->CargoChanged();

			}

		}

	}

	/* These windows show acceleration values only when realistic acceleration is on. They must be redrawn after a setting change. */

 * @return Always true.

 */

static bool RoadVehSlopeSteepnessChanged(int32 p1)

{

	RoadVehicle *rv;

	FOR_ALL_ROADVEHICLES(rv) {

	}

	return true;

}

static bool DragSignalsDensityChanged(int32)

				if (spd < v->cur_speed) v->cur_speed = spd;

			}

		}

	} else if (v->type == VEH_ROAD) {

		RoadVehicle *rv = RoadVehicle::From(v);

		if (rv->state < RVSB_IN_ROAD_STOP && !IsReversingRoadTrackdir((Trackdir)rv->state) && rv->frame == 0) {

				/* Attempt to allocate a parking bay in a road stop */

				return RoadStop::GetByTile(tile, GetRoadStopType(tile))->Enter(rv) ? VETSB_CONTINUE : VETSB_CANNOT_ENTER;

			}

		}

	}

{

	switch (this->type) {

		case VEH_AIRCRAFT: return Aircraft::From(this)->IsNormalAircraft(); // don't count plane shadows and helicopter rotors

		case VEH_TRAIN:

			return !Train::From(this)->IsArticulatedPart() && // tenders and other articulated parts

					!Train::From(this)->IsRearDualheaded(); // rear parts of multiheaded engines

		case VEH_SHIP: return true;

		default: return false; // Only count company buildable vehicles

	}

}

/**

			case VEH_AIRCRAFT:

			case VEH_SHIP:

				if (_age_cargo_skip_counter == 0) v->cargo.AgeCargo();

				if (v->type == VEH_TRAIN && Train::From(v)->IsWagon()) continue;

				if (v->type == VEH_AIRCRAFT && v->subtype != AIR_HELICOPTER) continue;

				v->motion_counter += 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 */