openttd-ottdgrfs: comparison src/roadveh

equal deleted inserted replaced

-:9a27928bcd5e
+:ebf0ece7d8f6
 {
 	byte length = 8;
 	uint16 veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, v->engine_type, v);
 	if (veh_len != CALLBACK_FAILED) {
-		length -= clamp(veh_len, 0, 7);
+		length -= Clamp(veh_len, 0, 7);
 	}
 	return length;
 }
 	/* 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);
+	if (HasBit(GetRoadTypes(tile), ROADTYPE_TRAM) != HasBit(EngInfo(p1)->misc_flags, EF_ROAD_TRAM)) return_cmd_error(STR_DEPOT_WRONG_DEPOT_TYPE);
 	uint num_vehicles = 1 + CountArticulatedParts(p1, false);
 	/* Allow for the front and the articulated parts, plus one to "terminate" the list. */
 	Vehicle **vl = (Vehicle**)alloca(sizeof(*vl) * (num_vehicles + 1));
 	}
 	v = vl[0];
 	/* find the first free roadveh id */
-	unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_ROAD);
+	unit_num = HasBit(p2, 0) ? 0 : GetFreeUnitNumber(VEH_ROAD);
 	if (unit_num > _patches.max_roadveh)
 		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 	if (flags & DC_EXEC) {
 		int x;
 		int y;
 		const RoadVehicleInfo *rvi = RoadVehInfo(p1);
+		v = new (v) RoadVehicle();
 		v->unitnumber = unit_num;
 		v->direction = DiagDirToDir(GetRoadDepotDirection(tile));
 		v->owner = _current_player;
 		v->tile = tile;
 		v->service_interval = _patches.servint_roadveh;
 		v->date_of_last_service = _date;
 		v->build_year = _cur_year;
-		v = new (v) RoadVehicle();
 		v->cur_image = 0xC15;
 		v->random_bits = VehicleRandomBits();
 		SetRoadVehFront(v);
-		v->u.road.roadtype = HASBIT(EngInfo(v->engine_type)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD;
+		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);
 		v->u.road.cached_veh_length = GetRoadVehLength(v);
 		v->vehicle_flags = 0;
-		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SETBIT(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
+		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
 		v->cargo_cap = GetVehicleProperty(v, 0x0F, rvi->capacity);
 		AddArticulatedParts(vl, VEH_ROAD);
 	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	if (!CheckRoadVehInDepotStopped(v)) {
 		return_cmd_error(STR_9013_MUST_BE_STOPPED_INSIDE);
 	}
+	CommandCost ret(-v->value);
 	if (flags & DC_EXEC) {
 		// Invalidate depot
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 		RebuildVehicleLists();
 		DeleteWindowById(WC_VEHICLE_VIEW, v->index);
 		DeleteDepotHighlightOfVehicle(v);
 		delete v;
 	}
-	return CommandCost(-v->value);
+	return ret;
 }
 struct RoadFindDepotData {
 	uint best_length;
 	TileIndex tile;
 	if (v->IsInDepot()) return CMD_ERROR;
 	/* If the current orders are already goto-depot */
 	if (v->current_order.type == OT_GOTO_DEPOT) {
-		if (!!(p2 & DEPOT_SERVICE) == HASBIT(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
+		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OFB_HALT_IN_DEPOT)) {
 			/* We called with a different DEPOT_SERVICE setting.
 			 * Now we change the setting to apply the new one and let the vehicle head for the same depot.
 			 * Note: the if is (true for requesting service == true for ordered to stop in depot) */
 			if (flags & DC_EXEC) {
-				CLRBIT(v->current_order.flags, OFB_PART_OF_ORDERS);
+				ClrBit(v->current_order.flags, OFB_PART_OF_ORDERS);
-				TOGGLEBIT(v->current_order.flags, OFB_HALT_IN_DEPOT);
+				ToggleBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
 				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 			}
 			return CommandCost();
 		}
 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
 		if (flags & DC_EXEC) {
 			/* If the orders to 'goto depot' are in the orders list (forced servicing),
 			 * then skip to the next order; effectively cancelling this forced service */
-			if (HASBIT(v->current_order.flags, OFB_PART_OF_ORDERS))
+			if (HasBit(v->current_order.flags, OFB_PART_OF_ORDERS))
 				v->cur_order_index++;
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 		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);
+		if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
 		v->current_order.refit_cargo = CT_INVALID;
 		v->current_order.dest = dep->index;
 		v->dest_tile = dep->xy;
 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
 	}
 	/* Mark the station entrance as not busy */
 	rs->SetEntranceBusy(false);
 	/* Free the parking bay */
-	rs->FreeBay(HASBIT(v->u.road.state, RVS_USING_SECOND_BAY));
+	rs->FreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY));
 }
 static void DeleteLastRoadVeh(Vehicle *v)
 {
 	Vehicle *u = v;
 {
 	const Vehicle* u = (Vehicle*)data;
 	return
 		v->type == VEH_TRAIN &&
-		myabs(v->z_pos - u->z_pos) <= 6 &&
+		abs(v->z_pos - u->z_pos) <= 6 &&
-		myabs(v->x_pos - u->x_pos) <= 4 &&
+		abs(v->x_pos - u->x_pos) <= 4 &&
-		myabs(v->y_pos - u->y_pos) <= 4 ?
+		abs(v->y_pos - u->y_pos) <= 4 ?
 			v : NULL;
 }
 static void RoadVehCrash(Vehicle *v)
 {
 	short y_diff = v->y_pos - rvf->y;
 	return
 		v->type == VEH_ROAD &&
 		!v->IsInDepot() &&
-		myabs(v->z_pos - rvf->veh->z_pos) < 6 &&
+		abs(v->z_pos - rvf->veh->z_pos) < 6 &&
 		v->direction == rvf->dir &&
 		rvf->veh->First() != v->First() &&
 		(dist_x[v->direction] >= 0 || (x_diff > dist_x[v->direction] && x_diff <= 0)) &&
 		(dist_x[v->direction] <= 0 || (x_diff < dist_x[v->direction] && x_diff >= 0)) &&
 		(dist_y[v->direction] >= 0 || (y_diff > dist_y[v->direction] && y_diff <= 0)) &&
 static Vehicle* RoadVehFindCloseTo(Vehicle* v, int x, int y, Direction dir)
 {
 	RoadVehFindData rvf;
 	Vehicle *u;
+	Vehicle *front = v->First();
-	if (v->u.road.reverse_ctr != 0) return NULL;
+	if (front->u.road.reverse_ctr != 0) return NULL;
 	rvf.x = x;
 	rvf.y = y;
 	rvf.dir = dir;
 	rvf.veh = v;
-	u = (Vehicle*)VehicleFromPosXY(x, y, &rvf, EnumCheckRoadVehClose);
+	if (front->u.road.state == RVSB_WORMHOLE) {
+		u = (Vehicle*)VehicleFromPos(v->tile, &rvf, EnumCheckRoadVehClose);
+	} else {
+		u = (Vehicle*)VehicleFromPosXY(x, y, &rvf, EnumCheckRoadVehClose);
+	}
 	/* This code protects a roadvehicle from being blocked for ever
 	 * If more than 1480 / 74 days a road vehicle is blocked, it will
 	 * drive just through it. The ultimate backup-code of TTD.
 	 * It can be disabled. */
 	if (u == NULL) {
-		v->u.road.blocked_ctr = 0;
+		front->u.road.blocked_ctr = 0;
 		return NULL;
 	}
-	if (++v->u.road.blocked_ctr > 1480) return NULL;
+	if (++front->u.road.blocked_ctr > 1480) return NULL;
 	return u;
 }
 static void RoadVehArrivesAt(const Vehicle* v, Station* st)
 static void* EnumFindVehToOvertake(Vehicle* v, void* data)
 {
 	const OvertakeData* od = (OvertakeData*)data;
 	return
-		v->tile == od->tile && v->type == VEH_ROAD && v != od->u && v != od->v ?
+		v->tile == od->tile && v->type == VEH_ROAD && v->First() == v && v != od->u && v != od->v ?
 			v : NULL;
 }
 static bool FindRoadVehToOvertake(OvertakeData *od)
 {
 }
 static int PickRandomBit(uint bits)
 {
 	uint i;
-	uint num = RandomRange(COUNTBITS(bits));
+	uint num = RandomRange(CountBits(bits));
 	for (i = 0; !(bits & 1) || (int)--num >= 0; bits >>= 1, i++) {}
 	return i;
 }
 		/* We've got no destination, pick a random track */
 		return_track(PickRandomBit(trackdirs));
 	}
 	/* Only one track to choose between? */
-	if (!(KillFirstBit2x64(trackdirs))) {
+	if (KillFirstBit(trackdirs) == TRACKDIR_BIT_NONE) {
 		return_track(FindFirstBit2x64(trackdirs));
 	}
 	if (_patches.yapf.road_use_yapf) {
 		Trackdir trackdir = YapfChooseRoadTrack(v, tile, enterdir);
 		best_track = INVALID_TRACKDIR;
 		uint best_dist = (uint)-1;
 		uint best_maxlen = (uint)-1;
 		uint bitmask = (uint)trackdirs;
 		for (int i = 0; bitmask != 0; bitmask >>= 1, i++) {
-			if (HASBIT(bitmask, 0)) {
+			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, v->u.road.compatible_roadtypes, _road_pf_directions[i], EnumRoadTrackFindDist, NULL, &frd);
 		}
 	}
 found_best_track:;
-	if (HASBIT(signal, best_track)) return INVALID_TRACKDIR;
+	if (HasBit(signal, best_track)) return INVALID_TRACKDIR;
 	return best_track;
 }
 static uint RoadFindPathToStop(const Vehicle *v, TileIndex tile)
 	RDE_NEXT_TILE = 0x80,
 	RDE_TURNED    = 0x40,
 	/* Start frames for when a vehicle enters a tile/changes its state.
 	 * The start frame is different for vehicles that turned around or
-	 * are leaving the depot as the do not start at the edge of the tile */
+	 * are leaving the depot as the do not start at the edge of the tile.
-	RVC_DEFAULT_START_FRAME      = 0,
+	 * For trams there are a few different start frames as there are two
-	RVC_TURN_AROUND_START_FRAME  = 1,
+	 * places where trams can turn. */
-	RVC_DEPOT_START_FRAME        = 6,
+	RVC_DEFAULT_START_FRAME                =  0,
+	RVC_TURN_AROUND_START_FRAME            =  1,
+	RVC_DEPOT_START_FRAME                  =  6,
+	RVC_START_FRAME_AFTER_LONG_TRAM        = 22,
+	RVC_TURN_AROUND_START_FRAME_SHORT_TRAM = 16,
 	/* Stop frame for a vehicle in a drive-through stop */
-	RVC_DRIVE_THROUGH_STOP_FRAME = 7
+	RVC_DRIVE_THROUGH_STOP_FRAME           =  7
 };
 struct RoadDriveEntry {
 	byte x, y;
 };
 			diag_dir = ReverseDiagDir(GetRoadDepotDirection(tile));
 		}
 		if (diag_dir == INVALID_DIAGDIR) return INVALID_TRACKDIR;
 		dir = DiagdirToDiagTrackdir(diag_dir);
-	} else if (HASBIT(prev_state, RVS_IN_DT_ROAD_STOP)) {
+	} else if (HasBit(prev_state, RVS_IN_DT_ROAD_STOP)) {
 		dir = (Trackdir)(prev_state & RVSB_ROAD_STOP_TRACKDIR_MASK);
 	} else if (prev_state < TRACKDIR_END) {
-		dir = (Trackdir)prev_state;
+		if (already_reversed && prev->tile != tile) {
+			/*
+			 * The vehicle has reversed, but did not go straight back.
+			 * It immediatelly turn onto another tile. This means that
+			 * the roadstate of the previous vehicle cannot be used
+			 * as the direction we have to go with this vehicle.
+			 *
+			 * Next table is build in the following way:
+			 *  - first row for when the vehicle in front went to the northern or
+			 *    western tile, second for southern and eastern.
+			 *  - columns represent the entry direction.
+			 *  - cell values are determined by the Trackdir one has to take from
+			 *    the entry dir (column) to the tile in north or south by only
+			 *    going over the trackdirs used for turning 90 degrees, i.e.
+			 *    TRACKDIR_{UPPER,RIGHT,LOWER,LEFT}_{N,E,S,W}.
+			 */
+			Trackdir reversed_turn_lookup[2][DIAGDIR_END] = {
+				{ TRACKDIR_UPPER_W, TRACKDIR_RIGHT_N, TRACKDIR_LEFT_N,  TRACKDIR_UPPER_E },
+				{ TRACKDIR_RIGHT_S, TRACKDIR_LOWER_W, TRACKDIR_LOWER_E, TRACKDIR_LEFT_S  }};
+			dir = reversed_turn_lookup[prev->tile < tile ? 0 : 1][ReverseDiagDir(entry_dir)];
+		} else {
+			dir = (Trackdir)prev_state;
+		}
 	} else {
 		return INVALID_TRACKDIR;
 	}
 	/* Do some sanity checking. */
 	if ((required & GetAnyRoadBits(tile, v->u.road.roadtype)) == ROAD_NONE) {
 		dir = INVALID_TRACKDIR;
 	}
 	return dir;
+}
+/**
+* Can a tram track build without destruction on the given tile?
+* @param t the tile to build on.
+* @return true when a track track can be build on 't'
+*/
+static bool CanBuildTramTrackOnTile(TileIndex t)
+{
+	switch (GetTileType(t)) {
+		case MP_CLEAR:
+		case MP_TREES:
+			return true;
+		case MP_ROAD:
+			return GetRoadTileType(t) == ROAD_TILE_NORMAL;
+		case MP_WATER:
+			return IsCoast(t);
+		default:
+			return false;
+	}
 }
 static bool IndividualRoadVehicleController(Vehicle *v, const Vehicle *prev)
 {
 	Direction new_dir;
 	if (v->u.road.state == RVSB_WORMHOLE) {
 		/* Vehicle is entering a depot or is on a bridge or in a tunnel */
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 		const Vehicle *u = RoadVehFindCloseTo(v, gp.x, gp.y, v->direction);
-		if (u != NULL && u->cur_speed < v->cur_speed) {
+		if (u != NULL && u->First()->cur_speed < v->cur_speed) {
-			v->cur_speed = u->cur_speed;
+			v->cur_speed = u->First()->cur_speed;
 			return false;
 		}
-		if ((IsTunnelTile(gp.new_tile) || IsBridgeTile(gp.new_tile)) && HASBIT(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
+		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 = v->GetImage(v->direction);
 			v->UpdateDeltaXY(v->direction);
 			SetRoadVehPosition(v,gp.x,gp.y);
 			return true;
 	/* 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[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) +
+		(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((DiagDirection)(rd.x & 3));
 		Trackdir dir;
 			v->cur_speed = 0;
 			return false;
 		}
 again:
+		uint start_frame = RVC_DEFAULT_START_FRAME;
 		if (IsReversingRoadTrackdir(dir)) {
 			/* Turning around */
 			if (v->u.road.roadtype == ROADTYPE_TRAM) {
-				RoadBits needed; // The road bits the tram needs to be able to turn around
+				/* Determine the road bits the tram needs to be able to turn around
+				 * using the 'big' corner loop. */
+				RoadBits needed;
 				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_ROAD) || GetRoadTileType(tile) != ROAD_TILE_NORMAL || HasRoadWorks(tile) || (needed & GetRoadBits(tile, ROADTYPE_TRAM)) == ROAD_NONE) {
+				if ((v->Previous() != NULL && v->Previous()->tile == tile) ||
-					/* The tram cannot turn here */
+						(IsRoadVehFront(v) && IsTileType(tile, MP_ROAD) &&
+							GetRoadTileType(tile) == ROAD_TILE_NORMAL && !HasRoadWorks(tile) &&
+							(needed & GetRoadBits(tile, ROADTYPE_TRAM)) != ROAD_NONE)) {
+					/*
+					 * Taking the 'big' corner for trams only happens when:
+					 * - The previous vehicle in this (articulated) tram chain is
+					 *   already on the 'next' tile, we just follow them regardless of
+					 *   anything. When it is NOT on the 'next' tile, the tram started
+					 *   doing a reversing turn when the piece of tram track on the next
+					 *   tile did not exist yet. Do not use the big tram loop as that is
+					 *   going to cause the tram to split up.
+					 * - Or the front of the tram can drive over the next tile.
+					 */
+				} else if (!IsRoadVehFront(v) || !CanBuildTramTrackOnTile(tile)) {
+					/*
+					 * Taking the 'small' corner for trams only happens when:
+					 * - We are not the from vehicle of an articulated tram.
+					 * - Or when the player cannot build on the next tile.
+					 *
+					 * The 'small' corner means that the vehicle is on the end of a
+					 * tram track and needs to start turning there. To do this properly
+					 * the tram needs to start at an offset in the tram turning 'code'
+					 * for 'big' corners. It furthermore does not go to the next tile,
+					 * so that needs to be fixed too.
+					 */
+					tile = v->tile;
+					start_frame = RVC_TURN_AROUND_START_FRAME_SHORT_TRAM;
+				} else {
+					/* The player can build on the next tile, so wait till (s)he does. */
 					v->cur_speed = 0;
 					return false;
 				}
 			} else if (IsTileType(v->tile, MP_ROAD) && GetRoadTileType(v->tile) == ROAD_TILE_NORMAL && GetDisallowedRoadDirections(v->tile) != DRD_NONE) {
 				v->cur_speed = 0;
 		}
 		/* Get position data for first frame on the new tile */
 		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;
+		x = TileX(tile) * TILE_SIZE + rdp[start_frame].x;
-		y = TileY(tile) * TILE_SIZE + rdp[RVC_DEFAULT_START_FRAME].y;
+		y = TileY(tile) * TILE_SIZE + rdp[start_frame].y;
 		newdir = RoadVehGetSlidingDirection(v, x, y);
-		if (IsRoadVehFront(v) && RoadVehFindCloseTo(v, x, y, newdir) != NULL) return false;
+		if (IsRoadVehFront(v)) {
+			Vehicle *u = RoadVehFindCloseTo(v, x, y, newdir);
+			if (u != NULL) {
+				v->cur_speed = u->First()->cur_speed;
+				return false;
+			}
+		}
 		r = VehicleEnterTile(v, tile, x, y);
-		if (HASBIT(r, VETS_CANNOT_ENTER)) {
+		if (HasBit(r, VETS_CANNOT_ENTER)) {
 			if (!IsTileType(tile, MP_TUNNELBRIDGE)) {
 				v->cur_speed = 0;
 				return false;
 			}
 			/* Try an about turn to re-enter the previous tile */
 			if (IsRoadStop(v->tile)) {
 				RoadStop *rs = GetRoadStopByTile(v->tile, GetRoadStopType(v->tile));
 				/* Vehicle is leaving a road stop tile, mark bay as free
 				 * For drive-through stops, only do it if the vehicle stopped here */
-				if (IsStandardRoadStopTile(v->tile) || HASBIT(v->u.road.state, RVS_IS_STOPPING)) {
+				if (IsStandardRoadStopTile(v->tile) || HasBit(v->u.road.state, RVS_IS_STOPPING)) {
-					rs->FreeBay(HASBIT(v->u.road.state, RVS_USING_SECOND_BAY));
+					rs->FreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY));
-					CLRBIT(v->u.road.state, RVS_IS_STOPPING);
+					ClrBit(v->u.road.state, RVS_IS_STOPPING);
 				}
 				if (IsStandardRoadStopTile(v->tile)) rs->SetEntranceBusy(false);
 			}
 		}
-		if (!HASBIT(r, VETS_ENTERED_WORMHOLE)) {
+		if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {
 			v->tile = tile;
 			v->u.road.state = (byte)dir;
-			v->u.road.frame = RVC_DEFAULT_START_FRAME;
+			v->u.road.frame = start_frame;
 		}
 		if (newdir != v->direction) {
 			v->direction = newdir;
 			v->cur_speed -= v->cur_speed >> 2;
 		}
 		Trackdir dir;
 		uint32 r;
 		Direction newdir;
 		const RoadDriveEntry *rdp;
-		if (IsRoadVehFront(v)) {
+		uint turn_around_start_frame = RVC_TURN_AROUND_START_FRAME;
-			/* If this is the front engine, look for the right path. */
-			dir = RoadFindPathToDest(v, v->tile, (DiagDirection)(rd.x & 3));
+		RoadBits tram;
+		if (v->u.road.roadtype == ROADTYPE_TRAM && CountBits(tram = GetRoadBits(v->tile, ROADTYPE_TRAM)) == 1) {
+			/*
+			 * The tram is turning around with one tram 'roadbit'. This means that
+			 * it is using the 'big' corner 'drive data'. However, to support the
+			 * trams to take a small corner, there is a 'turned' marker in the middle
+			 * of the turning 'drive data'. When the tram took the long corner, we
+			 * will still use the 'big' corner drive data, but we advance it one
+			 * frame. We furthermore set the driving direction so the turning is
+			 * going to be properly shown.
+			 */
+			turn_around_start_frame = RVC_START_FRAME_AFTER_LONG_TRAM;
+			switch (tram) {
+				default: NOT_REACHED();
+				case ROAD_SW: dir = TRACKDIR_RVREV_NE; break;
+				case ROAD_NW: dir = TRACKDIR_RVREV_SE; break;
+				case ROAD_NE: dir = TRACKDIR_RVREV_SW; break;
+				case ROAD_SE: dir = TRACKDIR_RVREV_NW; break;
+			}
 		} else {
-			dir = FollowPreviousRoadVehicle(v, prev, v->tile, (DiagDirection)(rd.x & 3), true);
+			if (IsRoadVehFront(v)) {
+				/* If this is the front engine, look for the right path. */
+				dir = RoadFindPathToDest(v, v->tile, (DiagDirection)(rd.x & 3));
+			} else {
+				dir = FollowPreviousRoadVehicle(v, prev, v->tile, (DiagDirection)(rd.x & 3), true);
+			}
 		}
 		if (dir == INVALID_TRACKDIR) {
 			v->cur_speed = 0;
 			return false;
 		}
 		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;
+		x = TileX(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].x;
-		y = TileY(v->tile) * TILE_SIZE + rdp[RVC_TURN_AROUND_START_FRAME].y;
+		y = TileY(v->tile) * TILE_SIZE + rdp[turn_around_start_frame].y;
 		newdir = RoadVehGetSlidingDirection(v, x, y);
 		if (IsRoadVehFront(v) && RoadVehFindCloseTo(v, x, y, newdir) != NULL) return false;
 		r = VehicleEnterTile(v, v->tile, x, y);
-		if (HASBIT(r, VETS_CANNOT_ENTER)) {
+		if (HasBit(r, VETS_CANNOT_ENTER)) {
 			v->cur_speed = 0;
 			return false;
 		}
 		v->u.road.state = dir;
-		v->u.road.frame = RVC_TURN_AROUND_START_FRAME;
+		v->u.road.frame = turn_around_start_frame;
 		if (newdir != v->direction) {
 			v->direction = newdir;
 			v->cur_speed -= v->cur_speed >> 2;
 		}
 		/* Vehicle is not in a road stop.
 		 * Check for another vehicle to overtake */
 		Vehicle* u = RoadVehFindCloseTo(v, x, y, new_dir);
 		if (u != NULL) {
+			u = u->First();
 			/* There is a vehicle in front overtake it if possible */
 			if (v->u.road.overtaking == 0) RoadVehCheckOvertake(v, u);
 			if (v->u.road.overtaking == 0) v->cur_speed = u->cur_speed;
 			return false;
 		}
 				/* Check if next inline bay is free */
 				if (IsDriveThroughStopTile(next_tile) && (GetRoadStopType(next_tile) == type)) {
 					RoadStop *rs_n = GetRoadStopByTile(next_tile, type);
-					if (rs_n->IsFreeBay(HASBIT(v->u.road.state, RVS_USING_SECOND_BAY))) {
+					if (rs_n->IsFreeBay(HasBit(v->u.road.state, RVS_USING_SECOND_BAY))) {
 						/* Bay in next stop along is free - use it */
 						ClearSlot(v);
 						rs_n->num_vehicles++;
 						v->u.road.slot = rs_n;
 						v->dest_tile = rs_n->xy;
 	}
 	/* Check tile position conditions - i.e. stop position in depot,
 	 * entry onto bridge or into tunnel */
 	r = VehicleEnterTile(v, v->tile, x, y);
-	if (HASBIT(r, VETS_CANNOT_ENTER)) {
+	if (HasBit(r, VETS_CANNOT_ENTER)) {
 		v->cur_speed = 0;
 		return false;
 	}
 	/* 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++;
+	if (!HasBit(r, VETS_ENTERED_WORMHOLE)) v->u.road.frame++;
 	v->cur_image = v->GetImage(v->direction);
 	v->UpdateDeltaXY(v->direction);
 	RoadZPosAffectSpeed(v, SetRoadVehPosition(v, x, y));
 	return true;
 {
 	Vehicle *v;
 	CommandCost cost;
 	CargoID new_cid = GB(p2, 0, 8);
 	byte new_subtype = GB(p2, 8, 8);
-	bool only_this = HASBIT(p2, 16);
+	bool only_this = HasBit(p2, 16);
 	uint16 capacity = CALLBACK_FAILED;
 	uint total_capacity = 0;
 	if (!IsValidVehicleID(p1)) return CMD_ERROR;
 		 * [Refit] button near each wagon. */
 		if (!CanRefitTo(v->engine_type, new_cid)) continue;
 		if (v->cargo_cap == 0) continue;
-		if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_REFIT_CAPACITY)) {
+		if (HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_REFIT_CAPACITY)) {
 			/* Back up the cargo type */
 			CargoID temp_cid = v->cargo_type;
 			byte temp_subtype = v->cargo_subtype;
 			v->cargo_type = new_cid;
 			v->cargo_subtype = new_subtype;

branch	noai
changeset 9722	ebf0ece7d8f6
parent 9718	f82a4facea8b
child 9723	eee46cb39750