* @param p2 unused

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdBuildRoadVeh(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	if (!IsEngineBuildable(p1, VEH_ROAD, _current_company)) return_cmd_error(STR_ERROR_ROAD_VEHICLE_NOT_AVAILABLE);

	const Engine *e = Engine::Get(p1);

	/* Engines without valid cargo should not be available */

	if (e->GetDefaultCargoType() == CT_INVALID) return CMD_ERROR;

	CommandCost cost(EXPENSES_NEW_VEHICLES, e->GetCost());

	if (flags & DC_QUERY_COST) return cost;

	/* The ai_new queries the vehicle cost before building the route,

	 * so we must check against cheaters no sooner than now. --pasky */

	if (!IsRoadDepotTile(tile)) return CMD_ERROR;

	if (!IsTileOwner(tile, _current_company)) return CMD_ERROR;

	if (HasTileRoadType(tile, ROADTYPE_TRAM) != HasBit(e->info.misc_flags, EF_ROAD_TRAM)) return_cmd_error(STR_ERROR_DEPOT_WRONG_DEPOT_TYPE);

	uint num_vehicles = 1 + CountArticulatedParts(p1, false);

	/* Allow for the front and the articulated parts */

	if (!Vehicle::CanAllocateItem(num_vehicles)) {

		return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);

	}

	/* find the first free roadveh id */

	UnitID unit_num = (flags & DC_AUTOREPLACE) ? 0 : GetFreeUnitNumber(VEH_ROAD);

	if (unit_num > _settings_game.vehicle.max_roadveh) {

		return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);

	}

	if (flags & DC_EXEC) {

		const RoadVehicleInfo *rvi = &e->u.road;

		RoadVehicle *v = new RoadVehicle();

		v->unitnumber = unit_num;

		v->direction = DiagDirToDir(GetRoadDepotDirection(tile));

		v->owner = _current_company;

		v->tile = tile;

		int x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;

		int y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;

		v->x_pos = x;

		v->y_pos = y;

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

//		v->running_ticks = 0;

		v->state = RVSB_IN_DEPOT;

		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;

		v->spritenum = rvi->image_index;

		v->cargo_type = e->GetDefaultCargoType();

//		v->cargo_subtype = 0;

		v->cargo_cap = rvi->capacity;

//		v->cargo_count = 0;

		v->value = cost.GetCost();

//		v->day_counter = 0;

//		v->next_order_param = v->next_order = 0;

//		v->time_counter = 0;

//		v->progress = 0;

//		v->overtaking = 0;

		v->last_station_visited = INVALID_STATION;

		v->max_speed = rvi->max_speed;

		v->engine_type = (EngineID)p1;

		v->rcache.first_engine = INVALID_ENGINE; // needs to be set before first callback

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

		v->max_age = e->GetLifeLengthInDays();

		_new_vehicle_id = v->index;

		v->name = NULL;

		v->service_interval = Company::Get(v->owner)->settings.vehicle.servint_roadveh;

		v->date_of_last_service = _date;

		v->build_year = _cur_year;

		v->cur_image = SPR_IMG_QUERY;

		v->random_bits = VehicleRandomBits();

		v->SetRoadVehFront();

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

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

		v->rcache.cached_veh_length = 8;

		v->vehicle_flags = 0;

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

		AddArticulatedParts(v);

		v->InvalidateNewGRFCacheOfChain();

		/* Call various callbacks after the whole consist has been constructed */

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

			/* Cargo capacity is zero if and only if the vehicle cannot carry anything */

			if (u->cargo_cap != 0) u->cargo_cap = GetVehicleProperty(u, PROP_ROADVEH_CARGO_CAPACITY, u->cargo_cap);

			v->InvalidateNewGRFCache();

			u->InvalidateNewGRFCache();

		}

		VehicleMove(v, false);

		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);

		InvalidateWindowClassesData(WC_ROADVEH_LIST, 0);

		SetWindowDirty(WC_COMPANY, v->owner);

		if (IsLocalCompany()) {

			InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Road window

		}

		Company::Get(_current_company)->num_engines[p1]++;

		CheckConsistencyOfArticulatedVehicle(v);

	}

	return cost;

}

void ClearSlot(RoadVehicle *v)

{

	RoadStop *rs = v->slot;

	if (v->slot == NULL) return;

	v->slot = NULL;

	v->slot_age = 0;

	assert(rs->num_vehicles != 0);

	rs->num_vehicles--;

	DEBUG(ms, 3, "Clearing slot at 0x%X", rs->xy);

}

bool RoadVehicle::IsStoppedInDepot() const

{

	TileIndex tile = this->tile;

	if (!IsRoadDepotTile(tile)) return false;

	if (this->IsRoadVehFront() && !(this->vehstatus & VS_STOPPED)) 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;

}

/** Sell a road vehicle.

 * @param tile unused

 * @param flags operation to perform

 * @param p1 vehicle ID to be sold

 * @param p2 unused

 * @param text unused

 * @return the cost of this operation or an error

 */

CommandCost CmdSellRoadVeh(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)

{

	RoadVehicle *v = RoadVehicle::GetIfValid(p1);

	if (v == NULL || !CheckOwnership(v->owner)) return CMD_ERROR;

	if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_ERROR_CAN_T_SELL_DESTROYED_VEHICLE);

	if (!v->IsStoppedInDepot()) {

		return_cmd_error(STR_ERROR_ROAD_VEHICLE_MUST_BE_STOPPED_INSIDE_DEPOT);

	}

	CommandCost ret(EXPENSES_NEW_VEHICLES, -v->value);

	if (flags & DC_EXEC) {

		delete v;

	}

	return ret;

}

struct RoadFindDepotData {

	uint best_length;

	TileIndex tile;

	OwnerByte owner;

};

static const DiagDirection _road_pf_directions[] = {

	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, INVALID_DIAGDIR, INVALID_DIAGDIR,

	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, INVALID_DIAGDIR, INVALID_DIAGDIR

};

static bool EnumRoadSignalFindDepot(TileIndex tile, void *data, Trackdir trackdir, uint length)

{

	RoadFindDepotData *rfdd = (RoadFindDepotData*)data;

	tile += TileOffsByDiagDir(_road_pf_directions[trackdir]);

	if (IsRoadDepotTile(tile) &&

			IsTileOwner(tile, rfdd->owner) &&

			length < rfdd->best_length) {

		rfdd->best_length = length;

		rfdd->tile = tile;

	}