openttd-ottdgrfs: comparison src/roadveh

equal deleted inserted replaced

-:5a8b295aa345
+:4cc327ad39d5
 /* $Id$ */
+/** @file roadveh_cmd.cpp */
 #include "stdafx.h"
 #include "openttd.h"
 #include "debug.h"
 #include "functions.h"
+#include "landscape.h"
 #include "road_map.h"
 #include "roadveh.h"
 #include "station_map.h"
 #include "table/strings.h"
 #include "map.h"
 	DrawSprite(6 + _roadveh_images[spritenum], pal, x, y);
 }
 static int32 EstimateRoadVehCost(EngineID engine_type)
 {
-	return ((_price.roadveh_base >> 3) * RoadVehInfo(engine_type)->base_cost) >> 5;
+	return ((_price.roadveh_base >> 3) * GetEngineProperty(engine_type, 0x11, RoadVehInfo(engine_type)->base_cost)) >> 5;
 }
 /** Build a road vehicle.
 * @param tile tile of depot where road vehicle is built
+* @param flags operation to perform
 * @param p1 bus/truck type being built (engine)
 * @param p2 bit 0 when set, the unitnumber will be 0, otherwise it will be a free number
 */
 int32 CmdBuildRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	int32 cost;
 	Vehicle *v;
 	UnitID unit_num;
 	Engine *e;
-	if (!IsEngineBuildable(p1, VEH_ROAD, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);
+	if (!IsEngineBuildable(p1, VEH_ROAD, _current_player)) return_cmd_error(STR_ROAD_VEHICLE_NOT_AVAILABLE);
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	cost = EstimateRoadVehCost(p1);
 	if (flags & DC_QUERY_COST) return cost;
 	/* The ai_new queries the vehicle cost before building the route,
 	 * so we must check against cheaters no sooner than now. --pasky */
 	if (!IsTileDepotType(tile, TRANSPORT_ROAD)) return CMD_ERROR;
 	if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
+	if (HASBIT(GetRoadTypes(tile), ROADTYPE_TRAM) != HASBIT(EngInfo(p1)->misc_flags, EF_ROAD_TRAM)) return_cmd_error(STR_DEPOT_WRONG_DEPOT_TYPE);
 	v = AllocateVehicle();
 	if (v == NULL) return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 	/* find the first free roadveh id */
 		v->tile = tile;
 		x = TileX(tile) * TILE_SIZE + TILE_SIZE / 2;
 		y = TileY(tile) * TILE_SIZE + TILE_SIZE / 2;
 		v->x_pos = x;
 		v->y_pos = y;
-		v->z_pos = GetSlopeZ(x,y);
+		v->z_pos = GetSlopeZ(x, y);
-		v->z_height = 6;
 		v->u.road.state = RVSB_IN_DEPOT;
-		v->vehstatus = VS_HIDDEN|VS_STOPPED|VS_DEFPAL;
+		v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
 		v->spritenum = rvi->image_index;
 		v->cargo_type = rvi->cargo_type;
 		v->cargo_subtype = 0;
 		v->cargo_cap = rvi->capacity;
 		v->last_station_visited = INVALID_STATION;
 		v->max_speed = rvi->max_speed;
 		v->engine_type = (byte)p1;
+		v->u.road.roadtype = HASBIT(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
+		v->u.road.compatible_roadtypes = RoadTypeToRoadTypes(v->u.road.roadtype);
 		e = GetEngine(p1);
 		v->reliability = e->reliability;
 		v->reliability_spd_dec = e->reliability_spd_dec;
 		v->max_age = e->lifelength * 366;
 		_new_vehicle_id = v->index;
 		v->service_interval = _patches.servint_roadveh;
 		v->date_of_last_service = _date;
 		v->build_year = _cur_year;
-		v->type = VEH_ROAD;
+		v = new (v) RoadVehicle();
 		v->cur_image = 0xC15;
 		v->random_bits = VehicleRandomBits();
 		v->vehicle_flags = 0;
 		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
+		v->cargo_cap = GetVehicleProperty(v, 0x0F, rvi->capacity);
 		VehiclePositionChanged(v);
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 		RebuildVehicleLists();
 	return cost;
 }
 /** Start/Stop a road vehicle.
 * @param tile unused
+* @param flags operation to perform
 * @param p1 road vehicle ID to start/stop
 * @param p2 unused
 */
 int32 CmdStartStopRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 		if (IsRoadVehInDepotStopped(v)) {
 			DeleteVehicleNews(p1, STR_9016_ROAD_VEHICLE_IS_WAITING);
 		}
 		v->vehstatus ^= VS_STOPPED;
+		v->cur_speed = 0;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 	}
 	return 0;
 	DEBUG(ms, 3, "Clearing slot at 0x%X", rs->xy);
 }
 /** Sell a road vehicle.
 * @param tile unused
+* @param flags operation to perform
 * @param p1 vehicle ID to be sold
 * @param p2 unused
 */
 int32 CmdSellRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	} else if (_patches.new_pathfinding_all) {
 		NPFFoundTargetData ftd;
 		/* See where we are now */
 		Trackdir trackdir = GetVehicleTrackdir(v);
-		ftd = NPFRouteToDepotBreadthFirst(v->tile, trackdir, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE);
+		ftd = NPFRouteToDepotBreadthFirst(v->tile, trackdir, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE);
 		if (ftd.best_bird_dist == 0) {
 			return GetDepotByTile(ftd.node.tile); /* Target found */
 		} else {
 			return NULL; /* Target not found */
 		}
 		rfdd.owner = v->owner;
 		rfdd.best_length = (uint)-1;
 		/* search in all directions */
 		for (DiagDirection i = DIAGDIR_BEGIN; i != DIAGDIR_END; i++) {
-			FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, i, EnumRoadSignalFindDepot, NULL, &rfdd);
+			FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, v->u.road.compatible_roadtypes, i, EnumRoadSignalFindDepot, NULL, &rfdd);
 		}
 		if (rfdd.best_length == (uint)-1) return NULL;
 		return GetDepotByTile(rfdd.tile);
 	}
 }
 /** Send a road vehicle to the depot.
 * @param tile unused
+* @param flags operation to perform
 * @param p1 vehicle ID to send to the depot
 * @param p2 various bitmasked elements
 * - p2 bit 0-3 - DEPOT_ flags (see vehicle.h)
 * - p2 bit 8-10 - VLW flag (for mass goto depot)
 */
 	dep = FindClosestRoadDepot(v);
 	if (dep == NULL) return_cmd_error(STR_9019_UNABLE_TO_FIND_LOCAL_DEPOT);
 	if (flags & DC_EXEC) {
+		if (v->current_order.type == OT_LOADING) v->LeaveStation();
 		ClearSlot(v);
 		v->current_order.type = OT_GOTO_DEPOT;
 		v->current_order.flags = OF_NON_STOP;
 		if (!(p2 & DEPOT_SERVICE)) SETBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
 		v->current_order.refit_cargo = CT_INVALID;
 	return 0;
 }
 /** Turn a roadvehicle around.
 * @param tile unused
+* @param flags operation to perform
 * @param p1 vehicle ID to turn
 * @param p2 unused
 */
 int32 CmdTurnRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	v = GetVehicle(p1);
 	if (v->type != VEH_ROAD || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_STOPPED ||
+			v->u.road.roadtype == ROADTYPE_TRAM ||
 			v->u.road.crashed_ctr != 0 ||
 			v->breakdown_ctr != 0 ||
 			v->u.road.overtaking != 0 ||
 			v->u.road.state == RVSB_WORMHOLE ||
 			IsRoadVehInDepot(v) ||
 			v->cur_speed < 5) {
 		return CMD_ERROR;
 	}
+	if (IsTileType(v->tile, MP_STREET) && GetRoadTileType(v->tile) == ROAD_TILE_NORMAL && GetDisallowedRoadDirections(v->tile) != DRD_NONE) return CMD_ERROR;
 	if (IsTunnelTile(v->tile) && DirToDiagDir(v->direction) == GetTunnelDirection(v->tile)) return CMD_ERROR;
 	if (IsBridgeTile(v->tile) && DirToDiagDir(v->direction) == GetBridgeRampDirection(v->tile)) return CMD_ERROR;
 	if (flags & DC_EXEC) v->u.road.reverse_ctr = 180;
 	return 0;
 }
-static void MarkRoadVehDirty(Vehicle *v)
+void RoadVehicle::MarkDirty()
 {
-	v->cur_image = GetRoadVehImage(v, v->direction);
+	this->cur_image = GetRoadVehImage(this, this->direction);
-	MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+	MarkAllViewportsDirty(this->left_coord, this->top_coord, this->right_coord + 1, this->bottom_coord + 1);
 }
-static void UpdateRoadVehDeltaXY(Vehicle *v)
+void RoadVehicle::UpdateDeltaXY(Direction direction)
 {
-#define MKIT(a,b,c,d) ((a&0xFF)<<24) | ((b&0xFF)<<16) | ((c&0xFF)<<8) | ((d&0xFF)<<0)
+#define MKIT(a, b, c, d) ((a & 0xFF) << 24) | ((b & 0xFF) << 16) | ((c & 0xFF) << 8) | ((d & 0xFF) << 0)
 	static const uint32 _delta_xy_table[8] = {
 		MKIT(3, 3, -1, -1),
 		MKIT(3, 7, -1, -3),
 		MKIT(3, 3, -1, -1),
 		MKIT(7, 3, -3, -1),
 		MKIT(3, 7, -1, -3),
 		MKIT(3, 3, -1, -1),
 		MKIT(7, 3, -3, -1),
 	};
 #undef MKIT
-	uint32 x = _delta_xy_table[v->direction];
-	v->x_offs        = GB(x,  0, 8);
+	uint32 x = _delta_xy_table[direction];
-	v->y_offs        = GB(x,  8, 8);
+	this->x_offs        = GB(x,  0, 8);
-	v->sprite_width  = GB(x, 16, 8);
+	this->y_offs        = GB(x,  8, 8);
-	v->sprite_height = GB(x, 24, 8);
+	this->sprite_width  = GB(x, 16, 8);
+	this->sprite_height = GB(x, 24, 8);
+	this->z_height      = 6;
 }
 static void ClearCrashedStation(Vehicle *v)
 {
 	RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
 static byte SetRoadVehPosition(Vehicle *v, int x, int y)
 {
 	byte new_z, old_z;
-	// need this hint so it returns the right z coordinate on bridges.
+	/* need this hint so it returns the right z coordinate on bridges. */
 	v->x_pos = x;
 	v->y_pos = y;
 	new_z = GetSlopeZ(x, y);
 	old_z = v->z_pos;
 	uint32 r = Random();
 	v->direction = ChangeDir(v->direction, delta[r & 3]);
 	BeginVehicleMove(v);
-	UpdateRoadVehDeltaXY(v);
+	v->UpdateDeltaXY(v->direction);
 	v->cur_image = GetRoadVehImage(v, v->direction);
 	SetRoadVehPosition(v, v->x_pos, v->y_pos);
 }
 static void RoadVehIsCrashed(Vehicle *v)
 {
 	const Order *order;
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
-			// Let a depot order in the orderlist interrupt.
+			/* Let a depot order in the orderlist interrupt. */
 			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;
 			if (v->current_order.flags & OF_SERVICE_IF_NEEDED &&
 					!VehicleNeedsService(v)) {
 				v->cur_order_index++;
 			}
 			rs = GetStation(order->dest)->GetPrimaryRoadStop(
 				IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK
 			);
+			TileIndex dest = INVALID_TILE;
 			if (rs != NULL) {
-				TileIndex dest = rs->xy;
+				uint mindist = MAX_UVALUE(uint);
-				uint mindist = DistanceManhattan(v->tile, rs->xy);
+				for (; rs != NULL; rs = rs->next) {
-				for (rs = rs->next; rs != NULL; rs = rs->next) {
+					/* The vehicle cannot go to this roadstop */
+					if ((GetRoadTypes(rs->xy) & v->u.road.compatible_roadtypes) == ROADTYPES_NONE) continue;
 					uint dist = DistanceManhattan(v->tile, rs->xy);
 					if (dist < mindist) {
 						mindist = dist;
 						dest = rs->xy;
 					}
 				}
-				v->dest_tile = dest;
+			}
+			if (dest != INVALID_TILE) {
+					v->dest_tile = dest;
 			} else {
-				// There is no stop left at the station, so don't even TRY to go there
+				/* There is no stop left at the station, so don't even TRY to go there */
 				v->cur_order_index++;
 				v->dest_tile = 0;
 			}
 			break;
 		}
 		default:
 			v->dest_tile = 0;
 			break;
 	}
-	InvalidateVehicleOrder(v);
-}
-static void HandleRoadVehLoading(Vehicle *v)
-{
-	switch (v->current_order.type) {
-		case OT_LOADING: {
-			Order b;
-			if (--v->load_unload_time_rem != 0) return;
-			if (CanFillVehicle(v) && (v->current_order.flags & OF_FULL_LOAD ||
-					(_patches.gradual_loading && !HASBIT(v->vehicle_flags, VF_LOADING_FINISHED)))) {
-				SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);
-				if (LoadUnloadVehicle(v, false)) {
-					InvalidateWindow(WC_ROADVEH_LIST, v->owner);
-					MarkRoadVehDirty(v);
-				}
-				return;
-			}
-			b = v->current_order;
-			v->LeaveStation();
-			if (!(b.flags & OF_NON_STOP)) return;
-			break;
-		}
-		case OT_DUMMY: break;
-		default: return;
-	}
-	v->cur_order_index++;
 	InvalidateVehicleOrder(v);
 }
 static void StartRoadVehSound(const Vehicle* v)
 {
 	rvf.y = y;
 	rvf.dir = dir;
 	rvf.veh = v;
 	u = (Vehicle*)VehicleFromPos(TileVirtXY(x, y), &rvf, EnumCheckRoadVehClose);
-	// This code protects a roadvehicle from being blocked for ever
+	/* This code protects a roadvehicle from being blocked for ever
-	//  If more than 1480 / 74 days a road vehicle is blocked, it will
+	 * If more than 1480 / 74 days a road vehicle is blocked, it will
-	//  drive just through it. The ultimate backup-code of TTD.
+	 * drive just through it. The ultimate backup-code of TTD.
-	// It can be disabled.
+	 * It can be disabled. */
 	if (u == NULL) {
 		v->u.road.blocked_ctr = 0;
 		return NULL;
 	}
 			st->had_vehicle_of_type |= HVOT_BUS;
 			SetDParam(0, st->index);
 			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);
 			AddNewsItem(
-				STR_902F_CITIZENS_CELEBRATE_FIRST,
+				v->u.road.roadtype == ROADTYPE_ROAD ? STR_902F_CITIZENS_CELEBRATE_FIRST : STR_902F_CITIZENS_CELEBRATE_FIRST_TRAM,
 				flags,
 				v->index,
 				0);
 		}
 	} else {
 			st->had_vehicle_of_type |= HVOT_TRUCK;
 			SetDParam(0, st->index);
 			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);
 			AddNewsItem(
-				STR_9030_CITIZENS_CELEBRATE_FIRST,
+				v->u.road.roadtype == ROADTYPE_ROAD ? STR_9030_CITIZENS_CELEBRATE_FIRST : STR_9030_CITIZENS_CELEBRATE_FIRST_TRAM,
 				flags,
 				v->index,
 				0
 			);
 		}
 static bool RoadVehAccelerate(Vehicle *v)
 {
 	uint spd = v->cur_speed + 1 + (v->u.road.overtaking != 0 ? 1 : 0);
 	byte t;
-	// Clamp
+	/* Clamp */
 	spd = min(spd, v->max_speed);
 	if (v->u.road.state == RVSB_WORMHOLE && !(v->vehstatus & VS_HIDDEN)) {
 		spd = min(spd, GetBridge(GetBridgeType(v->tile))->speed * 2);
 	}
-	//updates statusbar only if speed have changed to save CPU time
+	/* updates statusbar only if speed have changed to save CPU time */
 	if (spd != v->cur_speed) {
 		v->cur_speed = spd;
 		if (_patches.vehicle_speed) {
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		}
 	}
-	// Decrease somewhat when turning
+	/* Decrease somewhat when turning */
 	if (!(v->direction & 1)) spd = spd * 3 >> 2;
 	if (spd == 0) return false;
 	if ((byte)++spd == 0) return true;
 static bool FindRoadVehToOvertake(OvertakeData *od)
 {
 	uint32 bits;
-	bits = GetTileTrackStatus(od->tile, TRANSPORT_ROAD) & 0x3F;
+	bits = GetTileTrackStatus(od->tile, TRANSPORT_ROAD, od->v->u.road.compatible_roadtypes) & 0x3F;
 	if (!(od->tilebits & bits) || (bits & 0x3C) || (bits & 0x3F3F0000))
 		return true;
 	return VehicleFromPos(od->tile, od, EnumFindVehToOvertake) != NULL;
 }
 			!(u->vehstatus & VS_STOPPED) &&
 			u->cur_speed != 0) {
 		return;
 	}
+	/* Trams can't overtake other trams */
+	if (v->u.road.roadtype == ROADTYPE_TRAM) return;
 	if (v->direction != u->direction || !(v->direction & 1)) return;
 	/* Check if vehicle is in a road stop, depot, tunnel or bridge or not on a straight road */
 	if (v->u.road.state >= RVSB_IN_ROAD_STOP || !IsStraightRoadTrackdir((Trackdir)(v->u.road.state & RVSB_TRACKDIR_MASK))) return;
-	tt = GetTileTrackStatus(v->tile, TRANSPORT_ROAD) & 0x3F;
+	tt = GetTileTrackStatus(v->tile, TRANSPORT_ROAD, v->u.road.compatible_roadtypes) & 0x3F;
 	if ((tt & 3) == 0) return;
 	if ((tt & 0x3C) != 0) return;
 	if (tt == 3) tt = (v->direction & 2) ? 2 : 1;
 	od.tilebits = tt;
 		frd->mindist = dist;
 	}
 	return false;
 }
-static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, Owner owner, RailTypeMask railtypes)
+static inline NPFFoundTargetData PerfNPFRouteToStationOrTile(TileIndex tile, Trackdir trackdir, NPFFindStationOrTileData* target, TransportType type, uint sub_type, Owner owner, RailTypeMask railtypes)
 {
 	void* perf = NpfBeginInterval();
-	NPFFoundTargetData ret = NPFRouteToStationOrTile(tile, trackdir, target, type, owner, railtypes);
+	NPFFoundTargetData ret = NPFRouteToStationOrTile(tile, trackdir, target, type, sub_type, owner, railtypes);
 	int t = NpfEndInterval(perf);
 	DEBUG(yapf, 4, "[NPFR] %d us - %d rounds - %d open - %d closed -- ", t, 0, _aystar_stats_open_size, _aystar_stats_closed_size);
 	return ret;
 }
 /**
 * Returns direction to for a road vehicle to take or
 * INVALID_TRACKDIR if the direction is currently blocked
-* @param v        the vehicle to do the pathfinding for
+* @param v        the Vehicle to do the pathfinding for
 * @param tile     the where to start the pathfinding
 * @param enterdir the direction the vehicle enters the tile from
-* @return the trackdir to take
+* @return the Trackdir to take
 */
 static Trackdir RoadFindPathToDest(Vehicle* v, TileIndex tile, DiagDirection enterdir)
 {
 #define return_track(x) { best_track = (Trackdir)x; goto found_best_track; }
 	TileIndex desttile;
 	FindRoadToChooseData frd;
 	Trackdir best_track;
-	uint32 r  = GetTileTrackStatus(tile, TRANSPORT_ROAD);
+	uint32 r  = GetTileTrackStatus(tile, TRANSPORT_ROAD, v->u.road.compatible_roadtypes);
 	TrackdirBits signal    = (TrackdirBits)GB(r, 16, 16);
 	TrackdirBits trackdirs = (TrackdirBits)GB(r,  0, 16);
 	if (IsTileType(tile, MP_STREET)) {
-		if (GetRoadTileType(tile) == ROAD_TILE_DEPOT && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir)) {
+		if (GetRoadTileType(tile) == ROAD_TILE_DEPOT && (!IsTileOwner(tile, v->owner) || GetRoadDepotDirection(tile) == enterdir || (GetRoadTypes(tile) & v->u.road.compatible_roadtypes) == 0)) {
 			/* Road depot owned by another player or with the wrong orientation */
 			trackdirs = TRACKDIR_BIT_NONE;
 		}
 	} else if (IsTileType(tile, MP_STATION) && IsStandardRoadStopTile(tile)) {
 		/* Standard road stop (drive-through stops are treated as normal road) */
 		NPFFillWithOrderData(&fstd, v);
 		trackdir = DiagdirToDiagTrackdir(enterdir);
 		//debug("Finding path. Enterdir: %d, Trackdir: %d", enterdir, trackdir);
-		ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE);
+		ftd = PerfNPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE);
 		if (ftd.best_trackdir == INVALID_TRACKDIR) {
-			/* We are already at our target. Just do something */
+			/* We are already at our target. Just do something
-			//TODO: maybe display error?
+			 * @todo: maybe display error?
-			//TODO: go straight ahead if possible?
+			 * @todo: go straight ahead if possible? */
 			return_track(FindFirstBit2x64(trackdirs));
 		} else {
 			/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
 			the direction we need to take to get there, if ftd.best_bird_dist is not 0,
 			we did not find our target, but ftd.best_trackdir contains the direction leading
 		for (int i = 0; bitmask != 0; bitmask >>= 1, i++) {
 			if (HASBIT(bitmask, 0)) {
 				if (best_track == INVALID_TRACKDIR) best_track = (Trackdir)i; // in case we don't find the path, just pick a track
 				frd.maxtracklen = (uint)-1;
 				frd.mindist = (uint)-1;
-				FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
+				FollowTrack(tile, 0x2000 | TRANSPORT_ROAD, v->u.road.compatible_roadtypes, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
 				if (frd.mindist < best_dist || (frd.mindist == best_dist && frd.maxtracklen < best_maxlen)) {
 					best_dist = frd.mindist;
 					best_maxlen = frd.maxtracklen;
 					best_track = (Trackdir)i;
 static uint RoadFindPathToStop(const Vehicle *v, TileIndex tile)
 {
 	uint dist;
 	if (_patches.yapf.road_use_yapf) {
-		// use YAPF
+		/* use YAPF */
 		dist = YapfRoadVehDistanceToTile(v, tile);
 	} else {
-		// use NPF
+		/* use NPF */
 		NPFFindStationOrTileData fstd;
 		Trackdir trackdir = GetVehicleTrackdir(v);
 		assert(trackdir != INVALID_TRACKDIR);
 		fstd.dest_coords = tile;
 		fstd.station_index = INVALID_STATION; // indicates that the destination is a tile, not a station
-		dist = NPFRouteToStationOrTile(v->tile, trackdir, &fstd, TRANSPORT_ROAD, v->owner, INVALID_RAILTYPE).best_path_dist;
+		dist = NPFRouteToStationOrTile(v->tile, trackdir, &fstd, TRANSPORT_ROAD, v->u.road.compatible_roadtypes, v->owner, INVALID_RAILTYPE).best_path_dist;
-		// change units from NPF_TILE_LENGTH to # of tiles
+		/* change units from NPF_TILE_LENGTH to # of tiles */
 		if (dist != UINT_MAX)
 			dist = (dist + NPF_TILE_LENGTH - 1) / NPF_TILE_LENGTH;
 	}
 	return dist;
 }
 	Direction old_dir;
 	RoadDriveEntry rd;
 	int x,y;
 	uint32 r;
-	// decrease counters
+	/* decrease counters */
 	v->tick_counter++;
 	if (v->u.road.reverse_ctr != 0) v->u.road.reverse_ctr--;
-	// handle crashed
+	/* handle crashed */
 	if (v->u.road.crashed_ctr != 0) {
 		RoadVehIsCrashed(v);
 		return;
 	}
 	RoadVehCheckTrainCrash(v);
-	// road vehicle has broken down?
+	/* road vehicle has broken down? */
 	if (v->breakdown_ctr != 0) {
 		if (v->breakdown_ctr <= 2) {
 			HandleBrokenRoadVeh(v);
 			return;
 		}
 	}
 	if (v->vehstatus & VS_STOPPED) return;
 	ProcessRoadVehOrder(v);
-	HandleRoadVehLoading(v);
+	v->HandleLoading();
 	if (v->current_order.type == OT_LOADING) return;
 	if (IsRoadVehInDepot(v)) {
 		/* Vehicle is about to leave a depot */
 		dir = GetRoadDepotDirection(v->tile);
 		v->direction = DiagDirToDir(dir);
 		tdir = _roadveh_depot_exit_trackdir[dir];
-		rdp = _road_drive_data[(_opt.road_side << RVS_DRIVE_SIDE) + tdir];
+		rdp = _road_drive_data[v->u.road.roadtype][(_opt.road_side << RVS_DRIVE_SIDE) + tdir];
 		x = TileX(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].x & 0xF);
 		y = TileY(v->tile) * TILE_SIZE + (rdp[RVC_DEPOT_START_FRAME].y & 0xF);
 		if (RoadVehFindCloseTo(v, x, y, v->direction) != NULL) return;
 		v->vehstatus &= ~VS_HIDDEN;
 		v->u.road.state = tdir;
 		v->u.road.frame = RVC_DEPOT_START_FRAME;
 		v->cur_image = GetRoadVehImage(v, v->direction);
-		UpdateRoadVehDeltaXY(v);
+		v->UpdateDeltaXY(v->direction);
 		SetRoadVehPosition(v,x,y);
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 		return;
 	}
 		}
 		if ((IsTunnelTile(gp.new_tile) || IsBridgeTile(gp.new_tile)) && HASBIT(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
 			/* Vehicle has just entered a bridge or tunnel */
 			v->cur_image = GetRoadVehImage(v, v->direction);
-			UpdateRoadVehDeltaXY(v);
+			v->UpdateDeltaXY(v->direction);
 			SetRoadVehPosition(v,gp.x,gp.y);
 			return;
 		}
 		v->x_pos = gp.x;
 	}
 	/* Get move position data for next frame.
 	 * For a drive-through road stop use 'straight road' move data.
 	 * In this case v->u.road.state is masked to give the road stop entry direction. */
-	rd = _road_drive_data[(
+	rd = _road_drive_data[v->u.road.roadtype][(
 		(HASBIT(v->u.road.state, RVS_IN_DT_ROAD_STOP) ? v->u.road.state & RVSB_ROAD_STOP_TRACKDIR_MASK : v->u.road.state) +
 		(_opt.road_side << RVS_DRIVE_SIDE)) ^ v->u.road.overtaking][v->u.road.frame + 1];
 	if (rd.x & RDE_NEXT_TILE) {
 		TileIndex tile = v->tile + TileOffsByDiagDir(rd.x & 3);
 		}
 again:
 		if (IsReversingRoadTrackdir(dir)) {
 			/* Turning around */
-			tile = v->tile;
+			if (v->u.road.roadtype == ROADTYPE_TRAM) {
+				RoadBits needed; // The road bits the tram needs to be able to turn around
+				switch (dir) {
+					default: NOT_REACHED();
+					case TRACKDIR_RVREV_NE: needed = ROAD_SW; break;
+					case TRACKDIR_RVREV_SE: needed = ROAD_NW; break;
+					case TRACKDIR_RVREV_SW: needed = ROAD_NE; break;
+					case TRACKDIR_RVREV_NW: needed = ROAD_SE; break;
+				}
+				if (!IsTileType(tile, MP_STREET) || GetRoadTileType(tile) != ROAD_TILE_NORMAL || (needed & GetRoadBits(tile, ROADTYPE_TRAM)) == ROAD_NONE) {
+					/* The tram cannot turn here */
+					v->cur_speed = 0;
+					return;
+				}
+			} else if (IsTileType(v->tile, MP_STREET) && GetRoadTileType(v->tile) == ROAD_TILE_NORMAL && GetDisallowedRoadDirections(v->tile) != DRD_NONE) {
+				v->cur_speed = 0;
+				return;
+			} else {
+				tile = v->tile;
+			}
 		}
 		/* Get position data for first frame on the new tile */
-		rdp = _road_drive_data[(dir + (_opt.road_side << RVS_DRIVE_SIDE)) ^ v->u.road.overtaking];
+		rdp = _road_drive_data[v->u.road.roadtype][(dir + (_opt.road_side << RVS_DRIVE_SIDE)) ^ v->u.road.overtaking];
 		x = TileX(tile) * TILE_SIZE + rdp[RVC_DEFAULT_START_FRAME].x;
 		y = TileY(tile) * TILE_SIZE + rdp[RVC_DEFAULT_START_FRAME].y;
 		newdir = RoadVehGetSlidingDirection(v, x, y);
 			v->direction = newdir;
 			v->cur_speed -= v->cur_speed >> 2;
 		}
 		v->cur_image = GetRoadVehImage(v, newdir);
-		UpdateRoadVehDeltaXY(v);
+		v->UpdateDeltaXY(v->direction);
 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
 		return;
 	}
 	if (rd.x & RDE_TURNED) {
 		if (dir == INVALID_TRACKDIR) {
 			v->cur_speed = 0;
 			return;
 		}
-		rdp = _road_drive_data[(_opt.road_side << RVS_DRIVE_SIDE) + dir];
+		rdp = _road_drive_data[v->u.road.roadtype][(_opt.road_side << RVS_DRIVE_SIDE) + dir];
 		x = TileX(v->tile) * TILE_SIZE + rdp[RVC_TURN_AROUND_START_FRAME].x;
 		y = TileY(v->tile) * TILE_SIZE + rdp[RVC_TURN_AROUND_START_FRAME].y;
 		newdir = RoadVehGetSlidingDirection(v, x, y);
 			v->direction = newdir;
 			v->cur_speed -= v->cur_speed >> 2;
 		}
 		v->cur_image = GetRoadVehImage(v, newdir);
-		UpdateRoadVehDeltaXY(v);
+		v->UpdateDeltaXY(v->direction);
 		RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
 		return;
 	}
 	/* Calculate new position for the vehicle */
 		/* Vehicle is not in a road stop.
 		 * Check for another vehicle to overtake */
 		Vehicle* u = RoadVehFindCloseTo(v, x, y, new_dir);
 		if (u != NULL) {
+			v->cur_speed = u->cur_speed;
 			/* There is a vehicle in front overtake it if possible */
 			if (v->u.road.overtaking == 0) RoadVehCheckOvertake(v, u);
 			return;
 		}
 	}
 		v->direction = new_dir;
 		v->cur_speed -= (v->cur_speed >> 2);
 		if (old_dir != v->u.road.state) {
 			/* The vehicle is in a road stop */
 			v->cur_image = GetRoadVehImage(v, new_dir);
-			UpdateRoadVehDeltaXY(v);
+			v->UpdateDeltaXY(v->direction);
 			SetRoadVehPosition(v, v->x_pos, v->y_pos);
 			/* Note, return here means that the frame counter is not incremented
 			 * for vehicles changing direction in a road stop. This causes frames to
 			 * be repeated. (XXX) Is this intended? */
 			return;
 		 * Note, if vehicle is loading/unloading it has already been handled,
 		 * so if we get here the vehicle has just arrived or is just ready to leave. */
 		if (v->current_order.type != OT_LEAVESTATION &&
 				v->current_order.type != OT_GOTO_DEPOT) {
 			/* Vehicle has arrived at a bay in a road stop */
-			Order old_order;
 			if (IsDriveThroughStopTile(v->tile)) {
 				TileIndex next_tile = TILE_ADD(v->tile, TileOffsByDir(v->direction));
 				RoadStop::Type type = IsCargoInClass(v->cargo_type, CC_PASSENGERS) ? RoadStop::BUS : RoadStop::TRUCK;
-				assert(HASBIT(v->u.road.state, RVS_IS_STOPPING));
 				/* Check if next inline bay is free */
 				if (IsDriveThroughStopTile(next_tile) && (GetRoadStopType(next_tile) == type)) {
 					RoadStop *rs_n = GetRoadStopByTile(next_tile, type);
 			rs->SetEntranceBusy(false);
 			v->last_station_visited = GetStationIndex(v->tile);
 			RoadVehArrivesAt(v, st);
-			old_order = v->current_order;
 			v->BeginLoading();
-			v->current_order.flags = 0;
-			if (old_order.type == OT_GOTO_STATION &&
-					v->current_order.dest == v->last_station_visited) {
-				v->current_order.flags =
-					(old_order.flags & (OF_FULL_LOAD | OF_UNLOAD | OF_TRANSFER)) | OF_NON_STOP;
-			}
-			SET_EXPENSES_TYPE(EXPENSES_ROADVEH_INC);
-			if (LoadUnloadVehicle(v, true)) {
-				InvalidateWindow(WC_ROADVEH_LIST, v->owner);
-				MarkRoadVehDirty(v);
-			}
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 			return;
 		}
 		/* Vehicle is ready to leave a bay in a road stop */
 		if (v->current_order.type != OT_GOTO_DEPOT) {
 		if (rs == v->u.road.slot) {
 			/* We are leaving the correct station */
 			ClearSlot(v);
 		} else if (v->u.road.slot != NULL) {
-			/* We are leaving the wrong station */
+			/* We are leaving the wrong station
-			//XXX The question is .. what to do? Actually we shouldn't be here
+			 * XXX The question is .. what to do? Actually we shouldn't be here
-			//but I guess we need to clear the slot
+			 * but I guess we need to clear the slot */
 			DEBUG(ms, 0, "Vehicle %d (index %d) arrived at wrong stop", v->unitnumber, v->index);
 			if (v->tile != v->dest_tile) {
 				DEBUG(ms, 2, " current tile 0x%X is not destination tile 0x%X. Route problem", v->tile, v->dest_tile);
 			}
 			if (v->dest_tile != v->u.road.slot->xy) {
 	/* Move to next frame unless vehicle arrived at a stop position
 	 * in a depot or entered a tunnel/bridge */
 	if (!HASBIT(r, VETS_ENTERED_WORMHOLE)) v->u.road.frame++;
 	v->cur_image = GetRoadVehImage(v, v->direction);
-	UpdateRoadVehDeltaXY(v);
+	v->UpdateDeltaXY(v->direction);
 	RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
 }
 static void AgeRoadVehCargo(Vehicle *v)
 {
 	if (_patches.servint_roadveh == 0) return;
 	if (!VehicleNeedsService(v)) return;
 	if (v->vehstatus & VS_STOPPED) return;
 	if (_patches.gotodepot && VehicleHasDepotOrders(v)) return;
-	// Don't interfere with a depot visit scheduled by the user, or a
+	/* Don't interfere with a depot visit scheduled by the user, or a
-	// depot visit by the order list.
+	 * depot visit by the order list. */
 	if (v->current_order.type == OT_GOTO_DEPOT &&
 			(v->current_order.flags & (OF_HALT_IN_DEPOT | OF_PART_OF_ORDERS)) != 0)
 		return;
-	// If we already got a slot at a stop, use that FIRST, and go to a depot later
+	/* If we already got a slot at a stop, use that FIRST, and go to a depot later */
 	if (v->u.road.slot != NULL) return;
 	if (IsRoadVehInDepot(v)) {
 		VehicleServiceInDepot(v);
 		return;
 	}
-	// XXX If we already have a depot order, WHY do we search over and over?
+	/* XXX If we already have a depot order, WHY do we search over and over? */
 	depot = FindClosestRoadDepot(v);
 	if (depot == NULL || DistanceManhattan(v->tile, depot->xy) > 12) {
 		if (v->current_order.type == OT_GOTO_DEPOT) {
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags & OF_NON_STOP &&
 			!CHANCE16(1, 20)) {
 		return;
 	}
+	if (v->current_order.type == OT_LOADING) v->LeaveStation();
+	ClearSlot(v);
 	v->current_order.type = OT_GOTO_DEPOT;
 	v->current_order.flags = OF_NON_STOP;
 	v->current_order.dest = depot->index;
 	v->dest_tile = depot->xy;
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 	AgeVehicle(v);
 	CheckIfRoadVehNeedsService(v);
 	CheckOrders(v);
-	//Current slot has expired
+	/* Current slot has expired */
 	if (v->current_order.type == OT_GOTO_STATION && v->u.road.slot != NULL && v->u.road.slot_age-- == 0) {
 		DEBUG(ms, 3, "Slot expired for vehicle %d (index %d) at stop 0x%X",
 			v->unitnumber, v->index, v->u.road.slot->xy);
 		ClearSlot(v);
 	}
 	}
 }
 /** Refit a road vehicle to the specified cargo type
 * @param tile unused
+* @param flags operation to perform
 * @param p1 Vehicle ID of the vehicle to refit
 * @param p2 Bitstuffed elements
 * - p2 = (bit 0-7) - the new cargo type to refit to
 * - p2 = (bit 8-15) - the new cargo subtype to refit to
+* - p2 = (bit 16) - refit only this vehicle (ignored)
+* @return cost of refit or error
 */
 int32 CmdRefitRoadVeh(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
 {
 	Vehicle *v;
 	int32 cost;
 		CargoID old_cid = rvi->cargo_type;
 		/* normally, the capacity depends on the cargo type, a vehicle can
 		 * carry twice as much mail/goods as normal cargo, and four times as
 		 * many passengers
 		 */
-		capacity = rvi->capacity;
+		capacity = GetVehicleProperty(v, 0x0F, rvi->capacity);
 		switch (old_cid) {
 			case CT_PASSENGERS: break;
 			case CT_MAIL:
 			case CT_GOODS: capacity *= 2; break;
 			default:       capacity *= 4; break;

branch	NewGRF_ports
changeset 6719	4cc327ad39d5
parent 6683	7ec558346172
child 6720	35756db7e577