tron@2186: /* $Id$ */
tron@2186: 
belugas@3508: #include "stdafx.h"
celestar@3431: #include <limits.h>
Darkvater@1891: #include "openttd.h"
tron@1299: #include "debug.h"
tron@2163: #include "functions.h"
tron@3144: #include "road_map.h"
tron@3959: #include "roadveh.h"
tron@3315: #include "station_map.h"
tron@507: #include "table/strings.h"
tron@679: #include "map.h"
tron@1209: #include "tile.h"
truelight@0: #include "vehicle.h"
truelight@0: #include "engine.h"
truelight@0: #include "command.h"
truelight@0: #include "station.h"
truelight@0: #include "news.h"
truelight@0: #include "pathfind.h"
matthijs@1247: #include "npf.h"
truelight@0: #include "player.h"
tron@337: #include "sound.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"
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"
rubidium@4261: #include "date.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: 
truelight@0: 
truelight@0: static const uint16 _road_veh_fp_ax_and[4] = {
truelight@0: 	0x1009, 0x16, 0x520, 0x2A00
truelight@0: };
truelight@0: 
truelight@0: static const byte _road_reverse_table[4] = {
truelight@0: 	6, 7, 14, 15
truelight@0: };
truelight@0: 
truelight@0: static const uint16 _road_pf_table_3[4] = {
truelight@0: 	0x910, 0x1600, 0x2005, 0x2A
truelight@0: };
truelight@0: 
tron@3157: int GetRoadVehImage(const Vehicle* v, Direction direction)
truelight@0: {
truelight@0: 	int img = v->spritenum;
truelight@0: 	int image;
truelight@0: 
truelight@0: 	if (is_custom_sprite(img)) {
truelight@0: 		image = GetCustomVehicleSprite(v, direction);
tron@2989: 		if (image != 0) return image;
peter1138@2464: 		img = orig_road_vehicle_info[v->engine_type - ROAD_ENGINES_INDEX].image_index;
truelight@0: 	}
truelight@193: 
truelight@0: 	image = direction + _roadveh_images[img];
tron@2989: 	if (v->cargo_count >= v->cargo_cap / 2) image += _roadveh_full_adder[img];
truelight@0: 	return image;
truelight@0: }
truelight@0: 
tron@2477: void DrawRoadVehEngine(int x, int y, EngineID engine, uint32 image_ormod)
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) {
celestar@378: 			DrawSprite(sprite | image_ormod, x, y);
celestar@378: 			return;
celestar@378: 		}
peter1138@2464: 		spritenum = orig_road_vehicle_info[engine - ROAD_ENGINES_INDEX].image_index;
celestar@378: 	}
celestar@378: 	DrawSprite((6 + _roadveh_images[spritenum]) | image_ormod, x, y);
truelight@0: }
truelight@0: 
tron@2817: static int32 EstimateRoadVehCost(EngineID engine_type)
truelight@0: {
tron@538: 	return ((_price.roadveh_base >> 3) * RoadVehInfo(engine_type)->base_cost) >> 5;
truelight@0: }
truelight@0: 
Darkvater@1793: /** Build a road vehicle.
tron@3491:  * @param tile tile of depot where road vehicle is built
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:  */
tron@3491: int32 CmdBuildRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@0: 	int32 cost;
truelight@0: 	Vehicle *v;
truelight@1282: 	UnitID unit_num;
truelight@0: 	Engine *e;
truelight@193: 
peter1138@5215: 	if (!IsEngineBuildable(p1, VEH_Road, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
bjarni@1196: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
truelight@0: 
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: 
truelight@0: 	v = AllocateVehicle();
truelight@1024: 	if (v == NULL || IsOrderPoolFull())
truelight@0: 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
truelight@0: 
truelight@0: 	/* find the first free roadveh id */
peter1138@4095: 	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: 
truelight@0: 		v->unitnumber = unit_num;
truelight@0: 		v->direction = 0;
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;
truelight@0: 		v->z_pos = GetSlopeZ(x,y);
truelight@0: 		v->z_height = 6;
truelight@0: 
truelight@0: 		v->u.road.state = 254;
truelight@0: 		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;
truelight@0: 		v->value = cost;
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;
truelight@0: 		v->engine_type = (byte)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: 
truelight@0: 		v->string_id = STR_SV_ROADVEH_NAME;
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->type = VEH_Road;
truelight@0: 		v->cur_image = 0xC15;
peter1138@2804: 		v->random_bits = VehicleRandomBits();
truelight@0: 
truelight@0: 		VehiclePositionChanged(v);
bjarni@4574: 		GetPlayer(_current_player)->num_engines[p1]++;
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@2618: 			InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Road); // updates the replace Road window
truelight@0: 	}
truelight@0: 
truelight@0: 	return cost;
truelight@0: }
truelight@0: 
Darkvater@1793: /** Start/Stop a road vehicle.
tron@3491:  * @param tile unused
Darkvater@1793:  * @param p1 road vehicle ID to start/stop
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
tron@3491: int32 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: 
Darkvater@1793: 	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) {
tron@3959: 		if (IsRoadVehInDepotStopped(v)) {
tron@3139: 			DeleteVehicleNews(p1, STR_9016_ROAD_VEHICLE_IS_WAITING);
tron@3139: 		}
tron@3139: 
truelight@0: 		v->vehstatus ^= VS_STOPPED;
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
truelight@0: 	}
truelight@0: 
truelight@0: 	return 0;
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: 
Darkvater@1793: /** Sell a road vehicle.
tron@3491:  * @param tile unused
Darkvater@1793:  * @param p1 vehicle ID to be sold
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
tron@3491: int32 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: 
Darkvater@1793: 	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
bjarni@1237: 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
bjarni@1237: 
tron@3959: 	if (!IsRoadVehInDepotStopped(v)) {
truelight@0: 		return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
tron@3033: 	}
truelight@193: 
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);
celestar@3123: 		ClearSlot(v);
bjarni@5256: 		DeleteDepotHighlightOfVehicle(v);
truelight@0: 		DeleteVehicle(v);
tron@3017: 		if (IsLocalPlayer()) InvalidateWindow(WC_REPLACE_VEHICLE, VEH_Road);
truelight@0: 	}
truelight@193: 
truelight@0: 	return -(int32)v->value;
truelight@0: }
truelight@0: 
truelight@0: typedef struct RoadFindDepotData {
truelight@0: 	uint best_length;
tron@1977: 	TileIndex tile;
truelight@0: 	byte owner;
truelight@0: } RoadFindDepotData;
truelight@0: 
tron@3186: static const DiagDirection _road_pf_directions[] = {
tron@3186: 	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, 255, 255,
tron@3186: 	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE, 255, 255
truelight@0: };
truelight@0: 
tron@3137: static bool EnumRoadSignalFindDepot(TileIndex tile, void* data, int track, uint length, byte* state)
truelight@0: {
tron@3137: 	RoadFindDepotData* rfdd = data;
tron@3137: 
Darkvater@4559: 	tile += TileOffsByDiagDir(_road_pf_directions[track]);
truelight@0: 
tron@1035: 	if (IsTileType(tile, MP_STREET) &&
rubidium@3793: 			GetRoadTileType(tile) == ROAD_TILE_DEPOT &&
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: {
tron@1977: 	TileIndex tile = v->tile;
truelight@193: 
KUDr@3900: 	if (_patches.yapf.road_use_yapf) {
KUDr@3900: 		Depot* ret = YapfFindNearestRoadDepot(v);
KUDr@3900: 		return ret;
KUDr@3900: 	} else if (_patches.new_pathfinding_all) {
matthijs@1247: 		NPFFoundTargetData ftd;
matthijs@1247: 		/* See where we are now */
matthijs@1942: 		Trackdir trackdir = GetVehicleTrackdir(v);
matthijs@1745: 
matthijs@2006: 		ftd = NPFRouteToDepotBreadthFirst(v->tile, trackdir, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE);
tron@3017: 		if (ftd.best_bird_dist == 0) {
matthijs@1247: 			return GetDepotByTile(ftd.node.tile); /* Target found */
tron@3017: 		} else {
truelight@1313: 			return NULL; /* Target not found */
tron@3017: 		}
matthijs@1247: 		/* We do not search in two directions here, why should we? We can't reverse right now can we? */
matthijs@1247: 	} else {
matthijs@1247: 		RoadFindDepotData rfdd;
tron@3153: 		DiagDirection i;
tron@3153: 
matthijs@1247: 		rfdd.owner = v->owner;
matthijs@1247: 		rfdd.best_length = (uint)-1;
truelight@0: 
matthijs@1247: 		/* search in all directions */
tron@3033: 		for (i = 0; i != 4; i++) {
tron@3137: 			FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, i, EnumRoadSignalFindDepot, NULL, &rfdd);
tron@3033: 		}
truelight@0: 
tron@3017: 		if (rfdd.best_length == (uint)-1) return NULL;
truelight@0: 
matthijs@1247: 		return GetDepotByTile(rfdd.tile);
matthijs@1247: 	}
truelight@0: }
truelight@0: 
Darkvater@1793: /** Send a road vehicle to the depot.
tron@3491:  * @param tile unused
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:  */
tron@3491: int32 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;
Darkvater@4546: 		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: 
bjarni@4506: 	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: 
bjarni@4526: 	if (IsRoadVehInDepot(v)) return CMD_ERROR;
bjarni@4526: 
Darkvater@1793: 	/* If the current orders are already goto-depot */
tron@555: 	if (v->current_order.type == OT_GOTO_DEPOT) {
bjarni@4519: 		if (!!(p2 & DEPOT_SERVICE) == HASBIT(v->current_order.flags, OFB_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) {
bjarni@4510: 				TOGGLEBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
bjarni@4510: 				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
bjarni@4510: 			}
bjarni@4510: 			return 0;
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 */
celestar@1530: 			if (HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS))
truelight@0: 				v->cur_order_index++;
celestar@1530: 
tron@555: 			v->current_order.type = OT_DUMMY;
tron@555: 			v->current_order.flags = 0;
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 		}
truelight@0: 		return 0;
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) {
celestar@3236: 		ClearSlot(v);
tron@555: 		v->current_order.type = OT_GOTO_DEPOT;
bjarni@4412: 		v->current_order.flags = OF_NON_STOP;
bjarni@4506: 		if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
bjarni@5259: 		v->current_order.refit_cargo = CT_INVALID;
tron@4527: 		v->current_order.dest = dep->index;
Darkvater@1793: 		v->dest_tile = dep->xy;
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 	}
truelight@193: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
Darkvater@1793: /** Turn a roadvehicle around.
tron@3491:  * @param tile unused
Darkvater@1793:  * @param p1 vehicle ID to turn
Darkvater@1793:  * @param p2 unused
Darkvater@1793:  */
tron@3491: int32 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: 
Darkvater@1793: 	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
truelight@0: 
celestar@5573: 	if (v->vehstatus & VS_STOPPED ||
truelight@0: 			v->u.road.crashed_ctr != 0 ||
truelight@0: 			v->breakdown_ctr != 0 ||
truelight@0: 			v->u.road.overtaking != 0 ||
celestar@5573: 			v->u.road.state == 255 ||
celestar@5573: 			IsRoadVehInDepot(v) ||
truelight@0: 			v->cur_speed < 5) {
truelight@0: 		return CMD_ERROR;
truelight@0: 	}
truelight@193: 
celestar@5573: 	if (IsTunnelTile(v->tile) && DirToDiagDir(v->direction) == GetTunnelDirection(v->tile)) return CMD_ERROR;
celestar@5573: 	if (IsBridgeTile(v->tile) && DirToDiagDir(v->direction) == GetBridgeRampDirection(v->tile)) return CMD_ERROR;
celestar@5573: 
tron@3138: 	if (flags & DC_EXEC) v->u.road.reverse_ctr = 180;
truelight@0: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
truelight@0: 
truelight@0: static void MarkRoadVehDirty(Vehicle *v)
truelight@0: {
truelight@0: 	v->cur_image = GetRoadVehImage(v, v->direction);
truelight@0: 	MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
truelight@0: }
truelight@0: 
truelight@0: static void UpdateRoadVehDeltaXY(Vehicle *v)
truelight@0: {
truelight@0: #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
truelight@0: 	uint32 x = _delta_xy_table[v->direction];
tron@2150: 	v->x_offs        = GB(x,  0, 8);
tron@2150: 	v->y_offs        = GB(x,  8, 8);
tron@2150: 	v->sprite_width  = GB(x, 16, 8);
tron@2150: 	v->sprite_height = GB(x, 24, 8);
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: 
truelight@0: 	// mark station as not busy
peter1138@2671: 	CLRBIT(rs->status, 7);
truelight@193: 
truelight@0: 	// free parking bay
peter1138@2671: 	SETBIT(rs->status, HASBIT(v->u.road.state, 1) ? 1 : 0);
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehDelete(Vehicle *v)
truelight@0: {
truelight@0: 	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
truelight@0: 	InvalidateWindow(WC_VEHICLE_DETAILS, 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: 
truelight@0: 	BeginVehicleMove(v);
truelight@0: 	EndVehicleMove(v);
truelight@193: 
celestar@3123: 	ClearSlot(v);
truelight@0: 	DeleteVehicle(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: 
truelight@0: 	// 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: 
truelight@0: 	uint32 r = Random();
tron@3160: 
tron@3160: 	v->direction = ChangeDir(v->direction, delta[r & 3]);
truelight@0: 	BeginVehicleMove(v);
truelight@0: 	UpdateRoadVehDeltaXY(v);
truelight@0: 	v->cur_image = GetRoadVehImage(v, v->direction);
truelight@0: 	SetRoadVehPosition(v, v->x_pos, v->y_pos);
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);
truelight@0: 	} else if (v->u.road.crashed_ctr >= 2220) {
truelight@0: 		RoadVehDelete(v);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@3138: static void* EnumCheckRoadVehCrashTrain(Vehicle* v, void* data)
truelight@0: {
tron@3138: 	const Vehicle* u = data;
tron@3138: 
tron@2989: 	return
tron@2989: 		v->type == VEH_Train &&
tron@2989: 		myabs(v->z_pos - u->z_pos) <= 6 &&
tron@2989: 		myabs(v->x_pos - u->x_pos) <= 4 &&
tron@2989: 		myabs(v->y_pos - u->y_pos) <= 4 ?
tron@2989: 			v : NULL;
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehCrash(Vehicle *v)
truelight@0: {
truelight@0: 	uint16 pass;
truelight@0: 
truelight@0: 	v->u.road.crashed_ctr++;
truelight@0: 	v->vehstatus |= VS_CRASHED;
celestar@3236: 	ClearSlot(v);
truelight@0: 
darkvater@755: 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 
truelight@0: 	pass = 1;
tron@2989: 	if (v->cargo_type == CT_PASSENGERS) pass += v->cargo_count;
truelight@0: 	v->cargo_count = 0;
tron@2951: 
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,
truelight@0: 		NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),
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: {
tron@1977: 	TileIndex tile;
truelight@0: 
tron@2951: 	if (v->u.road.state == 255) return;
truelight@0: 
truelight@0: 	tile = v->tile;
truelight@0: 
Darkvater@3560: 	if (!IsLevelCrossingTile(tile)) return;
truelight@0: 
tron@3138: 	if (VehicleFromPos(tile, v, EnumCheckRoadVehCrashTrain) != NULL)
truelight@0: 		RoadVehCrash(v);
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)) {
peter1138@4656: 			SndPlayVehicleFx((_opt.landscape != LT_CANDY) ?
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);
tron@2989: 			if (u != NULL) u->u.special.unk0 = 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: 
truelight@0: static void ProcessRoadVehOrder(Vehicle *v)
truelight@0: {
truelight@1024: 	const Order *order;
truelight@0: 
tron@3004: 	switch (v->current_order.type) {
tron@3004: 		case OT_GOTO_DEPOT:
tron@3004: 			// Let a depot order in the orderlist interrupt.
tron@3004: 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
tron@3004: 			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
tron@3004: 					!VehicleNeedsService(v)) {
tron@3004: 				v->cur_order_index++;
tron@3004: 			}
tron@3004: 			break;
tron@3004: 
tron@3004: 		case OT_LOADING:
tron@3004: 		case OT_LEAVESTATION:
truelight@0: 			return;
truelight@4351: 
truelight@4351: 		default: break;
truelight@0: 	}
truelight@0: 
tron@3004: 	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
truelight@0: 
truelight@1024: 	order = GetVehicleOrder(v, v->cur_order_index);
truelight@0: 
truelight@1024: 	if (order == NULL) {
tron@555: 		v->current_order.type = OT_NOTHING;
tron@555: 		v->current_order.flags = 0;
truelight@0: 		v->dest_tile = 0;
celestar@3123: 		ClearSlot(v);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@4527: 	if (order->type  == v->current_order.type &&
tron@4527: 			order->flags == v->current_order.flags &&
tron@4527: 			order->dest  == v->current_order.dest) {
truelight@0: 		return;
tron@2951: 	}
truelight@0: 
truelight@1024: 	v->current_order = *order;
truelight@0: 
tron@4179: 	switch (order->type) {
tron@4179: 		case OT_GOTO_STATION: {
tron@4179: 			const RoadStop* rs;
celestar@1217: 
tron@4527: 			if (order->dest == v->last_station_visited) {
tron@4179: 				v->last_station_visited = INVALID_STATION;
tron@4179: 			}
tron@4179: 
tron@4179: 			rs = GetPrimaryRoadStop(
tron@4527: 				GetStation(order->dest),
tron@4179: 				v->cargo_type == CT_PASSENGERS ? RS_BUS : RS_TRUCK
tron@4179: 			);
tron@4179: 
tron@4179: 			if (rs != NULL) {
tron@4179: 				TileIndex dest = rs->xy;
tron@4179: 				uint mindist = DistanceManhattan(v->tile, rs->xy);
tron@4179: 
tron@4179: 				for (rs = rs->next; rs != NULL; rs = rs->next) {
tron@4179: 					uint dist = DistanceManhattan(v->tile, rs->xy);
tron@4179: 
tron@4179: 					if (dist < mindist) {
tron@4179: 						mindist = dist;
tron@4179: 						dest = rs->xy;
tron@4179: 					}
tron@4179: 				}
tron@4179: 				v->dest_tile = dest;
tron@4179: 			} else {
tron@4179: 				// There is no stop left at the station, so don't even TRY to go there
tron@4179: 				v->cur_order_index++;
tron@4179: 				v->dest_tile = 0;
tron@4179: 			}
tron@4179: 			break;
tron@3004: 		}
celestar@1231: 
tron@4179: 		case OT_GOTO_DEPOT:
tron@4527: 			v->dest_tile = GetDepot(order->dest)->xy;
tron@4179: 			break;
celestar@1217: 
tron@4179: 		default:
tron@4179: 			v->dest_tile = 0;
tron@4179: 			break;
truelight@0: 	}
truelight@0: 
truelight@1024: 	InvalidateVehicleOrder(v);
truelight@0: }
truelight@0: 
truelight@0: static void HandleRoadVehLoading(Vehicle *v)
truelight@0: {
tron@3004: 	switch (v->current_order.type) {
tron@3004: 		case OT_LOADING: {
tron@3004: 			Order b;
truelight@0: 
tron@3004: 			if (--v->load_unload_time_rem != 0) return;
truelight@0: 
peter1138@5211: 			if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
peter1138@5211: 					(_patches.gradual_loading && !HASBIT(v->load_status, LS_LOADING_FINISHED)))) {
tron@3004: 				SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);
peter1138@5211: 				if (LoadUnloadVehicle(v, false)) {
tron@3004: 					InvalidateWindow(WC_ROADVEH_LIST, v->owner);
tron@3004: 					MarkRoadVehDirty(v);
tron@3004: 				}
tron@3004: 				return;
truelight@0: 			}
tron@3004: 
tron@3004: 			b = v->current_order;
tron@3004: 			v->current_order.type = OT_LEAVESTATION;
tron@3004: 			v->current_order.flags = 0;
tron@3004: 			if (!(b.flags & OF_NON_STOP)) return;
tron@3004: 			break;
truelight@0: 		}
truelight@193: 
tron@3004: 		case OT_DUMMY: break;
tron@3004: 
tron@3004: 		default: return;
truelight@0: 	}
truelight@0: 
truelight@0: 	v->cur_order_index++;
truelight@1024: 	InvalidateVehicleOrder(v);
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: 
truelight@0: typedef struct RoadVehFindData {
tron@3017: 	int x;
tron@3017: 	int y;
tron@3017: 	const Vehicle* veh;
tron@3157: 	Direction dir;
truelight@0: } RoadVehFindData;
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: 
tron@3138: 	const RoadVehFindData* rvf = 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
tron@3138: 		rvf->veh != v &&
tron@3138: 		v->type == VEH_Road &&
tron@3959: 		!IsRoadVehInDepot(v) &&
tron@3138: 		myabs(v->z_pos - rvf->veh->z_pos) < 6 &&
tron@3138: 		v->direction == rvf->dir &&
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;
truelight@0: 
tron@3017: 	if (v->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;
tron@3138: 	u = VehicleFromPos(TileVirtXY(x, y), &rvf, EnumCheckRoadVehClose);
truelight@193: 
dominik@63: 	// This code protects a roadvehicle from being blocked for ever
miham@826: 	//  If more than 1480 / 74 days a road vehicle is blocked, it will
dominik@63: 	//  drive just through it. The ultimate backup-code of TTD.
dominik@63: 	// It can be disabled.
truelight@0: 	if (u == NULL) {
peter1138@3009: 		v->u.road.blocked_ctr = 0;
truelight@0: 		return NULL;
truelight@0: 	}
truelight@0: 
tron@3033: 	if (++v->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: {
tron@2550: 	if (v->cargo_type == CT_PASSENGERS) {
truelight@0: 		/* Check if station was ever visited before */
truelight@0: 		if (!(st->had_vehicle_of_type & HVOT_BUS)) {
truelight@0: 			uint32 flags;
truelight@0: 
truelight@0: 			st->had_vehicle_of_type |= HVOT_BUS;
tron@534: 			SetDParam(0, st->index);
truelight@0: 			flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
truelight@0: 			AddNewsItem(
truelight@0: 				STR_902F_CITIZENS_CELEBRATE_FIRST,
truelight@0: 				flags,
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: 			uint32 flags;
truelight@0: 
truelight@0: 			st->had_vehicle_of_type |= HVOT_TRUCK;
tron@534: 			SetDParam(0, st->index);
truelight@0: 			flags = (v->owner == _local_player) ? NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) : NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ARRIVAL_OTHER, 0);
truelight@0: 			AddNewsItem(
truelight@0: 				STR_9030_CITIZENS_CELEBRATE_FIRST,
truelight@0: 				flags,
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: 
truelight@0: 	// Clamp
truelight@0: 	spd = min(spd, v->max_speed);
celestar@5573: 	if (v->u.road.state == 255) spd = min(spd, SetSpeedLimitOnBridge(v));
truelight@0: 
truelight@0: 	//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) {
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
tron@2951: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	// 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[] = {
tron@3157: 		DIR_N , DIR_NW, DIR_W , 0,
tron@3157: 		DIR_NE, DIR_N , DIR_SW, 0,
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: {
tron@3168: 	Direction new = RoadVehGetNewDirection(v, x, y);
tron@3168: 	Direction old = v->direction;
tron@3159: 	DirDiff delta;
tron@3157: 
tron@3168: 	if (new == old) return old;
tron@3168: 	delta = (DirDifference(new, old) > DIRDIFF_REVERSE ? DIRDIFF_45LEFT : DIRDIFF_45RIGHT);
tron@3168: 	return ChangeDir(old, delta);
truelight@0: }
truelight@0: 
truelight@0: typedef struct OvertakeData {
tron@3138: 	const Vehicle* u;
tron@3138: 	const Vehicle* v;
tron@1977: 	TileIndex tile;
truelight@0: 	byte tilebits;
truelight@0: } OvertakeData;
truelight@0: 
tron@3138: static void* EnumFindVehToOvertake(Vehicle* v, void* data)
truelight@0: {
tron@3138: 	const OvertakeData* od = data;
tron@3138: 
tron@3017: 	return
tron@4170: 		v->tile == od->tile && v->type == VEH_Road && v != od->u && v != od->v ?
tron@3017: 			v : NULL;
truelight@0: }
truelight@0: 
truelight@0: static bool FindRoadVehToOvertake(OvertakeData *od)
truelight@0: {
truelight@0: 	uint32 bits;
truelight@0: 
tron@3033: 	bits = GetTileTrackStatus(od->tile, TRANSPORT_ROAD) & 0x3F;
truelight@0: 
tron@3138: 	if (!(od->tilebits & bits) || (bits & 0x3C) || (bits & 0x3F3F0000))
truelight@0: 		return true;
tron@3138: 	return VehicleFromPos(od->tile, od, EnumFindVehToOvertake) != NULL;
truelight@0: }
truelight@0: 
truelight@0: static void RoadVehCheckOvertake(Vehicle *v, Vehicle *u)
truelight@0: {
truelight@0: 	OvertakeData od;
truelight@0: 	byte tt;
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: 
tron@3033: 	if (v->direction != u->direction || !(v->direction & 1)) return;
truelight@0: 
tron@3033: 	if (v->u.road.state >= 32 || (v->u.road.state & 7) > 1) return;
truelight@0: 
tron@2150: 	tt = GetTileTrackStatus(v->tile, TRANSPORT_ROAD) & 0x3F;
tron@2951: 	if ((tt & 3) == 0) return;
tron@2951: 	if ((tt & 0x3C) != 0) return;
truelight@0: 
tron@2951: 	if (tt == 3) tt = (v->direction & 2) ? 2 : 1;
truelight@0: 	od.tilebits = tt;
truelight@0: 
truelight@0: 	od.tile = v->tile;
tron@2951: 	if (FindRoadVehToOvertake(&od)) return;
truelight@0: 
Darkvater@4559: 	od.tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));
tron@2951: 	if (FindRoadVehToOvertake(&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 {
tron@2951: //		if (FindRoadVehToOvertake(&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 num = 0;
truelight@0: 	uint b = bits;
truelight@0: 	uint i;
truelight@0: 
truelight@0: 	do {
tron@2951: 		if (b & 1) num++;
truelight@0: 	} while (b >>= 1);
truelight@0: 
tron@2637: 	num = RandomRange(num);
truelight@0: 
tron@3017: 	for (i = 0; !(bits & 1) || (int)--num >= 0; bits >>= 1, i++) {}
truelight@0: 	return i;
truelight@0: }
truelight@0: 
truelight@0: typedef struct {
truelight@0: 	TileIndex dest;
truelight@0: 	uint maxtracklen;
truelight@0: 	uint mindist;
truelight@0: } FindRoadToChooseData;
truelight@0: 
tron@3137: static bool EnumRoadTrackFindDist(TileIndex tile, void* data, int track, uint length, byte* state)
truelight@0: {
tron@3137: 	FindRoadToChooseData* frd = 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: 
KUDr@3900: static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes)
KUDr@3900: {
KUDr@3900: 
KUDr@3900: 	void* perf = NpfBeginInterval();
KUDr@3900: 	NPFFoundTargetData ret = NPFRouteToStationOrTile(tile, trackdir, target, 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: 
truelight@0: // Returns direction to choose
truelight@0: // or -1 if the direction is currently blocked
tron@3157: static int RoadFindPathToDest(Vehicle* v, TileIndex tile, DiagDirection enterdir)
truelight@0: {
truelight@0: #define return_track(x) {best_track = x; goto found_best_track; }
truelight@0: 
truelight@0: 	uint16 signal;
truelight@0: 	uint bitmask;
tron@1977: 	TileIndex desttile;
truelight@0: 	FindRoadToChooseData frd;
truelight@0: 	int best_track;
truelight@0: 	uint best_dist, best_maxlen;
truelight@0: 	uint i;
truelight@0: 
truelight@0: 	{
tron@3017: 		uint32 r = GetTileTrackStatus(tile, TRANSPORT_ROAD);
tron@2484: 		signal  = GB(r, 16, 16);
tron@2484: 		bitmask = GB(r,  0, 16);
truelight@0: 	}
truelight@0: 
tron@1035: 	if (IsTileType(tile, MP_STREET)) {
KUDr@4445: 		if (GetRoadTileType(tile) == ROAD_TILE_DEPOT && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir)) {
KUDr@4445: 			/* Road depot owned by another player or with the wrong orientation */
KUDr@3937: 			bitmask = 0;
tron@2549: 		}
celestar@3404: 	} else if (IsTileType(tile, MP_STATION) && IsRoadStopTile(tile)) {
KUDr@4445: 		if (!IsTileOwner(tile, v->owner) || GetRoadStopDir(tile) == enterdir) {
KUDr@4445: 			/* different station owner or wrong orientation */
KUDr@3937: 			bitmask = 0;
KUDr@3937: 		} else {
darkvater@241: 			/* Our station */
peter1138@3092: 			RoadStopType rstype = (v->cargo_type == CT_PASSENGERS) ? RS_BUS : RS_TRUCK;
tron@3138: 
KUDr@3937: 			if (GetRoadStopType(tile) != rstype) {
KUDr@3937: 				// wrong station type
KUDr@3937: 				bitmask = 0;
KUDr@3937: 			} else {
KUDr@3937: 				// proper station type, check if there is free loading bay
peter1138@3092: 				const RoadStop *rs = GetRoadStopByTile(tile, rstype);
KUDr@3937: 				if (rs == NULL || (!_patches.roadveh_queue && GB(rs->status, 0, 2) == 0)) {
KUDr@3937: 					// station is full and RV queuing is off
KUDr@3937: 					bitmask = 0;
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: 
truelight@159: 	/* remove unreachable tracks */
matthijs@1247: 	bitmask &= _road_veh_fp_ax_and[enterdir];
truelight@0: 	if (bitmask == 0) {
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) {
matthijs@1247: 		// Pick a random track
truelight@0: 		return_track(PickRandomBit(bitmask));
truelight@0: 	}
truelight@0: 
matthijs@1247: 	// Only one track to choose between?
matthijs@1247: 	if (!(KillFirstBit2x64(bitmask))) {
truelight@0: 		return_track(FindFirstBit2x64(bitmask));
truelight@0: 	}
truelight@0: 
KUDr@3900: 	if (_patches.yapf.road_use_yapf) {
KUDr@3900: 		Trackdir trackdir = YapfChooseRoadTrack(v, tile, enterdir);
KUDr@3900: 		if (trackdir != INVALID_TRACKDIR) return_track(trackdir);
KUDr@3900: 		return_track(PickRandomBit(bitmask));
KUDr@3900: 	} else if (_patches.new_pathfinding_all) {
matthijs@1247: 		NPFFindStationOrTileData fstd;
matthijs@1247: 		NPFFoundTargetData ftd;
matthijs@1247: 		byte trackdir;
matthijs@1247: 
matthijs@1247: 		NPFFillWithOrderData(&fstd, v);
matthijs@1942: 		trackdir = DiagdirToDiagTrackdir(enterdir);
matthijs@1247: 		//debug("Finding path. Enterdir: %d, Trackdir: %d", enterdir, trackdir);
matthijs@1247: 
Darkvater@4559: 		ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE);
matthijs@1698: 		if (ftd.best_trackdir == 0xff) {
matthijs@1698: 			/* We are already at our target. Just do something */
matthijs@1247: 			//TODO: maybe display error?
matthijs@1247: 			//TODO: go straight ahead if possible?
matthijs@1247: 			return_track(FindFirstBit2x64(bitmask));
matthijs@1247: 		} else {
matthijs@1698: 			/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
matthijs@1698: 			the direction we need to take to get there, if ftd.best_bird_dist is not 0,
matthijs@1698: 			we did not find our target, but ftd.best_trackdir contains the direction leading
matthijs@1698: 			to the tile closest to our target. */
matthijs@1247: 			return_track(ftd.best_trackdir);
matthijs@1247: 		}
matthijs@1247: 	} else {
tron@3167: 		DiagDirection dir;
tron@3167: 
matthijs@1247: 		if (IsTileType(desttile, MP_STREET)) {
rubidium@3793: 			if (GetRoadTileType(desttile) == ROAD_TILE_DEPOT) {
tron@3167: 				dir = GetRoadDepotDirection(desttile);
tron@3167: 				goto do_it;
tron@3167: 			}
matthijs@1247: 		} else if (IsTileType(desttile, MP_STATION)) {
tron@3338: 			if (IsRoadStop(desttile)) {
celestar@3404: 				dir = GetRoadStopDir(desttile);
truelight@0: do_it:;
matthijs@1247: 				/* When we are heading for a depot or station, we just
matthijs@1247: 				 * pretend we are heading for the tile in front, we'll
matthijs@1247: 				 * see from there */
Darkvater@4559: 				desttile += TileOffsByDiagDir(dir);
tron@3167: 				if (desttile == tile && bitmask & _road_pf_table_3[dir]) {
matthijs@1247: 					/* If we are already in front of the
matthijs@1247: 					 * station/depot and we can get in from here,
matthijs@1247: 					 * we enter */
tron@3167: 					return_track(FindFirstBit2x64(bitmask & _road_pf_table_3[dir]));
matthijs@1247: 				}
truelight@0: 			}
truelight@193: 		}
matthijs@1247: 		// do pathfind
matthijs@1247: 		frd.dest = desttile;
truelight@0: 
matthijs@1247: 		best_track = -1;
matthijs@1247: 		best_dist = (uint)-1;
matthijs@1247: 		best_maxlen = (uint)-1;
matthijs@1247: 		i = 0;
matthijs@1247: 		do {
matthijs@1247: 			if (bitmask & 1) {
matthijs@1247: 				if (best_track == -1) best_track = i; // in case we don't find the path, just pick a track
matthijs@1247: 				frd.maxtracklen = (uint)-1;
matthijs@1247: 				frd.mindist = (uint)-1;
celestar@3611: 				FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
truelight@0: 
matthijs@1247: 				if (frd.mindist < best_dist || (frd.mindist==best_dist && frd.maxtracklen < best_maxlen)) {
matthijs@1247: 					best_dist = frd.mindist;
matthijs@1247: 					best_maxlen = frd.maxtracklen;
matthijs@1247: 					best_track = i;
matthijs@1247: 				}
truelight@0: 			}
matthijs@1247: 		} while (++i,(bitmask>>=1) != 0);
matthijs@1247: 	}
truelight@0: 
truelight@0: found_best_track:;
truelight@0: 
tron@3017: 	if (HASBIT(signal, best_track)) return -1;
truelight@0: 
truelight@193: 	return best_track;
truelight@0: }
truelight@0: 
celestar@3123: static uint RoadFindPathToStop(const Vehicle *v, TileIndex tile)
celestar@1217: {
Darkvater@4271: 	uint dist;
KUDr@3915: 	if (_patches.yapf.road_use_yapf) {
KUDr@3915: 		// use YAPF
KUDr@3915: 		dist = YapfRoadVehDistanceToTile(v, tile);
KUDr@3915: 	} else {
KUDr@3915: 		// use NPF
KUDr@3915: 		NPFFindStationOrTileData fstd;
KUDr@3915: 		byte trackdir = GetVehicleTrackdir(v);
KUDr@3915: 		assert(trackdir != 0xFF);
celestar@1217: 
KUDr@3915: 		fstd.dest_coords = tile;
KUDr@3915: 		fstd.station_index = INVALID_STATION; // indicates that the destination is a tile, not a station
celestar@1217: 
KUDr@3915: 		dist = NPFRouteToStationOrTile(v->tile, trackdir, &fstd, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE).best_path_dist;
KUDr@3915: 		// change units from NPF_TILE_LENGTH to # of tiles
KUDr@3915: 		if (dist != UINT_MAX)
KUDr@3915: 			dist = (dist + NPF_TILE_LENGTH - 1) / NPF_TILE_LENGTH;
KUDr@3915: 	}
KUDr@3915: 	return dist;
celestar@1217: }
celestar@1217: 
truelight@0: typedef struct RoadDriveEntry {
truelight@0: 	byte x,y;
truelight@0: } RoadDriveEntry;
truelight@0: 
truelight@0: #include "table/roadveh.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: 
rubidium@4344: static const byte _roadveh_data_2[4] = { 0, 1, 8, 9 };
truelight@0: 
Darkvater@1401: static void RoadVehController(Vehicle *v)
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: 	// decrease counters
truelight@0: 	v->tick_counter++;
tron@3017: 	if (v->u.road.reverse_ctr != 0) v->u.road.reverse_ctr--;
truelight@0: 
truelight@0: 	// handle crashed
truelight@0: 	if (v->u.road.crashed_ctr != 0) {
truelight@0: 		RoadVehIsCrashed(v);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
truelight@0: 	RoadVehCheckTrainCrash(v);
truelight@0: 
truelight@0: 	// road vehicle has broken down?
truelight@0: 	if (v->breakdown_ctr != 0) {
truelight@0: 		if (v->breakdown_ctr <= 2) {
truelight@0: 			HandleBrokenRoadVeh(v);
truelight@0: 			return;
truelight@0: 		}
truelight@0: 		v->breakdown_ctr--;
truelight@0: 	}
truelight@0: 
celestar@3431: 	if (v->vehstatus & VS_STOPPED) return;
truelight@0: 
truelight@0: 	ProcessRoadVehOrder(v);
truelight@0: 	HandleRoadVehLoading(v);
truelight@0: 
tron@2951: 	if (v->current_order.type == OT_LOADING) return;
truelight@0: 
tron@3959: 	if (IsRoadVehInDepot(v)) {
tron@3153: 		DiagDirection dir;
tron@3033: 		const RoadDriveEntry* rdp;
truelight@0: 		byte rd2;
truelight@0: 
truelight@0: 		v->cur_speed = 0;
truelight@193: 
tron@3167: 		dir = GetRoadDepotDirection(v->tile);
tron@3153: 		v->direction = DiagDirToDir(dir);
truelight@0: 
truelight@0: 		rd2 = _roadveh_data_2[dir];
tron@3033: 		rdp = _road_drive_data[(_opt.road_side << 4) + rd2];
truelight@193: 
celestar@3421: 		x = TileX(v->tile) * TILE_SIZE + (rdp[6].x & 0xF);
celestar@3421: 		y = TileY(v->tile) * TILE_SIZE + (rdp[6].y & 0xF);
truelight@0: 
tron@3138: 		if (RoadVehFindCloseTo(v, x, y, v->direction) != NULL) return;
truelight@0: 
bjarni@578: 		VehicleServiceInDepot(v);
bjarni@578: 
truelight@0: 		StartRoadVehSound(v);
truelight@0: 
truelight@0: 		BeginVehicleMove(v);
truelight@0: 
truelight@0: 		v->vehstatus &= ~VS_HIDDEN;
truelight@0: 		v->u.road.state = rd2;
truelight@0: 		v->u.road.frame = 6;
truelight@193: 
truelight@0: 		v->cur_image = GetRoadVehImage(v, v->direction);
truelight@0: 		UpdateRoadVehDeltaXY(v);
truelight@0: 		SetRoadVehPosition(v,x,y);
truelight@0: 
bjarni@4739: 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@2951: 	if (!RoadVehAccelerate(v)) return;
truelight@0: 
truelight@0: 	if (v->u.road.overtaking != 0)  {
truelight@0: 		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
truelight@2823: 			 *  overtake if we are on straight road, which are the 8 states below */
truelight@2823: 			if (v->u.road.state == 0  || v->u.road.state == 1  ||
truelight@2823: 					v->u.road.state == 8  || v->u.road.state == 9  ||
truelight@2823: 					v->u.road.state == 16 || v->u.road.state == 17 ||
tron@3033: 					v->u.road.state == 24 || v->u.road.state == 25) {
truelight@2823: 				v->u.road.overtaking = 0;
tron@3033: 			}
truelight@0: 	}
truelight@0: 
truelight@0: 	BeginVehicleMove(v);
truelight@0: 
truelight@0: 	if (v->u.road.state == 255) {
tron@3138: 		GetNewVehiclePosResult gp;
tron@3138: 
truelight@0: 		GetNewVehiclePos(v, &gp);
truelight@0: 
tron@3138: 		if (RoadVehFindCloseTo(v, gp.x, gp.y, v->direction) != NULL) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			return;
truelight@0: 		}
truelight@0: 
celestar@5573: 		if ((IsTunnelTile(gp.new_tile) || IsBridgeTile(gp.new_tile)) && VehicleEnterTile(v, gp.new_tile, gp.x, gp.y) & 4) {
truelight@0: 			//new_dir = RoadGetNewDirection(v, gp.x, gp.y)
truelight@0: 			v->cur_image = GetRoadVehImage(v, v->direction);
truelight@0: 			UpdateRoadVehDeltaXY(v);
truelight@0: 			SetRoadVehPosition(v,gp.x,gp.y);
truelight@0: 			return;
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);
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@3033: 	rd = _road_drive_data[(v->u.road.state + (_opt.road_side << 4)) ^ v->u.road.overtaking][v->u.road.frame + 1];
truelight@0: 
truelight@0: // switch to another tile
truelight@0: 	if (rd.x & 0x80) {
Darkvater@4559: 		TileIndex tile = v->tile + TileOffsByDiagDir(rd.x & 3);
tron@3033: 		int dir = RoadFindPathToDest(v, tile, rd.x & 3);
truelight@0: 		uint32 r;
tron@3157: 		Direction newdir;
truelight@0: 		const RoadDriveEntry *rdp;
truelight@0: 
truelight@0: 		if (dir == -1) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			return;
truelight@0: 		}
truelight@0: 
truelight@0: again:
truelight@0: 		if ((dir & 7) >= 6) {
matthijs@1247: 			/* Turning around */
truelight@0: 			tile = v->tile;
truelight@0: 		}
truelight@0: 
truelight@2823: 		rdp = _road_drive_data[(dir + (_opt.road_side << 4)) ^ v->u.road.overtaking];
truelight@0: 
celestar@3421: 		x = TileX(tile) * TILE_SIZE + rdp[0].x;
celestar@3421: 		y = TileY(tile) * TILE_SIZE + rdp[0].y;
truelight@0: 
tron@3017: 		newdir = RoadVehGetSlidingDirection(v, x, y);
tron@3138: 		if (RoadVehFindCloseTo(v, x, y, newdir) != NULL) return;
truelight@0: 
truelight@0: 		r = VehicleEnterTile(v, tile, x, y);
truelight@0: 		if (r & 8) {
celestar@5590: 			if (!(IsTileType(tile, MP_TUNNEL) || IsTileType(tile, MP_STREET_BRIDGE))) {
truelight@0: 				v->cur_speed = 0;
truelight@0: 				return;
truelight@0: 			}
truelight@0: 			dir = _road_reverse_table[rd.x&3];
truelight@0: 			goto again;
truelight@0: 		}
truelight@0: 
tron@1035: 		if (IS_BYTE_INSIDE(v->u.road.state, 0x20, 0x30) && IsTileType(v->tile, MP_STATION)) {
tron@3033: 			if ((dir & 7) >= 6) {
tron@3033: 				v->cur_speed = 0;
tron@3033: 				return;
tron@3033: 			}
tron@3338: 			if (IsRoadStop(v->tile)) {
celestar@1217: 				RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
truelight@0: 
tron@3054: 				// reached a loading bay, mark it as used and clear the usage bit
tron@3054: 				SETBIT(rs->status, v->u.road.state & 2 ? 1 : 0); // occupied bay
tron@3054: 				CLRBIT(rs->status, 7); // usage bit
truelight@0: 			}
truelight@0: 		}
truelight@0: 
truelight@0: 		if (!(r & 4)) {
truelight@0: 			v->tile = tile;
truelight@2823: 			v->u.road.state = (byte)dir;
truelight@0: 			v->u.road.frame = 0;
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: 
truelight@0: 		v->cur_image = GetRoadVehImage(v, newdir);
truelight@0: 		UpdateRoadVehDeltaXY(v);
truelight@0: 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
truelight@0: 	if (rd.x & 0x40) {
rubidium@4434: 		int dir = RoadFindPathToDest(v, v->tile, rd.x & 3);
truelight@0: 		uint32 r;
truelight@0: 		int tmp;
tron@3157: 		Direction newdir;
truelight@0: 		const RoadDriveEntry *rdp;
truelight@0: 
truelight@0: 		if (dir == -1) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			return;
truelight@0: 		}
truelight@0: 
tron@3033: 		tmp = (_opt.road_side << 4) + dir;
truelight@0: 		rdp = _road_drive_data[tmp];
truelight@0: 
celestar@3421: 		x = TileX(v->tile) * TILE_SIZE + rdp[1].x;
celestar@3421: 		y = TileY(v->tile) * TILE_SIZE + rdp[1].y;
truelight@0: 
tron@3017: 		newdir = RoadVehGetSlidingDirection(v, x, y);
tron@3138: 		if (RoadVehFindCloseTo(v, x, y, newdir) != NULL) return;
truelight@0: 
truelight@0: 		r = VehicleEnterTile(v, v->tile, x, y);
truelight@0: 		if (r & 8) {
truelight@0: 			v->cur_speed = 0;
truelight@0: 			return;
truelight@0: 		}
truelight@0: 
truelight@0: 		v->u.road.state = tmp & ~16;
truelight@0: 		v->u.road.frame = 1;
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: 
truelight@0: 		v->cur_image = GetRoadVehImage(v, newdir);
truelight@0: 		UpdateRoadVehDeltaXY(v);
truelight@0: 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
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: 
tron@3138: 	if (!IS_BYTE_INSIDE(v->u.road.state, 0x20, 0x30)) {
tron@3138: 		Vehicle* u = RoadVehFindCloseTo(v, x, y, new_dir);
tron@3138: 
tron@3138: 		if (u != NULL) {
tron@3138: 			if (v->u.road.overtaking == 0) RoadVehCheckOvertake(v, u);
tron@3138: 			return;
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) {
truelight@0: 			v->cur_image = GetRoadVehImage(v, new_dir);
truelight@0: 			UpdateRoadVehDeltaXY(v);
truelight@0: 			SetRoadVehPosition(v, v->x_pos, v->y_pos);
truelight@0: 			return;
truelight@0: 		}
truelight@0: 	}
truelight@0: 
truelight@0: 	if (v->u.road.state >= 0x20 &&
truelight@0: 			_road_veh_data_1[v->u.road.state - 0x20 + (_opt.road_side<<4)] == v->u.road.frame) {
celestar@1217: 		RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
tron@3315: 		Station* st = GetStationByTile(v->tile);
truelight@0: 
tron@555: 		if (v->current_order.type != OT_LEAVESTATION &&
tron@555: 				v->current_order.type != OT_GOTO_DEPOT) {
tron@555: 			Order old_order;
truelight@193: 
tron@3054: 			CLRBIT(rs->status, 7);
truelight@0: 
tron@3315: 			v->last_station_visited = GetStationIndex(v->tile);
truelight@0: 
truelight@0: 			RoadVehArrivesAt(v, st);
truelight@0: 
tron@555: 			old_order = v->current_order;
tron@555: 			v->current_order.type = OT_LOADING;
tron@555: 			v->current_order.flags = 0;
truelight@0: 
tron@555: 			if (old_order.type == OT_GOTO_STATION &&
tron@4527: 					v->current_order.dest == v->last_station_visited) {
tron@555: 				v->current_order.flags =
celestar@1935: 					(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER)) | OF_NON_STOP;
truelight@0: 			}
truelight@0: 
truelight@0: 			SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);
peter1138@5211: 			if (LoadUnloadVehicle(v, true)) {
truelight@0: 				InvalidateWindow(WC_ROADVEH_LIST, v->owner);
truelight@0: 				MarkRoadVehDirty(v);
truelight@0: 			}
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 			return;
truelight@0: 		}
truelight@0: 
tron@555: 		if (v->current_order.type != OT_GOTO_DEPOT) {
tron@3054: 			if (HASBIT(rs->status, 7)) {
truelight@0: 				v->cur_speed = 0;
truelight@0: 				return;
truelight@0: 			}
tron@555: 			v->current_order.type = OT_NOTHING;
tron@555: 			v->current_order.flags = 0;
celestar@3123: 			ClearSlot(v);
truelight@0: 		}
tron@3054: 		SETBIT(rs->status, 7);
truelight@0: 
celestar@1217: 		if (rs == v->u.road.slot) {
celestar@1217: 			//we have arrived at the correct station
celestar@3123: 			ClearSlot(v);
celestar@1217: 		} else if (v->u.road.slot != NULL) {
celestar@1217: 			//we have arrived at the wrong station
celestar@1217: 			//XXX The question is .. what to do? Actually we shouldn't be here
celestar@1217: 			//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: 			}
celestar@3123: 			if (v->current_order.type != OT_GOTO_STATION) {
Darkvater@5568: 				DEBUG(ms, 2, " current order type (%d) is not OT_GOTO_STATION", v->current_order.type);
celestar@3123: 			} else {
tron@4527: 				if (v->current_order.dest != st->index)
Darkvater@5568: 					DEBUG(ms, 2, " current station %d is not target station in current_order.station (%d)",
tron@4527: 							st->index, v->current_order.dest);
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);
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 	}
truelight@0: 
truelight@0: 	r = VehicleEnterTile(v, v->tile, x, y);
truelight@0: 	if (r & 8) {
truelight@0: 		v->cur_speed = 0;
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@3017: 	if ((r & 4) == 0) v->u.road.frame++;
truelight@0: 
truelight@0: 	v->cur_image = GetRoadVehImage(v, v->direction);
truelight@0: 	UpdateRoadVehDeltaXY(v);
truelight@0: 	RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
truelight@0: }
truelight@0: 
truelight@0: static void AgeRoadVehCargo(Vehicle *v)
truelight@0: {
tron@3017: 	if (_age_cargo_skip_counter != 0) return;
tron@3017: 	if (v->cargo_days != 255) v->cargo_days++;
truelight@0: }
truelight@0: 
truelight@0: void RoadVeh_Tick(Vehicle *v)
truelight@0: {
truelight@0: 	AgeRoadVehCargo(v);
Darkvater@1401: 	RoadVehController(v);
truelight@0: }
truelight@0: 
truelight@0: static void CheckIfRoadVehNeedsService(Vehicle *v)
truelight@0: {
tron@3033: 	const Depot* depot;
truelight@0: 
tron@3017: 	if (_patches.servint_roadveh == 0) return;
tron@3017: 	if (!VehicleNeedsService(v)) return;
celestar@3431: 	if (v->vehstatus & VS_STOPPED) return;
tron@3017: 	if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;
truelight@193: 
truelight@0: 	// Don't interfere with a depot visit scheduled by the user, or a
truelight@0: 	// depot visit by the order list.
tron@555: 	if (v->current_order.type == OT_GOTO_DEPOT &&
celestar@1530: 			(v->current_order.flags & (OF_HALT_IN_DEPOT | OF_PART_OF_ORDERS)) != 0)
truelight@0: 		return;
truelight@0: 
tron@3017: 	// If we already got a slot at a stop, use that FIRST, and go to a depot later
tron@3017: 	if (v->u.road.slot != NULL) return;
celestar@1217: 
bjarni@4529: 	if (IsRoadVehInDepot(v)) {
bjarni@4529: 		VehicleServiceInDepot(v);
bjarni@4529: 		return;
bjarni@4529: 	}
bjarni@4529: 
celestar@3612: 	// XXX If we already have a depot order, WHY do we search over and over?
truelight@1313: 	depot = FindClosestRoadDepot(v);
truelight@0: 
truelight@1313: 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
bjarni@1520: 		if (v->current_order.type == OT_GOTO_DEPOT) {
tron@555: 			v->current_order.type = OT_DUMMY;
tron@555: 			v->current_order.flags = 0;
darkvater@755: 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: 		}
truelight@0: 		return;
truelight@0: 	}
truelight@0: 
tron@555: 	if (v->current_order.type == OT_GOTO_DEPOT &&
tron@555: 			v->current_order.flags & OF_NON_STOP &&
tron@3033: 			!CHANCE16(1, 20)) {
truelight@0: 		return;
tron@3033: 	}
truelight@0: 
tron@555: 	v->current_order.type = OT_GOTO_DEPOT;
tron@555: 	v->current_order.flags = OF_NON_STOP;
tron@4527: 	v->current_order.dest = depot->index;
truelight@1313: 	v->dest_tile = depot->xy;
darkvater@755: 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
truelight@0: }
truelight@0: 
truelight@0: void OnNewDay_RoadVeh(Vehicle *v)
truelight@0: {
truelight@0: 	int32 cost;
truelight@0: 
tron@3017: 	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
tron@3017: 	if (v->u.road.blocked_ctr == 0) CheckVehicleBreakdown(v);
truelight@0: 
truelight@0: 	AgeVehicle(v);
truelight@0: 	CheckIfRoadVehNeedsService(v);
truelight@0: 
tron@3140: 	CheckOrders(v);
dominik@19: 
celestar@3123: 	//Current slot has expired
tron@3481: 	if (v->current_order.type == OT_GOTO_STATION && v->u.road.slot != NULL && v->u.road.slot_age-- == 0) {
Darkvater@5568: 		DEBUG(ms, 3, "Slot expired for vehicle %d (index %d) at stop 0x%X",
celestar@3431: 			v->unitnumber, v->index, v->u.road.slot->xy);
celestar@3123: 		ClearSlot(v);
celestar@3123: 	}
celestar@3123: 
celestar@3236: 	if (v->vehstatus & VS_STOPPED) return;
celestar@3236: 
truelight@0: 	/* update destination */
celestar@3431: 	if (v->current_order.type == OT_GOTO_STATION && v->u.road.slot == NULL && !(v->vehstatus & VS_CRASHED)) {
tron@4527: 		Station* st = GetStation(v->current_order.dest);
tron@4077: 		RoadStop* rs = GetPrimaryRoadStop(st, v->cargo_type == CT_PASSENGERS ? RS_BUS : RS_TRUCK);
tron@4077: 		RoadStop* best = NULL;
celestar@1217: 
celestar@3123: 		if (rs != NULL) {
celestar@3123: 			if (DistanceManhattan(v->tile, st->xy) < 16) {
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)",
tron@4077: 					v->unitnumber, v->index, st->index, st->xy
tron@4077: 				);
celestar@3123: 				/* Now we find the nearest road stop that has a free slot */
celestar@3431: 				for (; rs != NULL; rs = rs->next) {
celestar@3431: 					dist = RoadFindPathToStop(v, 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: 
celestar@3431: 					v->u.road.slot = best;
celestar@3431: 					v->dest_tile = best->xy;
celestar@3431: 					v->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)",
celestar@3123: 						v->unitnumber, v->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)",
celestar@3123: 					v->unitnumber, v->index, st->index, st->xy);
celestar@1217: 		}
truelight@0: 	}
truelight@0: 
tron@538: 	cost = RoadVehInfo(v->engine_type)->running_cost * _price.roadveh_running / 364;
truelight@0: 
truelight@0: 	v->profit_this_year -= cost >> 8;
truelight@0: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN);
truelight@0: 	SubtractMoneyFromPlayerFract(v->owner, cost);
truelight@0: 
truelight@0: 	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
bjarni@1151: 	InvalidateWindowClasses(WC_ROADVEH_LIST);
truelight@0: }
truelight@0: 
truelight@0: 
tron@1093: void RoadVehiclesYearlyLoop(void)
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 
truelight@0: 	FOR_ALL_VEHICLES(v) {
truelight@0: 		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
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
peter1138@3990:  */
peter1138@3990: int32 CmdRefitRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
peter1138@3990: {
peter1138@3990: 	Vehicle *v;
peter1138@3990: 	int32 cost;
peter1138@3990: 	CargoID new_cid = GB(p2, 0, 8);
peter1138@3990: 	byte new_subtype = GB(p2, 8, 8);
peter1138@3990: 	uint16 capacity = CALLBACK_FAILED;
peter1138@3990: 
truelight@4352: 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
peter1138@3990: 
peter1138@3990: 	v = GetVehicle(p1);
peter1138@3990: 
peter1138@3990: 	if (v->type != VEH_Road || !CheckOwnership(v->owner)) return CMD_ERROR;
peter1138@3990: 	if (!IsRoadVehInDepotStopped(v)) return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
peter1138@3990: 
peter1138@3990: 	if (new_cid > NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;
peter1138@3990: 
peter1138@3990: 	SET_EXPENSES_TYPE(EXPENSES_ROADVEH_RUN);
peter1138@3990: 
peter1138@3990: 	if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_REFIT_CAPACITY)) {
peter1138@3990: 		/* Back up the cargo type */
peter1138@3990: 		CargoID temp_cid = v->cargo_type;
peter1138@3990: 		byte temp_subtype = v->cargo_subtype;
peter1138@3990: 		v->cargo_type = new_cid;
peter1138@3990: 		v->cargo_subtype = new_subtype;
peter1138@3990: 
peter1138@3990: 		/* Check the refit capacity callback */
peter1138@3990: 		capacity = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, v->engine_type, v);
peter1138@3990: 
peter1138@3990: 		/* Restore the original cargo type */
peter1138@3990: 		v->cargo_type = temp_cid;
peter1138@3990: 		v->cargo_subtype = temp_subtype;
peter1138@3990: 	}
peter1138@3990: 
peter1138@3990: 	if (capacity == CALLBACK_FAILED) {
peter1138@3990: 		/* callback failed or not used, use default capacity */
peter1138@3990: 		const RoadVehicleInfo *rvi = RoadVehInfo(v->engine_type);
peter1138@3990: 
peter1138@3990: 		CargoID old_cid = rvi->cargo_type;
peter1138@3990: 		/* normally, the capacity depends on the cargo type, a vehicle can
peter1138@3990: 		 * carry twice as much mail/goods as normal cargo, and four times as
peter1138@3990: 		 * many passengers
peter1138@3990: 		 */
peter1138@3990: 		capacity = rvi->capacity;
peter1138@3990: 		switch (old_cid) {
peter1138@3990: 			case CT_PASSENGERS: break;
peter1138@3990: 			case CT_MAIL:
peter1138@3990: 			case CT_GOODS: capacity *= 2; break;
peter1138@3990: 			default:       capacity *= 4; break;
peter1138@3990: 		}
peter1138@3990: 		switch (new_cid) {
peter1138@3990: 			case CT_PASSENGERS: break;
peter1138@3990: 			case CT_MAIL:
peter1138@3990: 			case CT_GOODS: capacity /= 2; break;
peter1138@3990: 			default:       capacity /= 4; break;
peter1138@3990: 		}
peter1138@3990: 	}
peter1138@3990: 	_returned_refit_capacity = capacity;
peter1138@3990: 
peter1138@3990: 	cost = 0;
Darkvater@4845: 	if (IsHumanPlayer(v->owner) && new_cid != v->cargo_type) {
bjarni@4544: 		cost = GetRefitCost(v->engine_type);
peter1138@3990: 	}
peter1138@3990: 
peter1138@3990: 	if (flags & DC_EXEC) {
peter1138@3990: 		v->cargo_cap = capacity;
peter1138@3990: 		v->cargo_count = (v->cargo_type == new_cid) ? min(capacity, v->cargo_count) : 0;
peter1138@3990: 		v->cargo_type = new_cid;
peter1138@3990: 		v->cargo_subtype = new_subtype;
peter1138@3990: 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
peter1138@3990: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
peter1138@3990: 		RebuildVehicleLists();
peter1138@3990: 	}
peter1138@3990: 
peter1138@3990: 	return cost;
peter1138@3990: }