tron@2186: /* $Id$ */
tron@2186: 
belugas@6889: /** @file roadveh_cmd.cpp */
belugas@6889: 
belugas@3508: #include "stdafx.h"
Darkvater@1891: #include "openttd.h"
tron@1299: #include "debug.h"
rubidium@8615: #include "tile_cmd.h"
maedhros@6949: #include "landscape.h"
tron@3144: #include "road_map.h"
tron@3959: #include "roadveh.h"
tron@3315: #include "station_map.h"
rubidium@8612: #include "command_func.h"
rubidium@9281: #include "station_base.h"
rubidium@9259: #include "news_func.h"
truelight@0: #include "pathfind.h"
matthijs@1247: #include "npf.h"
rubidium@8750: #include "player_func.h"
rubidium@8750: #include "player_base.h"
truelight@1313: #include "depot.h"
celestar@5573: #include "bridge.h"
tron@3184: #include "tunnel_map.h"
celestar@5573: #include "bridge_map.h"
matthijs@1752: #include "vehicle_gui.h"
maedhros@7353: #include "articulated_vehicles.h"
peter1138@3990: #include "newgrf_callbacks.h"
peter1138@2962: #include "newgrf_engine.h"
peter1138@4244: #include "newgrf_text.h"
peter1138@4656: #include "newgrf_sound.h"
KUDr@3900: #include "yapf/yapf.h"
peter1138@6655: #include "cargotype.h"
rubidium@8610: #include "strings_func.h"
smatz@8579: #include "tunnelbridge_map.h"
rubidium@8627: #include "functions.h"
rubidium@8627: #include "window_func.h"
rubidium@8636: #include "date_func.h"
rubidium@8640: #include "vehicle_func.h"
rubidium@8653: #include "sound_func.h"
rubidium@8707: #include "variables.h"
rubidium@8708: #include "autoreplace_gui.h"
rubidium@8720: #include "gfx_func.h"
rubidium@8766: #include "settings_type.h"
rubidium@9280: #include "order_func.h"
smatz@8579: 
rubidium@8760: #include "table/strings.h"
truelight@0: 
truelight@0: static const uint16 _roadveh_images[63] = {
truelight@0: 	0xCD4, 0xCDC, 0xCE4, 0xCEC, 0xCF4, 0xCFC, 0xD0C, 0xD14,
truelight@0: 	0xD24, 0xD1C, 0xD2C, 0xD04, 0xD1C, 0xD24, 0xD6C, 0xD74,
truelight@0: 	0xD7C, 0xC14, 0xC1C, 0xC24, 0xC2C, 0xC34, 0xC3C, 0xC4C,
truelight@0: 	0xC54, 0xC64, 0xC5C, 0xC6C, 0xC44, 0xC5C, 0xC64, 0xCAC,
truelight@0: 	0xCB4, 0xCBC, 0xD94, 0xD9C, 0xDA4, 0xDAC, 0xDB4, 0xDBC,
truelight@0: 	0xDCC, 0xDD4, 0xDE4, 0xDDC, 0xDEC, 0xDC4, 0xDDC, 0xDE4,
truelight@0: 	0xE2C, 0xE34, 0xE3C, 0xC14, 0xC1C, 0xC2C, 0xC3C, 0xC4C,
truelight@0: 	0xC5C, 0xC64, 0xC6C, 0xC74, 0xC84, 0xC94, 0xCA4
truelight@0: };
truelight@0: 
truelight@0: static const uint16 _roadveh_full_adder[63] = {
tron@3138: 	 0,  88,   0,   0,   0,   0,  48,  48,
tron@3138: 	48,  48,   0,   0,  64,  64,   0,  16,
tron@3138: 	16,   0,  88,   0,   0,   0,   0,  48,
tron@3138: 	48,  48,  48,   0,   0,  64,  64,   0,
tron@3138: 	16,  16,   0,  88,   0,   0,   0,   0,
tron@3138: 	48,  48,  48,  48,   0,   0,  64,  64,
tron@3138: 	 0,  16,  16,   0,   8,   8,   8,   8,
tron@3138: 	 0,   0,   0,   8,   8,   8,   8
truelight@0: };
truelight@0: 
rubidium@6325: /** 'Convert' the DiagDirection where a road vehicle enters to the trackdirs it can drive onto */
rubidium@6325: static const TrackdirBits _road_enter_dir_to_reachable_trackdirs[DIAGDIR_END] = {
rubidium@6325: 	TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_X_NE,    // Enter from north east
rubidium@6325: 	TRACKDIR_BIT_LEFT_S  | TRACKDIR_BIT_UPPER_E | TRACKDIR_BIT_Y_SE,    // Enter from south east
rubidium@6325: 	TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_X_SW    | TRACKDIR_BIT_RIGHT_S, // Enter from south west
rubidium@6325: 	TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_Y_NW     // Enter from north west
truelight@0: };
truelight@0: 
rubidium@6325: static const Trackdir _road_reverse_table[DIAGDIR_END] = {
rubidium@6325: 	TRACKDIR_RVREV_NE, TRACKDIR_RVREV_SE, TRACKDIR_RVREV_SW, TRACKDIR_RVREV_NW
truelight@0: };
truelight@0: 
rubidium@6325: /** 'Convert' the DiagDirection where a road vehicle should exit to
rubidium@6325:  * the trackdirs it can use to drive to the exit direction*/
rubidium@6325: static const TrackdirBits _road_exit_dir_to_incoming_trackdirs[DIAGDIR_END] = {
rubidium@6325: 	TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_X_SW    | TRACKDIR_BIT_LEFT_S,
rubidium@6325: 	TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_UPPER_W | TRACKDIR_BIT_Y_NW,
rubidium@6325: 	TRACKDIR_BIT_RIGHT_N | TRACKDIR_BIT_UPPER_E | TRACKDIR_BIT_X_NE,
rubidium@6325: 	TRACKDIR_BIT_RIGHT_S | TRACKDIR_BIT_LOWER_E | TRACKDIR_BIT_Y_SE
truelight@0: };
truelight@0: 
rubidium@6326: /** Converts the exit direction of a depot to trackdir the vehicle is going to drive to */
rubidium@6326: static const Trackdir _roadveh_depot_exit_trackdir[DIAGDIR_END] = {
rubidium@6326: 	TRACKDIR_X_NE, TRACKDIR_Y_SE, TRACKDIR_X_SW, TRACKDIR_Y_NW
rubidium@6326: };
rubidium@6326: 
rubidium@7630: int RoadVehicle::GetImage(Direction direction) const
truelight@0: {
rubidium@7630: 	int img = this->spritenum;
truelight@0: 	int image;
truelight@0: 
truelight@0: 	if (is_custom_sprite(img)) {
rubidium@7630: 		image = GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(img)));
tron@2989: 		if (image != 0) return image;
peter1138@8722: 		img = _orig_road_vehicle_info[this->engine_type - ROAD_ENGINES_INDEX].image_index;
truelight@0: 	}
truelight@193: 
truelight@0: 	image = direction + _roadveh_images[img];
rubidium@7630: 	if (this->cargo.Count() >= this->cargo_cap / 2U) image += _roadveh_full_adder[img];
truelight@0: 	return image;
truelight@0: }
truelight@0: 
peter1138@5919: void DrawRoadVehEngine(int x, int y, EngineID engine, SpriteID pal)
truelight@0: {
tron@538: 	int spritenum = RoadVehInfo(engine)->image_index;
celestar@378: 
celestar@378: 	if (is_custom_sprite(spritenum)) {
tron@3186: 		int sprite = GetCustomVehicleIcon(engine, DIR_W);
celestar@378: 
tron@3017: 		if (sprite != 0) {
peter1138@5919: 			DrawSprite(sprite, pal, x, y);
celestar@378: 			return;
celestar@378: 		}
peter1138@8722: 		spritenum = _orig_road_vehicle_info[engine - ROAD_ENGINES_INDEX].image_index;
celestar@378: 	}
peter1138@5919: 	DrawSprite(6 + _roadveh_images[spritenum], pal, x, y);
truelight@0: }
truelight@0: 
rubidium@7439: static CommandCost EstimateRoadVehCost(EngineID engine_type)
truelight@0: {
rubidium@8726: 	return CommandCost(EXPENSES_NEW_VEHICLES, ((_price.roadveh_base >> 3) * GetEngineProperty(engine_type, 0x11, RoadVehInfo(engine_type)->base_cost)) >> 5);
truelight@0: }
truelight@0: 
maedhros@7353: byte GetRoadVehLength(const Vehicle *v)
maedhros@7353: {
maedhros@7353: 	byte length = 8;
maedhros@7353: 
rubidium@7711: 	uint16 veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, v->engine_type, v);
maedhros@7353: 	if (veh_len != CALLBACK_FAILED) {
skidd13@8418: 		length -= Clamp(veh_len, 0, 7);
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	return length;
maedhros@7353: }
maedhros@7353: 
maedhros@7353: void RoadVehUpdateCache(Vehicle *v)
maedhros@7353: {
maedhros@7353: 	assert(v->type == VEH_ROAD);
maedhros@7353: 	assert(IsRoadVehFront(v));
maedhros@7353: 
rubidium@7988: 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
rubidium@7993: 		/* Check the v->first cache. */
rubidium@7993: 		assert(u->First() == v);
maedhros@7353: 
maedhros@7353: 		/* Update the 'first engine' */
maedhros@7353: 		u->u.road.first_engine = (v == u) ? INVALID_ENGINE : v->engine_type;
maedhros@7353: 
maedhros@7353: 		/* Update the length of the vehicle. */
maedhros@7353: 		u->u.road.cached_veh_length = GetRoadVehLength(u);
maedhros@7353: 	}
maedhros@7353: }
maedhros@7353: 
Darkvater@1793: /** Build a road vehicle.
tron@3491:  * @param tile tile of depot where road vehicle is built
belugas@6979:  * @param flags operation to perform
Darkvater@1793:  * @param p1 bus/truck type being built (engine)
bjarni@3816:  * @param p2 bit 0 when set, the unitnumber will be 0, otherwise it will be a free number
Darkvater@1793:  */
rubidium@7439: CommandCost CmdBuildRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
rubidium@7439: 	CommandCost cost;
truelight@0: 	Vehicle *v;
truelight@1282: 	UnitID unit_num;
truelight@0: 	Engine *e;
truelight@193: 
maedhros@6903: 	if (!IsEngineBuildable(p1, VEH_ROAD, _current_player)) return_cmd_error(STR_ROAD_VEHICLE_NOT_AVAILABLE);
bjarni@1196: 
truelight@0: 	cost = EstimateRoadVehCost(p1);
Darkvater@1793: 	if (flags & DC_QUERY_COST) return cost;
truelight@0: 
pasky@1442: 	/* The ai_new queries the vehicle cost before building the route,
pasky@1442: 	 * so we must check against cheaters no sooner than now. --pasky */
pasky@1442: 	if (!IsTileDepotType(tile, TRANSPORT_ROAD)) return CMD_ERROR;
tron@1901: 	if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
pasky@1442: 
frosch@9059: 	if (HasTileRoadType(tile, ROADTYPE_TRAM) != HasBit(EngInfo(p1)->misc_flags, EF_ROAD_TRAM)) return_cmd_error(STR_DEPOT_WRONG_DEPOT_TYPE);
bjarni@7205: 
rubidium@8091: 	uint num_vehicles = 1 + CountArticulatedParts(p1, false);
maedhros@7353: 
rubidium@8091: 	/* Allow for the front and the articulated parts, plus one to "terminate" the list. */
rubidium@8091: 	Vehicle **vl = (Vehicle**)alloca(sizeof(*vl) * (num_vehicles + 1));
rubidium@8091: 	memset(vl, 0, sizeof(*vl) * (num_vehicles + 1));
maedhros@7353: 
rubidium@7894: 	if (!Vehicle::AllocateList(vl, num_vehicles)) {
maedhros@7353: 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	v = vl[0];
truelight@0: 
truelight@0: 	/* find the first free roadveh id */
skidd13@8424: 	unit_num = HasBit(p2, 0) ? 0 : GetFreeUnitNumber(VEH_ROAD);
truelight@0: 	if (unit_num > _patches.max_roadveh)
truelight@0: 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
tron@3491: 		int x;
tron@3491: 		int y;
tron@3491: 
tron@538: 		const RoadVehicleInfo *rvi = RoadVehInfo(p1);
tron@538: 
rubidium@8278: 		v = new (v) RoadVehicle();
truelight@0: 		v->unitnumber = unit_num;
maedhros@7353: 		v->direction = DiagDirToDir(GetRoadDepotDirection(tile));
truelight@0: 		v->owner = _current_player;
truelight@0: 
truelight@0: 		v->tile = tile;
tron@3645: 		x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;
tron@3645: 		y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
truelight@0: 		v->x_pos = x;
truelight@0: 		v->y_pos = y;
rubidium@6987: 		v->z_pos = GetSlopeZ(x, y);
truelight@0: 
smatz@9052: 		v->running_ticks = 0;
smatz@9052: 
rubidium@6326: 		v->u.road.state = RVSB_IN_DEPOT;
rubidium@6987: 		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
truelight@0: 
tron@538: 		v->spritenum = rvi->image_index;
tron@538: 		v->cargo_type = rvi->cargo_type;
peter1138@3870: 		v->cargo_subtype = 0;
tron@538: 		v->cargo_cap = rvi->capacity;
truelight@0: //		v->cargo_count = 0;
rubidium@7446: 		v->value = cost.GetCost();
truelight@0: //		v->day_counter = 0;
truelight@0: //		v->next_order_param = v->next_order = 0;
truelight@0: //		v->load_unload_time_rem = 0;
truelight@0: //		v->progress = 0;
truelight@0: 
truelight@0: //	v->u.road.unk2 = 0;
truelight@0: //	v->u.road.overtaking = 0;
truelight@0: 
truelight@1266: 		v->last_station_visited = INVALID_STATION;
tron@538: 		v->max_speed = rvi->max_speed;
peter1138@8703: 		v->engine_type = (EngineID)p1;
truelight@0: 
tron@1926: 		e = GetEngine(p1);
truelight@0: 		v->reliability = e->reliability;
truelight@0: 		v->reliability_spd_dec = e->reliability_spd_dec;
truelight@0: 		v->max_age = e->lifelength * 366;
bjarni@2564: 		_new_vehicle_id = v->index;
truelight@193: 
peter1138@8754: 		v->name = NULL;
truelight@0: 
truelight@0: 		v->service_interval = _patches.servint_roadveh;
truelight@0: 
truelight@0: 		v->date_of_last_service = _date;
rubidium@4329: 		v->build_year = _cur_year;
truelight@0: 
truelight@0: 		v->cur_image = 0xC15;
peter1138@2804: 		v->random_bits = VehicleRandomBits();
maedhros@7353: 		SetRoadVehFront(v);
maedhros@7353: 
skidd13@8424: 		v->u.road.roadtype = HasBit(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
maedhros@7353: 		v->u.road.compatible_roadtypes = RoadTypeToRoadTypes(v->u.road.roadtype);
maedhros@7353: 		v->u.road.cached_veh_length = GetRoadVehLength(v);
truelight@0: 
maedhros@6502: 		v->vehicle_flags = 0;
skidd13@8427: 		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
maedhros@6502: 
peter1138@7104: 		v->cargo_cap = GetVehicleProperty(v, 0x0F, rvi->capacity);
peter1138@7104: 
maedhros@7353: 		AddArticulatedParts(vl, VEH_ROAD);
maedhros@7353: 
truelight@0: 		VehiclePositionChanged(v);
truelight@0: 
bjarni@4739: 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
tron@588: 		RebuildVehicleLists();
truelight@0: 		InvalidateWindow(WC_COMPANY, v->owner);
bjarni@2618: 		if (IsLocalPlayer())
bjarni@7921: 			InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Road window
bjarni@6195: 
bjarni@6195: 		GetPlayer(_current_player)->num_engines[p1]++;
truelight@0: 	}
truelight@0: 
rubidium@8726: 	return cost;
truelight@0: }
truelight@0: 
Darkvater@1793: /** Start/Stop a road vehicle.
tron@3491:  * @param tile unused
belugas@6979:  * @param flags operation to perform
Darkvater@1793:  * @param p1 road vehicle ID to start/stop
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
rubidium@7439: CommandCost CmdStartStopRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@0: 	Vehicle *v;
peter1138@4244: 	uint16 callback;
truelight@0: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
bjarni@1237: 
truelight@919: 	v = GetVehicle(p1);
truelight@0: 
rubidium@6585: 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
peter1138@4244: 	/* Check if this road veh can be started/stopped. The callback will fail or
peter1138@4244: 	 * return 0xFF if it can. */
peter1138@4244: 	callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);
peter1138@4244: 	if (callback != CALLBACK_FAILED && callback != 0xFF) {
peter1138@4244: 		StringID error = GetGRFStringID(GetEngineGRFID(v->engine_type), 0xD000 + callback);
peter1138@4244: 		return_cmd_error(error);
peter1138@4244: 	}
peter1138@4244: 
truelight@0: 	if (flags & DC_EXEC) {
rubidium@7986: 		if (v->IsStoppedInDepot()) {
tron@3139: 			DeleteVehicleNews(p1, STR_9016_ROAD_VEHICLE_IS_WAITING);
tron@3139: 		}
tron@3139: 
truelight@0: 		v->vehstatus ^= VS_STOPPED;
rubidium@7188: 		v->cur_speed = 0;
smatz@8846: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
truelight@0: 	}
truelight@0: 
rubidium@7446: 	return CommandCost();
truelight@0: }
truelight@0: 
celestar@3123: void ClearSlot(Vehicle *v)
Darkvater@1664: {
celestar@3123: 	RoadStop *rs = v->u.road.slot;
celestar@3123: 	if (v->u.road.slot == NULL) return;
celestar@3123: 
Darkvater@1664: 	v->u.road.slot = NULL;
Darkvater@1664: 	v->u.road.slot_age = 0;
celestar@3123: 
celestar@3431: 	assert(rs->num_vehicles != 0);
celestar@3431: 	rs->num_vehicles--;
celestar@3431: 
Darkvater@5568: 	DEBUG(ms, 3, "Clearing slot at 0x%X", rs->xy);
Darkvater@1664: }
Darkvater@1664: 
maedhros@7353: static bool CheckRoadVehInDepotStopped(const Vehicle *v)
maedhros@7353: {
maedhros@7353: 	TileIndex tile = v->tile;
maedhros@7353: 
maedhros@7946: 	if (!IsTileDepotType(tile, TRANSPORT_ROAD)) return false;
maedhros@7946: 	if (IsRoadVehFront(v) && !(v->vehstatus & VS_STOPPED)) return false;
maedhros@7353: 
rubidium@7988: 	for (; v != NULL; v = v->Next()) {
maedhros@7353: 		if (v->u.road.state != RVSB_IN_DEPOT || v->tile != tile) return false;
maedhros@7353: 	}
maedhros@7353: 	return true;
maedhros@7353: }
maedhros@7353: 
Darkvater@1793: /** Sell a road vehicle.
tron@3491:  * @param tile unused
belugas@6979:  * @param flags operation to perform
Darkvater@1793:  * @param p1 vehicle ID to be sold
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
rubidium@7439: CommandCost CmdSellRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
truelight@193: 
truelight@919: 	v = GetVehicle(p1);
truelight@0: 
rubidium@6585: 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
rubidium@8191: 	if (HASBITS(v->vehstatus, VS_CRASHED)) return_cmd_error(STR_CAN_T_SELL_DESTROYED_VEHICLE);
rubidium@8191: 
maedhros@7353: 	if (!CheckRoadVehInDepotStopped(v)) {
truelight@0: 		return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
tron@3033: 	}
truelight@193: 
rubidium@8726: 	CommandCost ret(EXPENSES_NEW_VEHICLES, -v->value);
rubidium@8264: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@0: 		// Invalidate depot
truelight@0: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
tron@588: 		RebuildVehicleLists();
truelight@0: 		InvalidateWindow(WC_COMPANY, v->owner);
truelight@0: 		DeleteWindowById(WC_VEHICLE_VIEW, v->index);
bjarni@5256: 		DeleteDepotHighlightOfVehicle(v);
rubidium@7894: 		delete v;
truelight@0: 	}
truelight@193: 
rubidium@8264: 	return ret;
truelight@0: }
truelight@0: 
rubidium@6574: struct RoadFindDepotData {
truelight@0: 	uint best_length;
tron@1977: 	TileIndex tile;
rubidium@5838: 	OwnerByte owner;
rubidium@6574: };
truelight@0: 
tron@3186: static const DiagDirection _road_pf_directions[] = {
rubidium@5838: 	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, INVALID_DIAGDIR, INVALID_DIAGDIR,
rubidium@5838: 	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, INVALID_DIAGDIR, INVALID_DIAGDIR
truelight@0: };
truelight@0: 
frosch@9107: static bool EnumRoadSignalFindDepot(TileIndex tile, void* data, Trackdir trackdir, uint length)
truelight@0: {
rubidium@5838: 	RoadFindDepotData* rfdd = (RoadFindDepotData*)data;
tron@3137: 
rubidium@5838: 	tile += TileOffsByDiagDir(_road_pf_directions[trackdir]);
truelight@0: 
frosch@9059: 	if (IsRoadDepotTile(tile) &&
tron@3138: 			IsTileOwner(tile, rfdd->owner) &&
tron@3138: 			length < rfdd->best_length) {
tron@3138: 		rfdd->best_length = length;
tron@3138: 		rfdd->tile = tile;
truelight@0: 	}
truelight@0: 	return false;
truelight@0: }
truelight@0: 
tron@3033: static const Depot* FindClosestRoadDepot(const Vehicle* v)
truelight@0: {
smatz@9050: 	switch (_patches.pathfinder_for_roadvehs) {
smatz@9050: 		case VPF_YAPF: /* YAPF */
smatz@9050: 			return YapfFindNearestRoadDepot(v);
matthijs@1745: 
smatz@9050: 		case VPF_NPF: { /* NPF */
smatz@9050: 			/* See where we are now */
smatz@9050: 			Trackdir trackdir = GetVehicleTrackdir(v);
tron@3153: 
smatz@9050: 			NPFFoundTargetData ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, false, v->tile, ReverseTrackdir(trackdir), false, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES, 0);
truelight@0: 
smatz@9050: 			if (ftd.best_bird_dist == 0) return GetDepotByTile(ftd.node.tile); /* Target found */
smatz@9050: 		} break;
truelight@0: 
smatz@9050: 		default:
smatz@9050: 		case VPF_OPF: { /* OPF */
smatz@9050: 			RoadFindDepotData rfdd;
truelight@0: 
smatz@9050: 			rfdd.owner = v->owner;
smatz@9050: 			rfdd.best_length = UINT_MAX;
smatz@9050: 
smatz@9050: 			/* search in all directions */
smatz@9050: 			for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
frosch@9296: 				FollowTrack(v->tile, PATHFIND_FLAGS_NONE, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, d, EnumRoadSignalFindDepot, NULL, &rfdd);
smatz@9050: 			}
smatz@9050: 
smatz@9050: 			if (rfdd.best_length != UINT_MAX) return GetDepotByTile(rfdd.tile);
smatz@9050: 		} break;
matthijs@1247: 	}
smatz@9050: 
smatz@9050: 	return NULL; /* Target not found */
truelight@0: }
truelight@0: 
Darkvater@1793: /** Send a road vehicle to the depot.
tron@3491:  * @param tile unused
belugas@6979:  * @param flags operation to perform
Darkvater@1793:  * @param p1 vehicle ID to send to the depot
bjarni@4451:  * @param p2 various bitmasked elements
bjarni@4506:  * - p2 bit 0-3 - DEPOT_ flags (see vehicle.h)
bjarni@4506:  * - p2 bit 8-10 - VLW flag (for mass goto depot)
Darkvater@1793:  */
rubidium@7439: CommandCost CmdSendRoadVehToDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
bjarni@1237: 	Vehicle *v;
Darkvater@1793: 	const Depot *dep;
truelight@0: 
bjarni@4506: 	if (p2 & DEPOT_MASS_SEND) {
bjarni@4506: 		/* Mass goto depot requested */
Darkvater@4546: 		if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;
rubidium@6585: 		return SendAllVehiclesToDepot(VEH_ROAD, flags, p2 & DEPOT_SERVICE, _current_player, (p2 & VLW_MASK), p1);
bjarni@4463: 	}
bjarni@4463: 
bjarni@4506: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
bjarni@1237: 
bjarni@1237: 	v = GetVehicle(p1);
bjarni@1237: 
rubidium@6585: 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
bjarni@4506: 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
matthijs@1757: 
rubidium@7986: 	if (v->IsInDepot()) return CMD_ERROR;
bjarni@4526: 
Darkvater@1793: 	/* If the current orders are already goto-depot */
rubidium@9332: 	if (v->current_order.IsType(OT_GOTO_DEPOT)) {
rubidium@9339: 		bool halt_in_depot = HasBit(v->current_order.GetDepotActionType(), OF_HALT_IN_DEPOT);
rubidium@9339: 		if (!!(p2 & DEPOT_SERVICE) == halt_in_depot) {
bjarni@4510: 			/* We called with a different DEPOT_SERVICE setting.
rubidium@4549: 			 * Now we change the setting to apply the new one and let the vehicle head for the same depot.
rubidium@4549: 			 * Note: the if is (true for requesting service == true for ordered to stop in depot) */
bjarni@4510: 			if (flags & DC_EXEC) {
rubidium@9339: 				v->current_order.SetDepotOrderType(OFB_MANUAL_ORDER);
rubidium@9339: 				v->current_order.SetDepotActionType(halt_in_depot ? OFB_NORMAL_ACTION : OFB_HALT_IN_DEPOT);
smatz@8846: 				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
bjarni@4510: 			}
rubidium@7446: 			return CommandCost();
bjarni@4510: 		}
bjarni@4510: 
bjarni@4506: 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
truelight@0: 		if (flags & DC_EXEC) {
Darkvater@1793: 			/* If the orders to 'goto depot' are in the orders list (forced servicing),
Darkvater@1793: 			 * then skip to the next order; effectively cancelling this forced service */
rubidium@9339: 			if (v->current_order.GetDepotOrderType() & OFB_PART_OF_ORDERS) v->cur_order_index++;
celestar@1530: 
rubidium@9332: 			v->current_order.MakeDummy();
smatz@8846: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 		}
rubidium@7446: 		return CommandCost();
truelight@0: 	}
truelight@0: 
Darkvater@1793: 	dep = FindClosestRoadDepot(v);
bjarni@4506: 	if (dep == NULL) return_cmd_error(STR_9019_UNABLE_TO_FIND_LOCAL_DEPOT);
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
rubidium@9332: 		if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
maedhros@6998: 
celestar@3236: 		ClearSlot(v);
rubidium@9332: 		v->current_order.MakeGoToDepot(dep->index, false);
rubidium@9339: 		if (!(p2 & DEPOT_SERVICE)) v->current_order.SetDepotActionType(OFB_HALT_IN_DEPOT);
Darkvater@1793: 		v->dest_tile = dep->xy;
smatz@8846: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 	}
truelight@193: 
rubidium@7446: 	return CommandCost();
truelight@0: }
truelight@0: 
Darkvater@1793: /** Turn a roadvehicle around.
tron@3491:  * @param tile unused
belugas@6979:  * @param flags operation to perform
Darkvater@1793:  * @param p1 vehicle ID to turn
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
rubidium@7439: CommandCost CmdTurnRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
bjarni@1237: 
truelight@919: 	v = GetVehicle(p1);
truelight@0: 
rubidium@6585: 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
celestar@5573: 	if (v->vehstatus & VS_STOPPED ||
rubidium@7972: 			v->vehstatus & VS_CRASHED ||
truelight@0: 			v->breakdown_ctr != 0 ||
truelight@0: 			v->u.road.overtaking != 0 ||
rubidium@6326: 			v->u.road.state == RVSB_WORMHOLE ||
rubidium@7986: 			v->IsInDepot() ||
truelight@0: 			v->cur_speed < 5) {
truelight@0: 		return CMD_ERROR;
truelight@0: 	}
truelight@193: 
frosch@9059: 	if (IsNormalRoadTile(v->tile) && GetDisallowedRoadDirections(v->tile) != DRD_NONE) return CMD_ERROR;
rubidium@7260: 
smatz@8584: 	if (IsTileType(v->tile, MP_TUNNELBRIDGE) && DirToDiagDir(v->direction) == GetTunnelBridgeDirection(v->tile)) return CMD_ERROR;
celestar@5573: 
tron@3138: 	if (flags & DC_EXEC) v->u.road.reverse_ctr = 180;
truelight@0: 
rubidium@7446: 	return CommandCost();
truelight@0: }
truelight@0: 
truelight@0: 
rubidium@7049: void RoadVehicle::MarkDirty()
truelight@0: {
rubidium@7988: 	for (Vehicle *v = this; v != NULL; v = v->Next()) {
maedhros@7915: 		v->cur_image = v->GetImage(v->direction);
smatz@8813: 		MarkSingleVehicleDirty(v);
maedhros@7915: 	}
truelight@0: }
truelight@0: 
rubidium@7054: void RoadVehicle::UpdateDeltaXY(Direction direction)
truelight@0: {
rubidium@7054: #define MKIT(a, b, c, d) ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | ((d & 0xFF) << 0)
truelight@0: 	static const uint32 _delta_xy_table[8] = {
truelight@0: 		MKIT(3, 3, -1, -1),
truelight@0: 		MKIT(3, 7, -1, -3),
truelight@0: 		MKIT(3, 3, -1, -1),
truelight@0: 		MKIT(7, 3, -3, -1),
truelight@0: 		MKIT(3, 3, -1, -1),
truelight@0: 		MKIT(3, 7, -1, -3),
truelight@0: 		MKIT(3, 3, -1, -1),
truelight@0: 		MKIT(7, 3, -3, -1),
truelight@0: 	};
truelight@0: #undef MKIT
rubidium@7054: 
rubidium@7054: 	uint32 x = _delta_xy_table[direction];
rubidium@7054: 	this->x_offs        = GB(x,  0, 8);
rubidium@7054: 	this->y_offs        = GB(x,  8, 8);
frosch@9289: 	this->x_extent      = GB(x, 16, 8);
frosch@9289: 	this->y_extent      = GB(x, 24, 8);
frosch@9289: 	this->z_extent      = 6;
truelight@0: }
truelight@0: 
truelight@0: static void ClearCrashedStation(Vehicle *v)
truelight@0: {
peter1138@2671: 	RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
truelight@0: 
rubidium@6316: 	/* Mark the station entrance as not busy */
rubidium@6316: 	rs->SetEntranceBusy(false);
truelight@193: 
rubidium@6316: 	/* Free the parking bay */
skidd13@8424: 	rs->FreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY));
truelight@0: }
truelight@0: 
maedhros@7353: static void DeleteLastRoadVeh(Vehicle *v)
truelight@0: {
maedhros@7353: 	Vehicle *u = v;
rubidium@7988: 	for (; v->Next() != NULL; v = v->Next()) u = v;
rubidium@7988: 	u->SetNext(NULL);
maedhros@7353: 
truelight@0: 	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
truelight@193: 
tron@588: 	RebuildVehicleLists();
truelight@0: 	InvalidateWindow(WC_COMPANY, v->owner);
truelight@0: 
tron@3017: 	if (IsTileType(v->tile, MP_STATION)) ClearCrashedStation(v);
truelight@193: 
smatz@8813: 	MarkSingleVehicleDirty(v);
truelight@193: 
rubidium@7894: 	delete v;
truelight@0: }
truelight@0: 
truelight@0: static byte SetRoadVehPosition(Vehicle *v, int x, int y)
truelight@0: {
truelight@0: 	byte new_z, old_z;
truelight@0: 
belugas@6889: 	/* need this hint so it returns the right z coordinate on bridges. */
tron@3017: 	v->x_pos = x;
tron@3017: 	v->y_pos = y;
tron@3017: 	new_z = GetSlopeZ(x, y);
truelight@0: 
truelight@0: 	old_z = v->z_pos;
truelight@0: 	v->z_pos = new_z;
truelight@193: 
truelight@0: 	VehiclePositionChanged(v);
truelight@0: 	EndVehicleMove(v);
truelight@0: 	return old_z;
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehSetRandomDirection(Vehicle *v)
truelight@0: {
tron@3160: 	static const DirDiff delta[] = {
tron@3160: 		DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT
tron@3160: 	};
tron@3160: 
maedhros@7353: 	do {
maedhros@7353: 		uint32 r = Random();
tron@3160: 
maedhros@7353: 		v->direction = ChangeDir(v->direction, delta[r & 3]);
maedhros@7353: 		BeginVehicleMove(v);
maedhros@7353: 		v->UpdateDeltaXY(v->direction);
rubidium@7630: 		v->cur_image = v->GetImage(v->direction);
maedhros@7353: 		SetRoadVehPosition(v, v->x_pos, v->y_pos);
rubidium@7988: 	} while ((v = v->Next()) != NULL);
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehIsCrashed(Vehicle *v)
truelight@0: {
truelight@0: 	v->u.road.crashed_ctr++;
truelight@0: 	if (v->u.road.crashed_ctr == 2) {
tron@1359: 		CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
truelight@0: 	} else if (v->u.road.crashed_ctr <= 45) {
tron@3017: 		if ((v->tick_counter & 7) == 0) RoadVehSetRandomDirection(v);
maedhros@7353: 	} else if (v->u.road.crashed_ctr >= 2220 && !(v->tick_counter & 0x1F)) {
maedhros@7353: 		DeleteLastRoadVeh(v);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@3138: static void* EnumCheckRoadVehCrashTrain(Vehicle* v, void* data)
truelight@0: {
rubidium@5838: 	const Vehicle* u = (Vehicle*)data;
tron@3138: 
tron@2989: 	return
rubidium@6585: 		v->type == VEH_TRAIN &&
skidd13@8419: 		abs(v->z_pos - u->z_pos) <= 6 &&
skidd13@8419: 		abs(v->x_pos - u->x_pos) <= 4 &&
skidd13@8419: 		abs(v->y_pos - u->y_pos) <= 4 ?
tron@2989: 			v : NULL;
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehCrash(Vehicle *v)
truelight@0: {
maedhros@7353: 	uint16 pass = 1;
truelight@0: 
truelight@0: 	v->u.road.crashed_ctr++;
maedhros@7353: 
rubidium@7988: 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
rubidium@7506: 		if (IsCargoInClass(u->cargo_type, CC_PASSENGERS)) pass += u->cargo.Count();
maedhros@7353: 
maedhros@7353: 		u->vehstatus |= VS_CRASHED;
maedhros@7353: 
smatz@8813: 		MarkSingleVehicleDirty(u);
maedhros@7353: 	}
maedhros@7353: 
celestar@3236: 	ClearSlot(v);
truelight@0: 
smatz@8846: 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 
tron@534: 	SetDParam(0, pass);
tron@2260: 	AddNewsItem(
tron@2260: 		(pass == 1) ?
tron@2260: 			STR_9031_ROAD_VEHICLE_CRASH_DRIVER : STR_9032_ROAD_VEHICLE_CRASH_DIE,
rubidium@9259: 		NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, DNC_NONE,
truelight@0: 		v->index,
tron@3033: 		0
tron@3033: 	);
truelight@0: 
truelight@0: 	ModifyStationRatingAround(v->tile, v->owner, -160, 22);
tron@541: 	SndPlayVehicleFx(SND_12_EXPLOSION, v);
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehCheckTrainCrash(Vehicle *v)
truelight@0: {
rubidium@7988: 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
maedhros@7353: 		if (u->u.road.state == RVSB_WORMHOLE) continue;
truelight@0: 
maedhros@7353: 		TileIndex tile = u->tile;
truelight@0: 
maedhros@7353: 		if (!IsLevelCrossingTile(tile)) continue;
truelight@0: 
peter1138@7367: 		if (VehicleFromPosXY(v->x_pos, v->y_pos, u, EnumCheckRoadVehCrashTrain) != NULL) {
maedhros@7353: 			RoadVehCrash(v);
maedhros@7353: 			return;
maedhros@7353: 		}
maedhros@7353: 	}
truelight@0: }
truelight@0: 
truelight@0: static void HandleBrokenRoadVeh(Vehicle *v)
truelight@0: {
truelight@0: 	if (v->breakdown_ctr != 1) {
truelight@0: 		v->breakdown_ctr = 1;
truelight@0: 		v->cur_speed = 0;
truelight@0: 
truelight@0: 		if (v->breakdowns_since_last_service != 255)
truelight@0: 			v->breakdowns_since_last_service++;
truelight@193: 
truelight@0: 		InvalidateWindow(WC_VEHICLE_VIEW, v->index);
truelight@0: 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
truelight@193: 
peter1138@4656: 		if (!PlayVehicleSound(v, VSE_BREAKDOWN)) {
belugas@6683: 			SndPlayVehicleFx((_opt.landscape != LT_TOYLAND) ?
peter1138@4656: 				SND_0F_VEHICLE_BREAKDOWN : SND_35_COMEDY_BREAKDOWN, v);
peter1138@4656: 		}
truelight@0: 
truelight@0: 		if (!(v->vehstatus & VS_HIDDEN)) {
truelight@0: 			Vehicle *u = CreateEffectVehicleRel(v, 4, 4, 5, EV_BREAKDOWN_SMOKE);
rubidium@7830: 			if (u != NULL) u->u.special.animation_state = v->breakdown_delay * 2;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
tron@2989: 	if ((v->tick_counter & 1) == 0) {
tron@2989: 		if (--v->breakdown_delay == 0) {
truelight@0: 			v->breakdown_ctr = 0;
truelight@0: 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
truelight@0: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
rubidium@9323: TileIndex RoadVehicle::GetOrderStationLocation(StationID station)
truelight@0: {
rubidium@9326: 	if (station == this->last_station_visited) this->last_station_visited = INVALID_STATION;
rubidium@9326: 
rubidium@9323: 	TileIndex dest = INVALID_TILE;
rubidium@9323: 	const RoadStop *rs = GetStation(station)->GetPrimaryRoadStop(this);
rubidium@9323: 	if (rs != NULL) {
rubidium@9323: 		uint mindist = MAX_UVALUE(uint);
truelight@0: 
rubidium@9323: 		for (; rs != NULL; rs = rs->GetNextRoadStop(this)) {
rubidium@9323: 			uint dist = DistanceManhattan(this->tile, rs->xy);
truelight@0: 
rubidium@9323: 			if (dist < mindist) {
rubidium@9323: 				mindist = dist;
rubidium@9323: 				dest = rs->xy;
rubidium@9323: 			}
rubidium@9323: 		}
tron@2951: 	}
truelight@0: 
rubidium@9323: 	if (dest != INVALID_TILE) {
rubidium@9323: 		return dest;
rubidium@9323: 	} else {
rubidium@9323: 		/* There is no stop left at the station, so don't even TRY to go there */
rubidium@9323: 		this->cur_order_index++;
rubidium@9323: 		return 0;
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@3017: static void StartRoadVehSound(const Vehicle* v)
truelight@0: {
peter1138@4656: 	if (!PlayVehicleSound(v, VSE_START)) {
peter1138@4656: 		SoundFx s = RoadVehInfo(v->engine_type)->sfx;
peter1138@4656: 		if (s == SND_19_BUS_START_PULL_AWAY && (v->tick_counter & 3) == 0)
peter1138@4656: 			s = SND_1A_BUS_START_PULL_AWAY_WITH_HORN;
peter1138@4656: 		SndPlayVehicleFx(s, v);
peter1138@4656: 	}
truelight@0: }
truelight@0: 
rubidium@6574: struct RoadVehFindData {
tron@3017: 	int x;
tron@3017: 	int y;
tron@3017: 	const Vehicle* veh;
tron@3157: 	Direction dir;
rubidium@6574: };
truelight@0: 
tron@3138: static void* EnumCheckRoadVehClose(Vehicle *v, void* data)
truelight@0: {
tron@3138: 	static const int8 dist_x[] = { -4, -8, -4, -1, 4, 8, 4, 1 };
tron@3138: 	static const int8 dist_y[] = { -4, -1, 4, 8, 4, 1, -4, -8 };
tron@3138: 
rubidium@5838: 	const RoadVehFindData* rvf = (RoadVehFindData*)data;
truelight@193: 
dominik@63: 	short x_diff = v->x_pos - rvf->x;
dominik@63: 	short y_diff = v->y_pos - rvf->y;
truelight@0: 
tron@3138: 	return
rubidium@6585: 		v->type == VEH_ROAD &&
rubidium@7986: 		!v->IsInDepot() &&
skidd13@8419: 		abs(v->z_pos - rvf->veh->z_pos) < 6 &&
tron@3138: 		v->direction == rvf->dir &&
rubidium@7993: 		rvf->veh->First() != v->First() &&
tron@3138: 		(dist_x[v->direction] >= 0 || (x_diff > dist_x[v->direction] && x_diff <= 0)) &&
tron@3138: 		(dist_x[v->direction] <= 0 || (x_diff < dist_x[v->direction] && x_diff >= 0)) &&
tron@3138: 		(dist_y[v->direction] >= 0 || (y_diff > dist_y[v->direction] && y_diff <= 0)) &&
tron@3138: 		(dist_y[v->direction] <= 0 || (y_diff < dist_y[v->direction] && y_diff >= 0)) ?
tron@3138: 			v : NULL;
truelight@0: }
truelight@0: 
tron@3157: static Vehicle* RoadVehFindCloseTo(Vehicle* v, int x, int y, Direction dir)
truelight@0: {
truelight@0: 	RoadVehFindData rvf;
truelight@0: 	Vehicle *u;
rubidium@8312: 	Vehicle *front = v->First();
truelight@0: 
rubidium@8312: 	if (front->u.road.reverse_ctr != 0) return NULL;
truelight@193: 
truelight@0: 	rvf.x = x;
truelight@0: 	rvf.y = y;
truelight@0: 	rvf.dir = dir;
truelight@0: 	rvf.veh = v;
rubidium@8312: 	if (front->u.road.state == RVSB_WORMHOLE) {
rubidium@8312: 		u = (Vehicle*)VehicleFromPos(v->tile, &rvf, EnumCheckRoadVehClose);
rubidium@8762: 		if (u == NULL) u = (Vehicle*)VehicleFromPos(GetOtherTunnelBridgeEnd(v->tile), &rvf, EnumCheckRoadVehClose);
rubidium@8312: 	} else {
rubidium@8312: 		u = (Vehicle*)VehicleFromPosXY(x, y, &rvf, EnumCheckRoadVehClose);
rubidium@8312: 	}
truelight@193: 
belugas@6889: 	/* This code protects a roadvehicle from being blocked for ever
belugas@6889: 	 * If more than 1480 / 74 days a road vehicle is blocked, it will
belugas@6889: 	 * drive just through it. The ultimate backup-code of TTD.
belugas@6889: 	 * It can be disabled. */
truelight@0: 	if (u == NULL) {
rubidium@8312: 		front->u.road.blocked_ctr = 0;
truelight@0: 		return NULL;
truelight@0: 	}
truelight@0: 
rubidium@8312: 	if (++front->u.road.blocked_ctr > 1480) return NULL;
truelight@193: 
truelight@0: 	return u;
truelight@0: }
truelight@0: 
tron@2630: static void RoadVehArrivesAt(const Vehicle* v, Station* st)
truelight@0: {
peter1138@6655: 	if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) {
truelight@0: 		/* Check if station was ever visited before */
truelight@0: 		if (!(st->had_vehicle_of_type & HVOT_BUS)) {
truelight@0: 			st->had_vehicle_of_type |= HVOT_BUS;
tron@534: 			SetDParam(0, st->index);
truelight@0: 			AddNewsItem(
maedhros@8920: 				v->u.road.roadtype == ROADTYPE_ROAD ? STR_902F_CITIZENS_CELEBRATE_FIRST : STR_CITIZENS_CELEBRATE_FIRST_PASSENGER_TRAM,
rubidium@9259: 				NM_THIN, NF_VIEWPORT | NF_VEHICLE, (v->owner == _local_player) ? NT_ARRIVAL_PLAYER : NT_ARRIVAL_OTHER, DNC_NONE,
truelight@0: 				v->index,
truelight@0: 				0);
truelight@0: 		}
truelight@0: 	} else {
truelight@0: 		/* Check if station was ever visited before */
truelight@0: 		if (!(st->had_vehicle_of_type & HVOT_TRUCK)) {
truelight@0: 			st->had_vehicle_of_type |= HVOT_TRUCK;
tron@534: 			SetDParam(0, st->index);
truelight@0: 			AddNewsItem(
maedhros@8920: 				v->u.road.roadtype == ROADTYPE_ROAD ? STR_9030_CITIZENS_CELEBRATE_FIRST : STR_CITIZENS_CELEBRATE_FIRST_CARGO_TRAM,
rubidium@9259: 				NM_THIN, NF_VIEWPORT | NF_VEHICLE, (v->owner == _local_player) ? NT_ARRIVAL_PLAYER : NT_ARRIVAL_OTHER, DNC_NONE,
truelight@0: 				v->index,
tron@3033: 				0
tron@3033: 			);
truelight@0: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static bool RoadVehAccelerate(Vehicle *v)
truelight@0: {
tron@2951: 	uint spd = v->cur_speed + 1 + (v->u.road.overtaking != 0 ? 1 : 0);
truelight@0: 	byte t;
truelight@193: 
belugas@6889: 	/* Clamp */
truelight@0: 	spd = min(spd, v->max_speed);
tron@6467: 	if (v->u.road.state == RVSB_WORMHOLE && !(v->vehstatus & VS_HIDDEN)) {
belugas@8987: 		spd = min(spd, GetBridgeSpec(GetBridgeType(v->tile))->speed * 2);
tron@6467: 	}
truelight@0: 
belugas@6889: 	/* updates statusbar only if speed have changed to save CPU time */
truelight@0: 	if (spd != v->cur_speed) {
truelight@193: 		v->cur_speed = spd;
tron@2951: 		if (_patches.vehicle_speed) {
smatz@8846: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
tron@2951: 		}
truelight@0: 	}
truelight@0: 
belugas@6889: 	/* Decrease somewhat when turning */
tron@2951: 	if (!(v->direction & 1)) spd = spd * 3 >> 2;
truelight@0: 
tron@2951: 	if (spd == 0) return false;
truelight@0: 
tron@2951: 	if ((byte)++spd == 0) return true;
truelight@0: 
truelight@0: 	v->progress = (t = v->progress) - (byte)spd;
truelight@0: 
truelight@0: 	return (t < v->progress);
truelight@0: }
truelight@0: 
tron@3157: static Direction RoadVehGetNewDirection(const Vehicle* v, int x, int y)
truelight@0: {
tron@3157: 	static const Direction _roadveh_new_dir[] = {
rubidium@5838: 		DIR_N , DIR_NW, DIR_W , INVALID_DIR,
rubidium@5838: 		DIR_NE, DIR_N , DIR_SW, INVALID_DIR,
tron@3157: 		DIR_E , DIR_SE, DIR_S
truelight@0: 	};
truelight@193: 
truelight@0: 	x = x - v->x_pos + 1;
truelight@0: 	y = y - v->y_pos + 1;
truelight@0: 
tron@3017: 	if ((uint)x > 2 || (uint)y > 2) return v->direction;
tron@3017: 	return _roadveh_new_dir[y * 4 + x];
truelight@0: }
truelight@0: 
tron@3157: static Direction RoadVehGetSlidingDirection(const Vehicle* v, int x, int y)
truelight@0: {
rubidium@5838: 	Direction new_dir = RoadVehGetNewDirection(v, x, y);
rubidium@5838: 	Direction old_dir = v->direction;
tron@3159: 	DirDiff delta;
tron@3157: 
rubidium@5838: 	if (new_dir == old_dir) return old_dir;
rubidium@5838: 	delta = (DirDifference(new_dir, old_dir) > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
rubidium@5838: 	return ChangeDir(old_dir, delta);
truelight@0: }
truelight@0: 
rubidium@6574: struct OvertakeData {
tron@3138: 	const Vehicle* u;
tron@3138: 	const Vehicle* v;
tron@1977: 	TileIndex tile;
frosch@9105: 	Trackdir trackdir;
rubidium@6574: };
truelight@0: 
frosch@9105: static void* EnumFindVehBlockingOvertake(Vehicle* v, void* data)
truelight@0: {
rubidium@5838: 	const OvertakeData* od = (OvertakeData*)data;
tron@3138: 
tron@3017: 	return
smatz@8577: 		v->type == VEH_ROAD && v->First() == v && v != od->u && v != od->v ?
tron@3017: 			v : NULL;
truelight@0: }
truelight@0: 
frosch@9105: /**
frosch@9105:  * Check if overtaking is possible on a piece of track
frosch@9105:  *
frosch@9105:  * @param od Information about the tile and the involved vehicles
frosch@9105:  * @return true if we have to abort overtaking
frosch@9105:  */
frosch@9105: static bool CheckRoadBlockedForOvertaking(OvertakeData *od)
truelight@0: {
frosch@9112: 	TrackStatus ts = GetTileTrackStatus(od->tile, TRANSPORT_ROAD, od->v->u.road.compatible_roadtypes);
frosch@9112: 	TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
frosch@9112: 	TrackdirBits red_signals = TrackStatusToRedSignals(ts); // barred level crossing
frosch@9105: 	TrackBits trackbits = TrackdirBitsToTrackBits(trackdirbits);
truelight@0: 
frosch@9105: 	/* Track does not continue along overtaking direction || track has junction || levelcrossing is barred */
frosch@9105: 	if (!HasBit(trackdirbits, od->trackdir) || (trackbits & ~TRACK_BIT_CROSS) || (red_signals != TRACKDIR_BIT_NONE)) return true;
truelight@0: 
frosch@9105: 	/* Are there more vehicles on the tile except the two vehicles involved in overtaking */
frosch@9105: 	return VehicleFromPos(od->tile, od, EnumFindVehBlockingOvertake) != NULL;
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehCheckOvertake(Vehicle *v, Vehicle *u)
truelight@0: {
truelight@0: 	OvertakeData od;
truelight@0: 
truelight@0: 	od.v = v;
truelight@0: 	od.u = u;
truelight@0: 
truelight@0: 	if (u->max_speed >= v->max_speed &&
celestar@3431: 			!(u->vehstatus & VS_STOPPED) &&
tron@2951: 			u->cur_speed != 0) {
tron@2951: 		return;
tron@2951: 	}
truelight@0: 
rubidium@7183: 	/* Trams can't overtake other trams */
rubidium@7183: 	if (v->u.road.roadtype == ROADTYPE_TRAM) return;
rubidium@7183: 
rubidium@8165: 	/* Don't overtake in stations */
rubidium@8165: 	if (IsTileType(v->tile, MP_STATION)) return;
rubidium@8165: 
maedhros@7353: 	/* For now, articulated road vehicles can't overtake anything. */
maedhros@7353: 	if (RoadVehHasArticPart(v)) return;
maedhros@7353: 
frosch@9105: 	/* Vehicles are not driving in same direction || direction is not a diagonal direction */
tron@3033: 	if (v->direction != u->direction || !(v->direction & 1)) return;
truelight@0: 
rubidium@6326: 	/* Check if vehicle is in a road stop, depot, tunnel or bridge or not on a straight road */
rubidium@6457: 	if (v->u.road.state >= RVSB_IN_ROAD_STOP || !IsStraightRoadTrackdir((Trackdir)(v->u.road.state & RVSB_TRACKDIR_MASK))) return;
truelight@0: 
frosch@9105: 	od.trackdir = DiagdirToDiagTrackdir(DirToDiagDir(v->direction));
rubidium@8165: 
frosch@9105: 	/* Are the current and the next tile suitable for overtaking?
frosch@9105: 	 *  - Does the track continue along od.trackdir
frosch@9105: 	 *  - No junctions
frosch@9105: 	 *  - No barred levelcrossing
frosch@9105: 	 *  - No other vehicles in the way
frosch@9105: 	 */
truelight@0: 	od.tile = v->tile;
frosch@9105: 	if (CheckRoadBlockedForOvertaking(&od)) return;
truelight@0: 
Darkvater@4559: 	od.tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
frosch@9105: 	if (CheckRoadBlockedForOvertaking(&od)) return;
truelight@0: 
celestar@3431: 	if (od.u->cur_speed == 0 || od.u->vehstatus& VS_STOPPED) {
truelight@0: 		v->u.road.overtaking_ctr = 0x11;
truelight@0: 		v->u.road.overtaking = 0x10;
truelight@0: 	} else {
frosch@9105: //		if (CheckRoadBlockedForOvertaking(&od)) return;
truelight@0: 		v->u.road.overtaking_ctr = 0;
truelight@0: 		v->u.road.overtaking = 0x10;
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void RoadZPosAffectSpeed(Vehicle *v, byte old_z)
truelight@0: {
tron@3017: 	if (old_z == v->z_pos) return;
truelight@0: 
truelight@0: 	if (old_z < v->z_pos) {
tron@3017: 		v->cur_speed = v->cur_speed * 232 / 256; // slow down by ~10%
truelight@0: 	} else {
truelight@0: 		uint16 spd = v->cur_speed + 2;
tron@3017: 		if (spd <= v->max_speed) v->cur_speed = spd;
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static int PickRandomBit(uint bits)
truelight@0: {
truelight@0: 	uint i;
truelight@8328: 	uint num = RandomRange(CountBits(bits));
truelight@0: 
tron@3017: 	for (i = 0; !(bits & 1) || (int)--num >= 0; bits >>= 1, i++) {}
truelight@0: 	return i;
truelight@0: }
truelight@0: 
rubidium@6574: struct FindRoadToChooseData {
truelight@0: 	TileIndex dest;
truelight@0: 	uint maxtracklen;
truelight@0: 	uint mindist;
rubidium@6574: };
truelight@0: 
frosch@9107: static bool EnumRoadTrackFindDist(TileIndex tile, void* data, Trackdir trackdir, uint length)
truelight@0: {
rubidium@5838: 	FindRoadToChooseData* frd = (FindRoadToChooseData*)data;
tron@1245: 	uint dist = DistanceManhattan(tile, frd->dest);
tron@3138: 
truelight@0: 	if (dist <= frd->mindist) {
truelight@0: 		if (dist != frd->mindist || length < frd->maxtracklen) {
truelight@0: 			frd->maxtracklen = length;
truelight@0: 		}
truelight@0: 		frd->mindist = dist;
truelight@0: 	}
truelight@0: 	return false;
truelight@0: }
truelight@0: 
frosch@9006: static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, bool ignore_start_tile, NPFFindStationOrTileData* target, TransportType type, uint sub_type, Owner owner, RailTypes railtypes)
KUDr@3900: {
KUDr@3900: 
KUDr@3900: 	void* perf = NpfBeginInterval();
frosch@9006: 	NPFFoundTargetData ret = NPFRouteToStationOrTile(tile, trackdir, ignore_start_tile, target, type, sub_type, owner, railtypes);
KUDr@3900: 	int t = NpfEndInterval(perf);
Darkvater@5568: 	DEBUG(yapf, 4, "[NPFR] %d us - %d rounds - %d open - %d closed -- ", t, 0, _aystar_stats_open_size, _aystar_stats_closed_size);
KUDr@3900: 	return ret;
KUDr@3900: }
KUDr@3900: 
rubidium@6325: /**
rubidium@6325:  * Returns direction to for a road vehicle to take or
rubidium@6325:  * INVALID_TRACKDIR if the direction is currently blocked
belugas@6979:  * @param v        the Vehicle to do the pathfinding for
rubidium@6325:  * @param tile     the where to start the pathfinding
rubidium@6325:  * @param enterdir the direction the vehicle enters the tile from
belugas@6979:  * @return the Trackdir to take
rubidium@6325:  */
rubidium@6325: static Trackdir RoadFindPathToDest(Vehicle* v, TileIndex tile, DiagDirection enterdir)
truelight@0: {
rubidium@6325: #define return_track(x) { best_track = (Trackdir)x; goto found_best_track; }
truelight@0: 
tron@1977: 	TileIndex desttile;
truelight@0: 	FindRoadToChooseData frd;
rubidium@6325: 	Trackdir best_track;
truelight@0: 
frosch@9112: 	TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_ROAD, v->u.road.compatible_roadtypes);
frosch@9112: 	TrackdirBits red_signals = TrackStatusToRedSignals(ts); // crossing
frosch@9112: 	TrackdirBits trackdirs = TrackStatusToTrackdirBits(ts);
truelight@0: 
rubidium@7866: 	if (IsTileType(tile, MP_ROAD)) {
frosch@9059: 		if (IsRoadDepot(tile) && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir || (GetRoadTypes(tile) & v->u.road.compatible_roadtypes) == 0)) {
KUDr@4445: 			/* Road depot owned by another player or with the wrong orientation */
rubidium@6325: 			trackdirs = TRACKDIR_BIT_NONE;
tron@2549: 		}
rubidium@6338: 	} else if (IsTileType(tile, MP_STATION) && IsStandardRoadStopTile(tile)) {
rubidium@6338: 		/* Standard road stop (drive-through stops are treated as normal road) */
rubidium@7965: 
rubidium@7965: 		if (!IsTileOwner(tile, v->owner) || GetRoadStopDir(tile) == enterdir || RoadVehHasArticPart(v)) {
rubidium@7965: 			/* different station owner or wrong orientation or the vehicle has articulated parts */
rubidium@6325: 			trackdirs = TRACKDIR_BIT_NONE;
KUDr@3937: 		} else {
darkvater@241: 			/* Our station */
rubidium@9281: 			RoadStopType rstype = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK;
tron@3138: 
KUDr@3937: 			if (GetRoadStopType(tile) != rstype) {
rubidium@6325: 				/* Wrong station type */
rubidium@6325: 				trackdirs = TRACKDIR_BIT_NONE;
KUDr@3937: 			} else {
rubidium@6325: 				/* Proper station type, check if there is free loading bay */
rubidium@7965: 				if (!_patches.roadveh_queue && IsStandardRoadStopTile(tile) &&
rubidium@6316: 						!GetRoadStopByTile(tile, rstype)->HasFreeBay()) {
rubidium@6325: 					/* Station is full and RV queuing is off */
rubidium@6325: 					trackdirs = TRACKDIR_BIT_NONE;
peter1138@3092: 				}
darkvater@241: 			}
darkvater@241: 		}
darkvater@241: 	}
darkvater@241: 	/* The above lookups should be moved to GetTileTrackStatus in the
darkvater@241: 	 * future, but that requires more changes to the pathfinder and other
darkvater@241: 	 * stuff, probably even more arguments to GTTS.
darkvater@241: 	 */
truelight@0: 
rubidium@6325: 	/* Remove tracks unreachable from the enter dir */
rubidium@6325: 	trackdirs &= _road_enter_dir_to_reachable_trackdirs[enterdir];
rubidium@6325: 	if (trackdirs == TRACKDIR_BIT_NONE) {
matthijs@1247: 		/* No reachable tracks, so we'll reverse */
matthijs@1247: 		return_track(_road_reverse_table[enterdir]);
truelight@0: 	}
truelight@0: 
truelight@0: 	if (v->u.road.reverse_ctr != 0) {
matthijs@1247: 		/* What happens here?? */
truelight@0: 		v->u.road.reverse_ctr = 0;
tron@1986: 		if (v->tile != tile) {
matthijs@1247: 			return_track(_road_reverse_table[enterdir]);
truelight@0: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	desttile = v->dest_tile;
truelight@0: 	if (desttile == 0) {
rubidium@6325: 		/* We've got no destination, pick a random track */
rubidium@6325: 		return_track(PickRandomBit(trackdirs));
truelight@0: 	}
truelight@0: 
rubidium@6325: 	/* Only one track to choose between? */
truelight@8331: 	if (KillFirstBit(trackdirs) == TRACKDIR_BIT_NONE) {
rubidium@6325: 		return_track(FindFirstBit2x64(trackdirs));
truelight@0: 	}
truelight@0: 
smatz@9050: 	switch (_patches.pathfinder_for_roadvehs) {
smatz@9050: 		case VPF_YAPF: { /* YAPF */
smatz@9050: 			Trackdir trackdir = YapfChooseRoadTrack(v, tile, enterdir);
smatz@9050: 			if (trackdir != INVALID_TRACKDIR) return_track(trackdir);
smatz@9050: 			return_track(PickRandomBit(trackdirs));
smatz@9050: 		} break;
matthijs@1247: 
smatz@9050: 		case VPF_NPF: { /* NPF */
smatz@9050: 			NPFFindStationOrTileData fstd;
tron@3167: 
smatz@9050: 			NPFFillWithOrderData(&fstd, v);
smatz@9050: 			Trackdir trackdir = DiagdirToDiagTrackdir(enterdir);
smatz@9050: 			//debug("Finding path. Enterdir: %d, Trackdir: %d", enterdir, trackdir);
smatz@9050: 
smatz@9050: 			NPFFoundTargetData ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, true, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES);
smatz@9050: 			if (ftd.best_trackdir == INVALID_TRACKDIR) {
smatz@9050: 				/* We are already at our target. Just do something
smatz@9050: 				 * @todo: maybe display error?
smatz@9050: 				 * @todo: go straight ahead if possible? */
smatz@9050: 				return_track(FindFirstBit2x64(trackdirs));
smatz@9050: 			} else {
smatz@9050: 				/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
smatz@9050: 				 * the direction we need to take to get there, if ftd.best_bird_dist is not 0,
smatz@9050: 				 * we did not find our target, but ftd.best_trackdir contains the direction leading
smatz@9050: 				 * to the tile closest to our target. */
smatz@9050: 				return_track(ftd.best_trackdir);
tron@3167: 			}
smatz@9050: 		} break;
smatz@9050: 
smatz@9050: 		default:
smatz@9050: 		case VPF_OPF: { /* OPF */
smatz@9050: 			DiagDirection dir;
smatz@9050: 
smatz@9050: 			if (IsTileType(desttile, MP_ROAD)) {
frosch@9059: 				if (IsRoadDepot(desttile)) {
smatz@9050: 					dir = GetRoadDepotDirection(desttile);
smatz@9050: 					goto do_it;
smatz@9050: 				}
smatz@9050: 			} else if (IsTileType(desttile, MP_STATION)) {
smatz@9050: 				/* For drive-through stops we can head for the actual station tile */
smatz@9050: 				if (IsStandardRoadStopTile(desttile)) {
smatz@9050: 					dir = GetRoadStopDir(desttile);
truelight@0: do_it:;
smatz@9050: 					/* When we are heading for a depot or station, we just
smatz@9050: 					 * pretend we are heading for the tile in front, we'll
smatz@9050: 					 * see from there */
smatz@9050: 					desttile += TileOffsByDiagDir(dir);
smatz@9050: 					if (desttile == tile && trackdirs & _road_exit_dir_to_incoming_trackdirs[dir]) {
smatz@9050: 						/* If we are already in front of the
smatz@9050: 						 * station/depot and we can get in from here,
smatz@9050: 						 * we enter */
smatz@9050: 						return_track(FindFirstBit2x64(trackdirs & _road_exit_dir_to_incoming_trackdirs[dir]));
smatz@9050: 					}
matthijs@1247: 				}
truelight@0: 			}
smatz@9050: 			/* Do some pathfinding */
smatz@9050: 			frd.dest = desttile;
truelight@0: 
smatz@9050: 			best_track = INVALID_TRACKDIR;
smatz@9050: 			uint best_dist = UINT_MAX;
smatz@9050: 			uint best_maxlen = UINT_MAX;
smatz@9050: 			uint bitmask = (uint)trackdirs;
smatz@9050: 			uint i;
smatz@9050: 			FOR_EACH_SET_BIT(i, bitmask) {
smatz@9050: 				if (best_track == INVALID_TRACKDIR) best_track = (Trackdir)i; // in case we don't find the path, just pick a track
smatz@9050: 				frd.maxtracklen = UINT_MAX;
smatz@9050: 				frd.mindist = UINT_MAX;
frosch@9296: 				FollowTrack(tile, PATHFIND_FLAGS_NONE, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
truelight@0: 
smatz@9050: 				if (frd.mindist < best_dist || (frd.mindist == best_dist && frd.maxtracklen < best_maxlen)) {
smatz@9050: 					best_dist = frd.mindist;
smatz@9050: 					best_maxlen = frd.maxtracklen;
smatz@9050: 					best_track = (Trackdir)i;
smatz@9050: 				}
truelight@0: 			}
smatz@9050: 		} break;
matthijs@1247: 	}
truelight@0: 
truelight@0: found_best_track:;
truelight@0: 
frosch@9112: 	if (HasBit(red_signals, best_track)) return INVALID_TRACKDIR;
truelight@0: 
truelight@193: 	return best_track;
truelight@0: }
truelight@0: 
celestar@3123: static uint RoadFindPathToStop(const Vehicle *v, TileIndex tile)
celestar@1217: {
smatz@9047: 	if (_patches.pathfinder_for_roadvehs == VPF_YAPF) {
belugas@6889: 		/* use YAPF */
smatz@9050: 		return YapfRoadVehDistanceToTile(v, tile);
smatz@9050: 	}
celestar@1217: 
smatz@9050: 	/* use NPF */
smatz@9050: 	Trackdir trackdir = GetVehicleTrackdir(v);
smatz@9050: 	assert(trackdir != INVALID_TRACKDIR);
celestar@1217: 
smatz@9050: 	NPFFindStationOrTileData fstd;
smatz@9050: 	fstd.dest_coords = tile;
smatz@9050: 	fstd.station_index = INVALID_STATION; // indicates that the destination is a tile, not a station
smatz@9050: 
smatz@9050: 	uint dist = NPFRouteToStationOrTile(v->tile, trackdir, false, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPES).best_path_dist;
smatz@9050: 	/* change units from NPF_TILE_LENGTH to # of tiles */
smatz@9050: 	if (dist != UINT_MAX) dist = (dist + NPF_TILE_LENGTH - 1) / NPF_TILE_LENGTH;
smatz@9050: 
KUDr@3915: 	return dist;
celestar@1217: }
celestar@1217: 
rubidium@6329: enum {
rubidium@6329: 	RDE_NEXT_TILE = 0x80,
rubidium@6329: 	RDE_TURNED    = 0x40,
rubidium@6335: 
rubidium@6335: 	/* Start frames for when a vehicle enters a tile/changes its state.
rubidium@6335: 	 * The start frame is different for vehicles that turned around or
rubidium@8394: 	 * are leaving the depot as the do not start at the edge of the tile.
rubidium@8394: 	 * For trams there are a few different start frames as there are two
rubidium@8394: 	 * places where trams can turn. */
rubidium@8394: 	RVC_DEFAULT_START_FRAME                =  0,
rubidium@8394: 	RVC_TURN_AROUND_START_FRAME            =  1,
rubidium@8394: 	RVC_DEPOT_START_FRAME                  =  6,
rubidium@8394: 	RVC_START_FRAME_AFTER_LONG_TRAM        = 22,
rubidium@8394: 	RVC_TURN_AROUND_START_FRAME_SHORT_TRAM = 16,
rubidium@6338: 	/* Stop frame for a vehicle in a drive-through stop */
rubidium@8394: 	RVC_DRIVE_THROUGH_STOP_FRAME           =  7
rubidium@6329: };
rubidium@6329: 
rubidium@6574: struct RoadDriveEntry {
rubidium@6574: 	byte x, y;
rubidium@6574: };
truelight@0: 
belugas@9002: #include "table/roadveh_movement.h"
truelight@0: 
truelight@0: static const byte _road_veh_data_1[] = {
truelight@0: 	20, 20, 16, 16, 0, 0, 0, 0,
truelight@0: 	19, 19, 15, 15, 0, 0, 0, 0,
truelight@0: 	16, 16, 12, 12, 0, 0, 0, 0,
truelight@0: 	15, 15, 11, 11
truelight@0: };
truelight@0: 
maedhros@7353: static bool RoadVehLeaveDepot(Vehicle *v, bool first)
maedhros@7353: {
maedhros@7353: 	/* Don't leave if not all the wagons are in the depot. */
rubidium@7988: 	for (const Vehicle *u = v; u != NULL; u = u->Next()) {
maedhros@7353: 		if (u->u.road.state != RVSB_IN_DEPOT || u->tile != v->tile) return false;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	DiagDirection dir = GetRoadDepotDirection(v->tile);
maedhros@7353: 	v->direction = DiagDirToDir(dir);
maedhros@7353: 
maedhros@7353: 	Trackdir tdir = _roadveh_depot_exit_trackdir[dir];
maedhros@7353: 	const RoadDriveEntry *rdp = _road_drive_data[v->u.road.roadtype][(_opt.road_side << RVS_DRIVE_SIDE) + tdir];
maedhros@7353: 
maedhros@7353: 	int x = TileX(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].x & 0xF);
maedhros@7353: 	int y = TileY(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].y & 0xF);
maedhros@7353: 
maedhros@7353: 	if (first) {
maedhros@7353: 		if (RoadVehFindCloseTo(v, x, y, v->direction) != NULL) return true;
maedhros@7353: 
maedhros@7353: 		VehicleServiceInDepot(v);
maedhros@7353: 
maedhros@7353: 		StartRoadVehSound(v);
maedhros@7353: 
maedhros@7353: 		/* Vehicle is about to leave a depot */
maedhros@7353: 		v->cur_speed = 0;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	BeginVehicleMove(v);
maedhros@7353: 
maedhros@7353: 	v->vehstatus &= ~VS_HIDDEN;
maedhros@7353: 	v->u.road.state = tdir;
maedhros@7353: 	v->u.road.frame = RVC_DEPOT_START_FRAME;
maedhros@7353: 
rubidium@7630: 	v->cur_image = v->GetImage(v->direction);
maedhros@7353: 	v->UpdateDeltaXY(v->direction);
maedhros@7353: 	SetRoadVehPosition(v,x,y);
maedhros@7353: 
maedhros@7353: 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
maedhros@7353: 
maedhros@7353: 	return true;
maedhros@7353: }
maedhros@7353: 
maedhros@7912: static Trackdir FollowPreviousRoadVehicle(const Vehicle *v, const Vehicle *prev, TileIndex tile, DiagDirection entry_dir, bool already_reversed)
maedhros@7353: {
maedhros@7912: 	if (prev->tile == v->tile && !already_reversed) {
maedhros@7353: 		/* If the previous vehicle is on the same tile as this vehicle is
maedhros@7353: 		 * then it must have reversed. */
maedhros@7353: 		return _road_reverse_table[entry_dir];
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	byte prev_state = prev->u.road.state;
maedhros@7353: 	Trackdir dir;
maedhros@7353: 
maedhros@7353: 	if (prev_state == RVSB_WORMHOLE || prev_state == RVSB_IN_DEPOT) {
maedhros@7353: 		DiagDirection diag_dir = INVALID_DIAGDIR;
maedhros@7353: 
smatz@8584: 		if (IsTileType(tile, MP_TUNNELBRIDGE)) {
smatz@8579: 			diag_dir = GetTunnelBridgeDirection(tile);
frosch@9059: 		} else if (IsRoadDepotTile(tile)) {
maedhros@7353: 			diag_dir = ReverseDiagDir(GetRoadDepotDirection(tile));
maedhros@7353: 		}
maedhros@7353: 
maedhros@7353: 		if (diag_dir == INVALID_DIAGDIR) return INVALID_TRACKDIR;
maedhros@7353: 		dir = DiagdirToDiagTrackdir(diag_dir);
rubidium@8757: 	} else {
rubidium@8365: 		if (already_reversed && prev->tile != tile) {
rubidium@8365: 			/*
rubidium@8365: 			 * The vehicle has reversed, but did not go straight back.
rubidium@8365: 			 * It immediatelly turn onto another tile. This means that
rubidium@8365: 			 * the roadstate of the previous vehicle cannot be used
rubidium@8365: 			 * as the direction we have to go with this vehicle.
rubidium@8365: 			 *
rubidium@8365: 			 * Next table is build in the following way:
rubidium@8365: 			 *  - first row for when the vehicle in front went to the northern or
rubidium@8365: 			 *    western tile, second for southern and eastern.
rubidium@8365: 			 *  - columns represent the entry direction.
rubidium@8365: 			 *  - cell values are determined by the Trackdir one has to take from
rubidium@8365: 			 *    the entry dir (column) to the tile in north or south by only
rubidium@8365: 			 *    going over the trackdirs used for turning 90 degrees, i.e.
rubidium@8365: 			 *    TRACKDIR_{UPPER,RIGHT,LOWER,LEFT}_{N,E,S,W}.
rubidium@8365: 			 */
rubidium@8365: 			Trackdir reversed_turn_lookup[2][DIAGDIR_END] = {
rubidium@8365: 				{ TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N,  TRACKDIR_UPPER_E },
rubidium@8365: 				{ TRACKDIR_RIGHT_S, TRACKDIR_LOWER_W, TRACKDIR_LOWER_E, TRACKDIR_LEFT_S  }};
rubidium@8365: 			dir = reversed_turn_lookup[prev->tile < tile ? 0 : 1][ReverseDiagDir(entry_dir)];
rubidium@8757: 		} else if (HasBit(prev_state, RVS_IN_DT_ROAD_STOP)) {
rubidium@8757: 			dir = (Trackdir)(prev_state & RVSB_ROAD_STOP_TRACKDIR_MASK);
rubidium@8757: 		} else if (prev_state < TRACKDIR_END) {
rubidium@8365: 			dir = (Trackdir)prev_state;
rubidium@8757: 		} else {
rubidium@8757: 			return INVALID_TRACKDIR;
rubidium@8365: 		}
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	/* Do some sanity checking. */
maedhros@7353: 	static const RoadBits required_roadbits[] = {
maedhros@7353: 		ROAD_X,            ROAD_Y,            ROAD_NW | ROAD_NE, ROAD_SW | ROAD_SE,
maedhros@7353: 		ROAD_NW | ROAD_SW, ROAD_NE | ROAD_SE, ROAD_X,            ROAD_Y
maedhros@7353: 	};
maedhros@7353: 	RoadBits required = required_roadbits[dir & 0x07];
maedhros@7353: 
rubidium@9212: 	if ((required & GetAnyRoadBits(tile, v->u.road.roadtype, true)) == ROAD_NONE) {
maedhros@7353: 		dir = INVALID_TRACKDIR;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	return dir;
maedhros@7353: }
maedhros@7353: 
rubidium@8394: /**
rubidium@8394:  * Can a tram track build without destruction on the given tile?
rubidium@8556:  * @param p the player that would be building the tram tracks
rubidium@8394:  * @param t the tile to build on.
rubidium@8556:  * @param r the road bits needed.
rubidium@8394:  * @return true when a track track can be build on 't'
rubidium@8394:  */
rubidium@8556: static bool CanBuildTramTrackOnTile(PlayerID p, TileIndex t, RoadBits r)
rubidium@8394: {
rubidium@8556: 	/* The 'current' player is not necessarily the owner of the vehicle. */
rubidium@8556: 	PlayerID original_player = _current_player;
rubidium@8556: 	_current_player = p;
rubidium@8394: 
rubidium@8556: 	CommandCost ret = DoCommand(t, ROADTYPE_TRAM << 4 | r, 0, 0, CMD_BUILD_ROAD);
rubidium@8394: 
rubidium@8556: 	_current_player = original_player;
rubidium@8556: 	return CmdSucceeded(ret);
rubidium@8394: }
rubidium@8394: 
maedhros@7353: static bool IndividualRoadVehicleController(Vehicle *v, const Vehicle *prev)
truelight@0: {
tron@3157: 	Direction new_dir;
tron@3157: 	Direction old_dir;
truelight@0: 	RoadDriveEntry rd;
truelight@0: 	int x,y;
truelight@0: 	uint32 r;
truelight@0: 
truelight@0: 	if (v->u.road.overtaking != 0)  {
rubidium@8507: 		if (IsTileType(v->tile, MP_STATION)) {
rubidium@8507: 			/* Force us to be not overtaking! */
rubidium@8507: 			v->u.road.overtaking = 0;
rubidium@8507: 		} else if (++v->u.road.overtaking_ctr >= 35) {
truelight@2823: 			/* If overtaking just aborts at a random moment, we can have a out-of-bound problem,
truelight@2823: 			 *  if the vehicle started a corner. To protect that, only allow an abort of
rubidium@6326: 			 *  overtake if we are on straight roads */
rubidium@6326: 			if (v->u.road.state < RVSB_IN_ROAD_STOP && IsStraightRoadTrackdir((Trackdir)v->u.road.state)) {
truelight@2823: 				v->u.road.overtaking = 0;
tron@3033: 			}
rubidium@8507: 		}
truelight@0: 	}
truelight@0: 
maedhros@7353: 	/* If this vehicle is in a depot and we've reached this point it must be
maedhros@7353: 	 * one of the articulated parts. It will stay in the depot until activated
maedhros@7353: 	 * by the previous vehicle in the chain when it gets to the right place. */
rubidium@7986: 	if (v->IsInDepot()) return true;
maedhros@7353: 
rubidium@6315: 	/* Save old vehicle position to use at end of move to set viewport area dirty */
truelight@0: 	BeginVehicleMove(v);
truelight@0: 
rubidium@6326: 	if (v->u.road.state == RVSB_WORMHOLE) {
rubidium@6335: 		/* Vehicle is entering a depot or is on a bridge or in a tunnel */
tron@6479: 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
truelight@0: 
rubidium@8762: 		if (IsRoadVehFront(v)) {
rubidium@8762: 			const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);
rubidium@8762: 			if (u != NULL) {
rubidium@8762: 				v->cur_speed = u->First()->cur_speed;
rubidium@8762: 				return false;
rubidium@8762: 			}
truelight@0: 		}
truelight@0: 
smatz@8886: 		if (IsTileType(gp.new_tile, MP_TUNNELBRIDGE) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
rubidium@6315: 			/* Vehicle has just entered a bridge or tunnel */
rubidium@7630: 			v->cur_image = v->GetImage(v->direction);
rubidium@7054: 			v->UpdateDeltaXY(v->direction);
truelight@0: 			SetRoadVehPosition(v,gp.x,gp.y);
maedhros@7353: 			return true;
truelight@0: 		}
truelight@0: 
truelight@0: 		v->x_pos = gp.x;
truelight@0: 		v->y_pos = gp.y;
truelight@0: 		VehiclePositionChanged(v);
celestar@5573: 		if (!(v->vehstatus & VS_HIDDEN)) EndVehicleMove(v);
maedhros@7353: 		return true;
truelight@0: 	}
truelight@0: 
rubidium@6338: 	/* Get move position data for next frame.
rubidium@6338: 	 * For a drive-through road stop use 'straight road' move data.
rubidium@6338: 	 * In this case v->u.road.state is masked to give the road stop entry direction. */
rubidium@7187: 	rd = _road_drive_data[v->u.road.roadtype][(
skidd13@8424: 		(HasBit(v->u.road.state, RVS_IN_DT_ROAD_STOP) ? v->u.road.state & RVSB_ROAD_STOP_TRACKDIR_MASK : v->u.road.state) +
rubidium@6338: 		(_opt.road_side << RVS_DRIVE_SIDE)) ^ v->u.road.overtaking][v->u.road.frame + 1];
truelight@0: 
rubidium@6329: 	if (rd.x & RDE_NEXT_TILE) {
rubidium@7813: 		TileIndex tile = v->tile + TileOffsByDiagDir((DiagDirection)(rd.x & 3));
maedhros@7353: 		Trackdir dir;
truelight@0: 		uint32 r;
tron@3157: 		Direction newdir;
truelight@0: 		const RoadDriveEntry *rdp;
truelight@0: 
maedhros@7353: 		if (IsRoadVehFront(v)) {
maedhros@7353: 			/* If this is the front engine, look for the right path. */
maedhros@7353: 			dir = RoadFindPathToDest(v, tile, (DiagDirection)(rd.x & 3));
maedhros@7353: 		} else {
maedhros@7912: 			dir = FollowPreviousRoadVehicle(v, prev, tile, (DiagDirection)(rd.x & 3), false);
maedhros@7353: 		}
maedhros@7353: 
rubidium@6325: 		if (dir == INVALID_TRACKDIR) {
maedhros@7353: 			if (!IsRoadVehFront(v)) error("!Disconnecting road vehicle.");
truelight@0: 			v->cur_speed = 0;
maedhros@7353: 			return false;
truelight@0: 		}
truelight@0: 
truelight@0: again:
rubidium@8394: 		uint start_frame = RVC_DEFAULT_START_FRAME;
rubidium@6326: 		if (IsReversingRoadTrackdir(dir)) {
matthijs@1247: 			/* Turning around */
rubidium@7187: 			if (v->u.road.roadtype == ROADTYPE_TRAM) {
rubidium@8394: 				/* Determine the road bits the tram needs to be able to turn around
rubidium@8394: 				 * using the 'big' corner loop. */
rubidium@8394: 				RoadBits needed;
rubidium@7187: 				switch (dir) {
rubidium@7187: 					default: NOT_REACHED();
rubidium@7187: 					case TRACKDIR_RVREV_NE: needed = ROAD_SW; break;
rubidium@7187: 					case TRACKDIR_RVREV_SE: needed = ROAD_NW; break;
rubidium@7187: 					case TRACKDIR_RVREV_SW: needed = ROAD_NE; break;
rubidium@7187: 					case TRACKDIR_RVREV_NW: needed = ROAD_SE; break;
rubidium@7187: 				}
rubidium@8394: 				if ((v->Previous() != NULL && v->Previous()->tile == tile) ||
frosch@9059: 						(IsRoadVehFront(v) && IsNormalRoadTile(tile) && !HasRoadWorks(tile) &&
rubidium@8394: 							(needed & GetRoadBits(tile, ROADTYPE_TRAM)) != ROAD_NONE)) {
rubidium@8394: 					/*
rubidium@8394: 					 * Taking the 'big' corner for trams only happens when:
rubidium@8394: 					 * - The previous vehicle in this (articulated) tram chain is
rubidium@8394: 					 *   already on the 'next' tile, we just follow them regardless of
rubidium@8394: 					 *   anything. When it is NOT on the 'next' tile, the tram started
rubidium@8394: 					 *   doing a reversing turn when the piece of tram track on the next
rubidium@8394: 					 *   tile did not exist yet. Do not use the big tram loop as that is
rubidium@8394: 					 *   going to cause the tram to split up.
rubidium@8394: 					 * - Or the front of the tram can drive over the next tile.
rubidium@8394: 					 */
rubidium@8556: 				} else if (!IsRoadVehFront(v) || !CanBuildTramTrackOnTile(v->owner, tile, needed)) {
rubidium@8394: 					/*
rubidium@8394: 					 * Taking the 'small' corner for trams only happens when:
rubidium@8394: 					 * - We are not the from vehicle of an articulated tram.
rubidium@8394: 					 * - Or when the player cannot build on the next tile.
rubidium@8394: 					 *
rubidium@8394: 					 * The 'small' corner means that the vehicle is on the end of a
rubidium@8394: 					 * tram track and needs to start turning there. To do this properly
rubidium@8394: 					 * the tram needs to start at an offset in the tram turning 'code'
rubidium@8394: 					 * for 'big' corners. It furthermore does not go to the next tile,
rubidium@8394: 					 * so that needs to be fixed too.
rubidium@8394: 					 */
rubidium@8394: 					tile = v->tile;
rubidium@8394: 					start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;
rubidium@8394: 				} else {
rubidium@8394: 					/* The player can build on the next tile, so wait till (s)he does. */
rubidium@7187: 					v->cur_speed = 0;
maedhros@7353: 					return false;
rubidium@7187: 				}
frosch@9059: 			} else if (IsNormalRoadTile(v->tile) && GetDisallowedRoadDirections(v->tile) != DRD_NONE) {
rubidium@7260: 				v->cur_speed = 0;
maedhros@7353: 				return false;
rubidium@7187: 			} else {
rubidium@7187: 				tile = v->tile;
rubidium@7187: 			}
truelight@0: 		}
truelight@0: 
rubidium@6315: 		/* Get position data for first frame on the new tile */
rubidium@7187: 		rdp = _road_drive_data[v->u.road.roadtype][(dir + (_opt.road_side << RVS_DRIVE_SIDE)) ^ v->u.road.overtaking];
truelight@0: 
rubidium@8394: 		x = TileX(tile) * TILE_SIZE + rdp[start_frame].x;
rubidium@8394: 		y = TileY(tile) * TILE_SIZE + rdp[start_frame].y;
truelight@0: 
tron@3017: 		newdir = RoadVehGetSlidingDirection(v, x, y);
rubidium@8420: 		if (IsRoadVehFront(v)) {
rubidium@8420: 			Vehicle *u = RoadVehFindCloseTo(v, x, y, newdir);
rubidium@8420: 			if (u != NULL) {
rubidium@8420: 				v->cur_speed = u->First()->cur_speed;
rubidium@8420: 				return false;
rubidium@8420: 			}
rubidium@8420: 		}
truelight@0: 
truelight@0: 		r = VehicleEnterTile(v, tile, x, y);
skidd13@8424: 		if (HasBit(r, VETS_CANNOT_ENTER)) {
tron@1035: 			if (!IsTileType(tile, MP_TUNNELBRIDGE)) {
truelight@0: 				v->cur_speed = 0;
maedhros@7353: 				return false;
truelight@0: 			}
rubidium@6315: 			/* Try an about turn to re-enter the previous tile */
rubidium@6326: 			dir = _road_reverse_table[rd.x & 3];
truelight@0: 			goto again;
truelight@0: 		}
truelight@0: 
skidd13@8450: 		if (IsInsideMM(v->u.road.state, RVSB_IN_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) && IsTileType(v->tile, MP_STATION)) {
skidd13@8450: 			if (IsReversingRoadTrackdir(dir) && IsInsideMM(v->u.road.state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END)) {
rubidium@6315: 				/* New direction is trying to turn vehicle around.
rubidium@6315: 				 * We can't turn at the exit of a road stop so wait.*/
tron@3033: 				v->cur_speed = 0;
maedhros@7353: 				return false;
tron@3033: 			}
tron@3338: 			if (IsRoadStop(v->tile)) {
celestar@1217: 				RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
truelight@0: 
rubidium@6338: 				/* Vehicle is leaving a road stop tile, mark bay as free
rubidium@6338: 				 * For drive-through stops, only do it if the vehicle stopped here */
skidd13@8424: 				if (IsStandardRoadStopTile(v->tile) || HasBit(v->u.road.state, RVS_IS_STOPPING)) {
skidd13@8424: 					rs->FreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY));
skidd13@8425: 					ClrBit(v->u.road.state, RVS_IS_STOPPING);
rubidium@6338: 				}
rubidium@6338: 				if (IsStandardRoadStopTile(v->tile)) rs->SetEntranceBusy(false);
truelight@0: 			}
truelight@0: 		}
truelight@0: 
skidd13@8424: 		if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {
truelight@0: 			v->tile = tile;
truelight@2823: 			v->u.road.state = (byte)dir;
rubidium@8394: 			v->u.road.frame = start_frame;
truelight@0: 		}
truelight@0: 		if (newdir != v->direction) {
truelight@0: 			v->direction = newdir;
truelight@0: 			v->cur_speed -= v->cur_speed >> 2;
truelight@0: 		}
truelight@0: 
rubidium@7630: 		v->cur_image = v->GetImage(newdir);
rubidium@7054: 		v->UpdateDeltaXY(v->direction);
truelight@0: 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
maedhros@7353: 		return true;
truelight@0: 	}
truelight@0: 
rubidium@6329: 	if (rd.x & RDE_TURNED) {
rubidium@6315: 		/* Vehicle has finished turning around, it will now head back onto the same tile */
maedhros@7912: 		Trackdir dir;
truelight@0: 		uint32 r;
tron@3157: 		Direction newdir;
truelight@0: 		const RoadDriveEntry *rdp;
truelight@0: 
rubidium@8394: 		uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME;
rubidium@8394: 
rubidium@8405: 		RoadBits tram;
rubidium@9212: 		if (v->u.road.roadtype == ROADTYPE_TRAM && CountBits(tram = GetAnyRoadBits(v->tile, ROADTYPE_TRAM, true)) == 1) {
rubidium@8394: 			/*
rubidium@8394: 			 * The tram is turning around with one tram 'roadbit'. This means that
rubidium@8394: 			 * it is using the 'big' corner 'drive data'. However, to support the
rubidium@8394: 			 * trams to take a small corner, there is a 'turned' marker in the middle
rubidium@8394: 			 * of the turning 'drive data'. When the tram took the long corner, we
rubidium@8394: 			 * will still use the 'big' corner drive data, but we advance it one
rubidium@8394: 			 * frame. We furthermore set the driving direction so the turning is
rubidium@8394: 			 * going to be properly shown.
rubidium@8394: 			 */
rubidium@8394: 			turn_around_start_frame = RVC_START_FRAME_AFTER_LONG_TRAM;
rubidium@8394: 			switch (tram) {
rubidium@8394: 				default: NOT_REACHED();
rubidium@8394: 				case ROAD_SW: dir = TRACKDIR_RVREV_NE; break;
rubidium@8394: 				case ROAD_NW: dir = TRACKDIR_RVREV_SE; break;
rubidium@8394: 				case ROAD_NE: dir = TRACKDIR_RVREV_SW; break;
rubidium@8394: 				case ROAD_SE: dir = TRACKDIR_RVREV_NW; break;
rubidium@8394: 			}
maedhros@7912: 		} else {
rubidium@8394: 			if (IsRoadVehFront(v)) {
rubidium@8394: 				/* If this is the front engine, look for the right path. */
rubidium@8394: 				dir = RoadFindPathToDest(v, v->tile, (DiagDirection)(rd.x & 3));
rubidium@8394: 			} else {
rubidium@8394: 				dir = FollowPreviousRoadVehicle(v, prev, v->tile, (DiagDirection)(rd.x & 3), true);
rubidium@8394: 			}
maedhros@7912: 		}
maedhros@7912: 
rubidium@6325: 		if (dir == INVALID_TRACKDIR) {
truelight@0: 			v->cur_speed = 0;
maedhros@7353: 			return false;
truelight@0: 		}
truelight@0: 
rubidium@7187: 		rdp = _road_drive_data[v->u.road.roadtype][(_opt.road_side << RVS_DRIVE_SIDE) + dir];
truelight@0: 
rubidium@8394: 		x = TileX(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].x;
rubidium@8394: 		y = TileY(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].y;
truelight@0: 
tron@3017: 		newdir = RoadVehGetSlidingDirection(v, x, y);
maedhros@7353: 		if (IsRoadVehFront(v) && RoadVehFindCloseTo(v, x, y, newdir) != NULL) return false;
truelight@0: 
truelight@0: 		r = VehicleEnterTile(v, v->tile, x, y);
skidd13@8424: 		if (HasBit(r, VETS_CANNOT_ENTER)) {
truelight@0: 			v->cur_speed = 0;
maedhros@7353: 			return false;
truelight@0: 		}
truelight@0: 
rubidium@6335: 		v->u.road.state = dir;
rubidium@8394: 		v->u.road.frame = turn_around_start_frame;
truelight@0: 
truelight@0: 		if (newdir != v->direction) {
truelight@0: 			v->direction = newdir;
truelight@0: 			v->cur_speed -= v->cur_speed >> 2;
truelight@0: 		}
truelight@0: 
rubidium@7630: 		v->cur_image = v->GetImage(newdir);
rubidium@7054: 		v->UpdateDeltaXY(v->direction);
truelight@0: 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
maedhros@7353: 		return true;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	/* This vehicle is not in a wormhole and it hasn't entered a new tile. If
maedhros@7353: 	 * it's on a depot tile, check if it's time to activate the next vehicle in
maedhros@7353: 	 * the chain yet. */
frosch@9059: 	if (v->Next() != NULL && IsRoadDepotTile(v->tile)) {
maedhros@7353: 		if (v->u.road.frame == v->u.road.cached_veh_length + RVC_DEPOT_START_FRAME) {
rubidium@7988: 			RoadVehLeaveDepot(v->Next(), false);
maedhros@7353: 		}
truelight@0: 	}
truelight@0: 
rubidium@6315: 	/* Calculate new position for the vehicle */
tron@3033: 	x = (v->x_pos & ~15) + (rd.x & 15);
tron@3033: 	y = (v->y_pos & ~15) + (rd.y & 15);
truelight@193: 
truelight@0: 	new_dir = RoadVehGetSlidingDirection(v, x, y);
truelight@0: 
skidd13@8450: 	if (IsRoadVehFront(v) && !IsInsideMM(v->u.road.state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END)) {
rubidium@6315: 		/* Vehicle is not in a road stop.
rubidium@6315: 		 * Check for another vehicle to overtake */
tron@3138: 		Vehicle* u = RoadVehFindCloseTo(v, x, y, new_dir);
tron@3138: 
tron@3138: 		if (u != NULL) {
rubidium@8313: 			u = u->First();
rubidium@6315: 			/* There is a vehicle in front overtake it if possible */
tron@3138: 			if (v->u.road.overtaking == 0) RoadVehCheckOvertake(v, u);
rubidium@8165: 			if (v->u.road.overtaking == 0) v->cur_speed = u->cur_speed;
maedhros@7353: 			return false;
tron@3138: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	old_dir = v->direction;
truelight@0: 	if (new_dir != old_dir) {
truelight@0: 		v->direction = new_dir;
truelight@0: 		v->cur_speed -= (v->cur_speed >> 2);
truelight@0: 		if (old_dir != v->u.road.state) {
rubidium@6315: 			/* The vehicle is in a road stop */
rubidium@7630: 			v->cur_image = v->GetImage(new_dir);
rubidium@7054: 			v->UpdateDeltaXY(v->direction);
truelight@0: 			SetRoadVehPosition(v, v->x_pos, v->y_pos);
rubidium@6315: 			/* Note, return here means that the frame counter is not incremented
rubidium@6315: 			 * for vehicles changing direction in a road stop. This causes frames to
rubidium@6335: 			 * be repeated. (XXX) Is this intended? */
maedhros@7353: 			return true;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
rubidium@6338: 	/* If the vehicle is in a normal road stop and the frame equals the stop frame OR
rubidium@6338: 	 * if the vehicle is in a drive-through road stop and this is the destination station
rubidium@6338: 	 * and it's the correct type of stop (bus or truck) and the frame equals the stop frame...
rubidium@6338: 	 * (the station test and stop type test ensure that other vehicles, using the road stop as
rubidium@6338: 	 * a through route, do not stop) */
skidd13@8450: 	if (IsRoadVehFront(v) && ((IsInsideMM(v->u.road.state, RVSB_IN_ROAD_STOP, RVSB_IN_ROAD_STOP_END) &&
rubidium@6338: 			_road_veh_data_1[v->u.road.state - RVSB_IN_ROAD_STOP + (_opt.road_side << RVS_DRIVE_SIDE)] == v->u.road.frame) ||
skidd13@8450: 			(IsInsideMM(v->u.road.state, RVSB_IN_DT_ROAD_STOP, RVSB_IN_DT_ROAD_STOP_END) &&
rubidium@9336: 			v->current_order.GetDestination() == GetStationIndex(v->tile) &&
rubidium@9281: 			GetRoadStopType(v->tile) == (IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK) &&
maedhros@7353: 			v->u.road.frame == RVC_DRIVE_THROUGH_STOP_FRAME))) {
rubidium@6338: 
celestar@1217: 		RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
tron@3315: 		Station* st = GetStationByTile(v->tile);
truelight@0: 
rubidium@6315: 		/* Vehicle is at the stop position (at a bay) in a road stop.
rubidium@6315: 		 * Note, if vehicle is loading/unloading it has already been handled,
rubidium@6315: 		 * so if we get here the vehicle has just arrived or is just ready to leave. */
rubidium@9332: 		if (!v->current_order.IsType(OT_LEAVESTATION) &&
rubidium@9332: 				!v->current_order.IsType(OT_GOTO_DEPOT)) {
rubidium@6315: 			/* Vehicle has arrived at a bay in a road stop */
truelight@193: 
rubidium@6338: 			if (IsDriveThroughStopTile(v->tile)) {
rubidium@6338: 				TileIndex next_tile = TILE_ADD(v->tile, TileOffsByDir(v->direction));
rubidium@9281: 				RoadStopType type = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? ROADSTOP_BUS : ROADSTOP_TRUCK;
rubidium@6338: 
rubidium@6338: 				/* Check if next inline bay is free */
rubidium@6338: 				if (IsDriveThroughStopTile(next_tile) && (GetRoadStopType(next_tile) == type)) {
rubidium@6338: 					RoadStop *rs_n = GetRoadStopByTile(next_tile, type);
rubidium@6338: 
skidd13@8424: 					if (rs_n->IsFreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY))) {
rubidium@6338: 						/* Bay in next stop along is free - use it */
rubidium@6338: 						ClearSlot(v);
rubidium@6338: 						rs_n->num_vehicles++;
rubidium@6338: 						v->u.road.slot = rs_n;
rubidium@6338: 						v->dest_tile = rs_n->xy;
rubidium@6338: 						v->u.road.slot_age = 14;
rubidium@6338: 
rubidium@6338: 						v->u.road.frame++;
rubidium@6338: 						RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
maedhros@7353: 						return true;
rubidium@6338: 					}
rubidium@6338: 				}
rubidium@6338: 			}
rubidium@6338: 
rubidium@6316: 			rs->SetEntranceBusy(false);
truelight@0: 
tron@3315: 			v->last_station_visited = GetStationIndex(v->tile);
truelight@0: 
truelight@0: 			RoadVehArrivesAt(v, st);
KUDr@5902: 			v->BeginLoading();
truelight@0: 
maedhros@7353: 			return false;
truelight@0: 		}
truelight@0: 
rubidium@6315: 		/* Vehicle is ready to leave a bay in a road stop */
rubidium@9332: 		if (!v->current_order.IsType(OT_GOTO_DEPOT)) {
rubidium@6316: 			if (rs->IsEntranceBusy()) {
rubidium@6335: 				/* Road stop entrance is busy, so wait as there is nowhere else to go */
truelight@0: 				v->cur_speed = 0;
maedhros@7353: 				return false;
truelight@0: 			}
bjarni@6589: 			v->current_order.Free();
celestar@3123: 			ClearSlot(v);
truelight@0: 		}
rubidium@6335: 
rubidium@6338: 		if (IsStandardRoadStopTile(v->tile)) rs->SetEntranceBusy(true);
truelight@0: 
celestar@1217: 		if (rs == v->u.road.slot) {
rubidium@6315: 			/* We are leaving the correct station */
celestar@3123: 			ClearSlot(v);
celestar@1217: 		} else if (v->u.road.slot != NULL) {
belugas@6889: 			/* We are leaving the wrong station
belugas@6889: 			 * XXX The question is .. what to do? Actually we shouldn't be here
belugas@6889: 			 * but I guess we need to clear the slot */
Darkvater@5568: 			DEBUG(ms, 0, "Vehicle %d (index %d) arrived at wrong stop", v->unitnumber, v->index);
tron@3138: 			if (v->tile != v->dest_tile) {
Darkvater@5568: 				DEBUG(ms, 2, " current tile 0x%X is not destination tile 0x%X. Route problem", v->tile, v->dest_tile);
tron@3138: 			}
tron@3138: 			if (v->dest_tile != v->u.road.slot->xy) {
Darkvater@5568: 				DEBUG(ms, 2, " stop tile 0x%X is not destination tile 0x%X. Multistop desync", v->u.road.slot->xy, v->dest_tile);
tron@3138: 			}
rubidium@9332: 			if (!v->current_order.IsType(OT_GOTO_STATION)) {
rubidium@9332: 				DEBUG(ms, 2, " current order type (%d) is not OT_GOTO_STATION", v->current_order.GetType());
celestar@3123: 			} else {
rubidium@9336: 				if (v->current_order.GetDestination() != st->index)
Darkvater@5568: 					DEBUG(ms, 2, " current station %d is not target station in current_order.station (%d)",
rubidium@9336: 							st->index, v->current_order.GetDestination());
celestar@3123: 			}
celestar@3123: 
Darkvater@5568: 			DEBUG(ms, 2, " force a slot clearing");
celestar@3123: 			ClearSlot(v);
celestar@1217: 		}
celestar@1217: 
truelight@0: 		StartRoadVehSound(v);
smatz@8846: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 	}
truelight@0: 
rubidium@6315: 	/* Check tile position conditions - i.e. stop position in depot,
rubidium@6315: 	 * entry onto bridge or into tunnel */
truelight@0: 	r = VehicleEnterTile(v, v->tile, x, y);
skidd13@8424: 	if (HasBit(r, VETS_CANNOT_ENTER)) {
truelight@0: 		v->cur_speed = 0;
maedhros@7353: 		return false;
truelight@0: 	}
truelight@0: 
rubidium@6315: 	/* Move to next frame unless vehicle arrived at a stop position
rubidium@6315: 	 * in a depot or entered a tunnel/bridge */
skidd13@8424: 	if (!HasBit(r, VETS_ENTERED_WORMHOLE)) v->u.road.frame++;
truelight@0: 
rubidium@7630: 	v->cur_image = v->GetImage(v->direction);
rubidium@7054: 	v->UpdateDeltaXY(v->direction);
truelight@0: 	RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
maedhros@7353: 	return true;
maedhros@7353: }
maedhros@7353: 
maedhros@7353: static void RoadVehController(Vehicle *v)
maedhros@7353: {
maedhros@7353: 	/* decrease counters */
maedhros@7353: 	v->tick_counter++;
maedhros@7476: 	v->current_order_time++;
maedhros@7353: 	if (v->u.road.reverse_ctr != 0) v->u.road.reverse_ctr--;
maedhros@7353: 
maedhros@7353: 	/* handle crashed */
rubidium@7972: 	if (v->vehstatus & VS_CRASHED) {
maedhros@7353: 		RoadVehIsCrashed(v);
maedhros@7353: 		return;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	RoadVehCheckTrainCrash(v);
maedhros@7353: 
maedhros@7353: 	/* road vehicle has broken down? */
maedhros@7353: 	if (v->breakdown_ctr != 0) {
maedhros@7353: 		if (v->breakdown_ctr <= 2) {
maedhros@7353: 			HandleBrokenRoadVeh(v);
maedhros@7353: 			return;
maedhros@7353: 		}
maedhros@7353: 		v->breakdown_ctr--;
maedhros@7353: 	}
maedhros@7353: 
maedhros@7353: 	if (v->vehstatus & VS_STOPPED) return;
maedhros@7353: 
rubidium@9323: 	ProcessOrders(v);
maedhros@7353: 	v->HandleLoading();
maedhros@7353: 
rubidium@9332: 	if (v->current_order.IsType(OT_LOADING)) return;
maedhros@7353: 
rubidium@7986: 	if (v->IsInDepot() && RoadVehLeaveDepot(v, true)) return;
maedhros@7353: 
maedhros@7353: 	/* Check if vehicle needs to proceed, return if it doesn't */
maedhros@7353: 	if (!RoadVehAccelerate(v)) return;
maedhros@7353: 
rubidium@7988: 	for (Vehicle *prev = NULL; v != NULL; prev = v, v = v->Next()) {
maedhros@7353: 		if (!IndividualRoadVehicleController(v, prev)) break;
maedhros@7353: 	}
truelight@0: }
truelight@0: 
truelight@0: static void AgeRoadVehCargo(Vehicle *v)
truelight@0: {
tron@3017: 	if (_age_cargo_skip_counter != 0) return;
rubidium@7506: 	v->cargo.AgeCargo();
truelight@0: }
truelight@0: 
rubidium@7631: void RoadVehicle::Tick()
truelight@0: {
rubidium@7631: 	AgeRoadVehCargo(this);
maedhros@7353: 
smatz@9052: 	if (IsRoadVehFront(this)) {
smatz@9052: 		if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;
smatz@9052: 		RoadVehController(this);
smatz@9052: 	}
truelight@0: }
truelight@0: 
truelight@0: static void CheckIfRoadVehNeedsService(Vehicle *v)
truelight@0: {
belugas@6889: 	/* If we already got a slot at a stop, use that FIRST, and go to a depot later */
rubidium@7998: 	if (v->u.road.slot != NULL || _patches.servint_roadveh == 0 || !VehicleNeedsService(v)) return;
rubidium@7986: 	if (v->IsInDepot()) {
bjarni@4529: 		VehicleServiceInDepot(v);
bjarni@4529: 		return;
bjarni@4529: 	}
bjarni@4529: 
belugas@6889: 	/* XXX If we already have a depot order, WHY do we search over and over? */
rubidium@7998: 	const Depot *depot = FindClosestRoadDepot(v);
truelight@0: 
truelight@1313: 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
rubidium@9332: 		if (v->current_order.IsType(OT_GOTO_DEPOT)) {
rubidium@9332: 			v->current_order.MakeDummy();
smatz@8846: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: 		}
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
rubidium@9332: 	if (v->current_order.IsType(OT_GOTO_DEPOT) &&
rubidium@9344: 			v->current_order.GetNonStopType() & ONSF_NO_STOP_AT_INTERMEDIATE_STATIONS &&
skidd13@8463: 			!Chance16(1, 20)) {
truelight@0: 		return;
tron@3033: 	}
truelight@0: 
rubidium@9332: 	if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
rubidium@7109: 	ClearSlot(v);
rubidium@7109: 
rubidium@9332: 	v->current_order.MakeGoToDepot(depot->index, false);
truelight@1313: 	v->dest_tile = depot->xy;
smatz@8846: 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
truelight@0: }
truelight@0: 
glx@8963: void RoadVehicle::OnNewDay()
truelight@0: {
glx@8963: 	if (!IsRoadVehFront(this)) return;
maedhros@7353: 
glx@8963: 	if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);
glx@8963: 	if (this->u.road.blocked_ctr == 0) CheckVehicleBreakdown(this);
truelight@0: 
glx@8963: 	AgeVehicle(this);
glx@8963: 	CheckIfRoadVehNeedsService(this);
truelight@0: 
glx@8963: 	CheckOrders(this);
dominik@19: 
belugas@6889: 	/* Current slot has expired */
rubidium@9332: 	if (this->current_order.IsType(OT_GOTO_STATION) && this->u.road.slot != NULL && this->u.road.slot_age-- == 0) {
Darkvater@5568: 		DEBUG(ms, 3, "Slot expired for vehicle %d (index %d) at stop 0x%X",
glx@8963: 			this->unitnumber, this->index, this->u.road.slot->xy);
glx@8963: 		ClearSlot(this);
celestar@3123: 	}
celestar@3123: 
truelight@0: 	/* update destination */
rubidium@9332: 	if (!(this->vehstatus & VS_STOPPED) && this->current_order.IsType(OT_GOTO_STATION) && this->u.road.slot == NULL && !(this->vehstatus & VS_CRASHED)) {
rubidium@9336: 		Station *st = GetStation(this->current_order.GetDestination());
glx@8963: 		RoadStop *rs = st->GetPrimaryRoadStop(this);
rubidium@7965: 		RoadStop *best = NULL;
celestar@1217: 
celestar@3123: 		if (rs != NULL) {
celestar@6161: 			/* We try to obtain a slot if:
celestar@6161: 			 * 1) we're reasonably close to the primary road stop
celestar@6161: 			 * or
celestar@6161: 			 * 2) we're somewhere close to the station rectangle (to make sure we do assign
celestar@6161: 			 *    slots even if the station and its road stops are incredibly spread out)
celestar@6161: 			 */
glx@8963: 			if (DistanceManhattan(this->tile, rs->xy) < 16 || st->rect.PtInExtendedRect(TileX(this->tile), TileY(this->tile), 2)) {
celestar@3431: 				uint dist, badness;
celestar@3431: 				uint minbadness = UINT_MAX;
celestar@1217: 
Darkvater@5568: 				DEBUG(ms, 2, "Attempting to obtain a slot for vehicle %d (index %d) at station %d (0x%X)",
glx@8963: 					this->unitnumber, this->index, st->index, st->xy
tron@4077: 				);
celestar@3123: 				/* Now we find the nearest road stop that has a free slot */
glx@8963: 				for (; rs != NULL; rs = rs->GetNextRoadStop(this)) {
glx@8963: 					dist = RoadFindPathToStop(this, rs->xy);
celestar@3431: 					if (dist == UINT_MAX) {
Darkvater@5568: 						DEBUG(ms, 4, " stop 0x%X is unreachable, not treating further", rs->xy);
celestar@3123: 						continue;
celestar@3123: 					}
KUDr@3915: 					badness = (rs->num_vehicles + 1) * (rs->num_vehicles + 1) + dist;
celestar@3123: 
Darkvater@5568: 					DEBUG(ms, 4, " stop 0x%X has %d vehicle%s waiting", rs->xy, rs->num_vehicles, rs->num_vehicles == 1 ? "":"s");
Darkvater@5568: 					DEBUG(ms, 4, " distance is %u", dist);
Darkvater@5568: 					DEBUG(ms, 4, " badness %u", badness);
celestar@3431: 
celestar@3431: 					if (badness < minbadness) {
celestar@3431: 						best = rs;
celestar@3431: 						minbadness = badness;
celestar@3123: 					}
tron@3033: 				}
celestar@1217: 
celestar@3431: 				if (best != NULL) {
celestar@3431: 					best->num_vehicles++;
Darkvater@5568: 					DEBUG(ms, 3, "Assigned to stop 0x%X", best->xy);
celestar@1217: 
glx@8963: 					this->u.road.slot = best;
glx@8963: 					this->dest_tile = best->xy;
glx@8963: 					this->u.road.slot_age = 14;
celestar@3123: 				} else {
Darkvater@5568: 					DEBUG(ms, 3, "Could not find a suitable stop");
celestar@3123: 				}
celestar@3123: 			} else {
Darkvater@5568: 				DEBUG(ms, 5, "Distance from station too far. Postponing slotting for vehicle %d (index %d) at station %d, (0x%X)",
glx@8963: 						this->unitnumber, this->index, st->index, st->xy);
celestar@1295: 			}
celestar@3123: 		} else {
Darkvater@5568: 			DEBUG(ms, 4, "No road stop for vehicle %d (index %d) at station %d (0x%X)",
glx@8963: 					this->unitnumber, this->index, st->index, st->xy);
celestar@1217: 		}
truelight@0: 	}
truelight@0: 
smatz@9052: 	if (this->running_ticks == 0) return;
truelight@0: 
peter1138@9122: 	const RoadVehicleInfo *rvi = RoadVehInfo(this->engine_type);
peter1138@9122: 	CommandCost cost(EXPENSES_ROADVEH_RUN, rvi->running_cost * GetPriceByIndex(rvi->running_cost_class) * this->running_ticks / (364 * DAY_TICKS));
smatz@9052: 
smatz@9052: 	this->profit_this_year -= cost.GetCost();
smatz@9052: 	this->running_ticks = 0;
truelight@0: 
glx@8963: 	SubtractMoneyFromPlayerFract(this->owner, cost);
truelight@0: 
glx@8963: 	InvalidateWindow(WC_VEHICLE_DETAILS, this->index);
bjarni@1151: 	InvalidateWindowClasses(WC_ROADVEH_LIST);
truelight@0: }
truelight@0: 
truelight@0: 
rubidium@6573: void RoadVehiclesYearlyLoop()
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 
truelight@0: 	FOR_ALL_VEHICLES(v) {
rubidium@6585: 		if (v->type == VEH_ROAD) {
truelight@0: 			v->profit_last_year = v->profit_this_year;
truelight@0: 			v->profit_this_year = 0;
truelight@0: 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
truelight@0: 		}
truelight@0: 	}
truelight@0: }
peter1138@3990: 
peter1138@3990: /** Refit a road vehicle to the specified cargo type
peter1138@3990:  * @param tile unused
belugas@6979:  * @param flags operation to perform
peter1138@3990:  * @param p1 Vehicle ID of the vehicle to refit
peter1138@3990:  * @param p2 Bitstuffed elements
peter1138@3990:  * - p2 = (bit 0-7) - the new cargo type to refit to
peter1138@3990:  * - p2 = (bit 8-15) - the new cargo subtype to refit to
maedhros@7914:  * - p2 = (bit 16) - refit only this vehicle
maedhros@7042:  * @return cost of refit or error
peter1138@3990:  */
rubidium@7439: CommandCost CmdRefitRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
peter1138@3990: {
peter1138@3990: 	Vehicle *v;
rubidium@8726: 	CommandCost cost(EXPENSES_ROADVEH_RUN);
peter1138@3990: 	CargoID new_cid = GB(p2, 0, 8);
peter1138@3990: 	byte new_subtype = GB(p2, 8, 8);
skidd13@8424: 	bool only_this = HasBit(p2, 16);
peter1138@3990: 	uint16 capacity = CALLBACK_FAILED;
maedhros@7914: 	uint total_capacity = 0;
peter1138@3990: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
peter1138@3990: 
peter1138@3990: 	v = GetVehicle(p1);
peter1138@3990: 
rubidium@6585: 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
maedhros@7353: 	if (!CheckRoadVehInDepotStopped(v)) return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
smatz@8641: 	if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_CAN_T_REFIT_DESTROYED_VEHICLE);
peter1138@3990: 
maedhros@7914: 	if (new_cid >= NUM_CARGO) return CMD_ERROR;
peter1138@3990: 
rubidium@7988: 	for (; v != NULL; v = v->Next()) {
maedhros@7914: 		/* XXX: We refit all the attached wagons en-masse if they can be
maedhros@7914: 		 * refitted. This is how TTDPatch does it.  TODO: Have some nice
maedhros@7914: 		 * [Refit] button near each wagon. */
maedhros@7914: 		if (!CanRefitTo(v->engine_type, new_cid)) continue;
peter1138@3990: 
maedhros@7914: 		if (v->cargo_cap == 0) continue;
peter1138@3990: 
skidd13@8424: 		if (HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_REFIT_CAPACITY)) {
maedhros@7914: 			/* Back up the cargo type */
maedhros@7914: 			CargoID temp_cid = v->cargo_type;
maedhros@7914: 			byte temp_subtype = v->cargo_subtype;
maedhros@7914: 			v->cargo_type = new_cid;
maedhros@7914: 			v->cargo_subtype = new_subtype;
maedhros@7914: 
maedhros@7914: 			/* Check the refit capacity callback */
maedhros@7914: 			capacity = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
maedhros@7914: 
maedhros@7914: 			/* Restore the original cargo type */
maedhros@7914: 			v->cargo_type = temp_cid;
maedhros@7914: 			v->cargo_subtype = temp_subtype;
maedhros@7914: 		}
maedhros@7914: 
maedhros@7914: 		if (capacity == CALLBACK_FAILED) {
maedhros@7914: 			/* callback failed or not used, use default capacity */
maedhros@7914: 			const RoadVehicleInfo *rvi = RoadVehInfo(v->engine_type);
maedhros@7914: 
maedhros@7914: 			CargoID old_cid = rvi->cargo_type;
maedhros@7914: 			/* normally, the capacity depends on the cargo type, a vehicle can
maedhros@7914: 			 * carry twice as much mail/goods as normal cargo, and four times as
maedhros@7914: 			 * many passengers
maedhros@7914: 			 */
maedhros@7914: 			capacity = GetVehicleProperty(v, 0x0F, rvi->capacity);
maedhros@7914: 			switch (old_cid) {
maedhros@7914: 				case CT_PASSENGERS: break;
maedhros@7914: 				case CT_MAIL:
maedhros@7914: 				case CT_GOODS: capacity *= 2; break;
maedhros@7914: 				default:       capacity *= 4; break;
maedhros@7914: 			}
maedhros@7914: 			switch (new_cid) {
maedhros@7914: 				case CT_PASSENGERS: break;
maedhros@7914: 				case CT_MAIL:
maedhros@7914: 				case CT_GOODS: capacity /= 2; break;
maedhros@7914: 				default:       capacity /= 4; break;
maedhros@7914: 			}
maedhros@7914: 		}
maedhros@7914: 
maedhros@7914: 		if (capacity == 0) continue;
maedhros@7914: 
maedhros@7914: 		total_capacity += capacity;
maedhros@7914: 
maedhros@7914: 		if (IsHumanPlayer(v->owner) && new_cid != v->cargo_type) {
maedhros@7914: 			cost.AddCost(GetRefitCost(v->engine_type));
maedhros@7914: 		}
maedhros@7914: 
maedhros@7914: 		if (flags & DC_EXEC) {
maedhros@7914: 			v->cargo_cap = capacity;
maedhros@7914: 			v->cargo.Truncate((v->cargo_type == new_cid) ? capacity : 0);
maedhros@7914: 			v->cargo_type = new_cid;
maedhros@7914: 			v->cargo_subtype = new_subtype;
maedhros@7914: 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
maedhros@7914: 			InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
maedhros@7914: 			RebuildVehicleLists();
maedhros@7914: 		}
maedhros@7914: 
maedhros@7914: 		if (only_this) break;
peter1138@3990: 	}
peter1138@3990: 
maedhros@7914: 	_returned_refit_capacity = total_capacity;
peter1138@3990: 
peter1138@3990: 	return cost;
peter1138@3990: }