openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:889301acc299
+:7d1ff2f621c7
 			v->tile = tile;
 			v->owner = _current_player;
 			v->x_pos = x;
 			v->y_pos = y;
 			v->z_pos = GetSlopeZ(x, y);
+			v->running_ticks = 0;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_STOPPED | VS_DEFPAL;
 			v->spritenum = rvi->image_index;
 			v->cargo_type = rvi->cargo_type;
 			v->cargo_subtype = 0;
 	/* when moving all wagons, we can't have the same src_head and dst_head */
 	if (HasBit(p2, 0) && src_head == dst_head) return CommandCost();
 	{
-		int max_len = _patches.mammoth_trains ? 100 : 9;
+		int max_len = _patches.mammoth_trains ? 100 : 10;
 		/* check if all vehicles in the source train are stopped inside a depot. */
 		int src_len = CheckTrainStoppedInDepot(src_head);
 		if (src_len < 0) return_cmd_error(STR_881A_TRAINS_CAN_ONLY_BE_ALTERED);
 				/* (6.) Borked AI. If it sells an engine it expects all wagons lined
 				 * up on a new line to be added to the newly built loco. Replace it is.
 				 * Totally braindead cause building a new engine adds all loco-less
 				 * engines to its train anyways */
-				if (p2 == 2 && HasBit(ori_subtype, Train_Front)) {
+				if (p2 == 2 && HasBit(ori_subtype, TS_FRONT)) {
 					Vehicle *tmp;
 					for (v = first; v != NULL; v = tmp) {
 						tmp = GetNextVehicle(v);
 						DoCommand(v->tile, v->index | INVALID_VEHICLE << 16, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
 					}
 	BeginVehicleMove(v);
 	VehiclePositionChanged(v);
 	EndVehicleMove(v);
 }
-static void SetLastSpeed(Vehicle* v, int spd)
+static inline void SetLastSpeed(Vehicle* v, int spd)
 {
 	int old = v->u.rail.last_speed;
 	if (spd != old) {
 		v->u.rail.last_speed = spd;
 		if (_patches.vehicle_speed || (old == 0) != (spd == 0))
 */
 static Vehicle *TrainApproachingCrossing(TileIndex tile)
 {
 	assert(IsLevelCrossingTile(tile));
-	DiagDirection dir = AxisToDiagDir(OtherAxis(GetCrossingRoadAxis(tile)));
+	DiagDirection dir = AxisToDiagDir(GetCrossingRailAxis(tile));
 	TileIndex tile_from = tile + TileOffsByDiagDir(dir);
 	Vehicle *v = (Vehicle *)VehicleFromPos(tile_from, &tile, &TrainApproachingCrossingEnum);
 	if (v != NULL) return v;
 	if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
+	/* set reversed flag on all parts */
+	for (Vehicle *u = v; u != NULL; u = u->Next()) ToggleBit(u->u.rail.flags, VRF_TOGGLE_REVERSE);
+	ClrBit(v->u.rail.flags, VRF_REVERSING);
+	/* recalculate cached data */
+	TrainConsistChanged(v);
 	/* update all images */
-	for (Vehicle *u = v; u != NULL; u = u->Next()) { u->cur_image = u->GetImage(u->direction); }
+	for (Vehicle *u = v; u != NULL; u = u->Next()) u->cur_image = u->GetImage(u->direction);
-	ClrBit(v->u.rail.flags, VRF_REVERSING);
 	/* update crossing we were approaching */
 	if (crossing != INVALID_TILE) UpdateLevelCrossing(crossing);
 	/* maybe we are approaching crossing now, after reversal */
 {
 	assert(!(v->vehstatus & VS_CRASHED));
 	TrainFindDepotData tfdd;
 	tfdd.owner = v->owner;
-	tfdd.best_length = (uint)-1;
+	tfdd.best_length = UINT_MAX;
 	tfdd.reverse = false;
 	TileIndex tile = v->tile;
 	if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
 		tfdd.tile = tile;
 		tfdd.best_length = 0;
 		return tfdd;
 	}
-	if (_patches.yapf.rail_use_yapf) {
+	switch (_patches.pathfinder_for_trains) {
-		bool found = YapfFindNearestRailDepotTwoWay(v, max_distance, NPF_INFINITE_PENALTY, &tfdd.tile, &tfdd.reverse);
+		case VPF_YAPF: { /* YAPF */
-		tfdd.best_length = found ? max_distance / 2 : -1; // some fake distance or NOT_FOUND
+			bool found = YapfFindNearestRailDepotTwoWay(v, max_distance, NPF_INFINITE_PENALTY, &tfdd.tile, &tfdd.reverse);
-	} else if (_patches.new_pathfinding_all) {
+			tfdd.best_length = found ? max_distance / 2 : UINT_MAX; // some fake distance or NOT_FOUND
-		Vehicle* last = GetLastVehicleInChain(v);
+		} break;
-		Trackdir trackdir = GetVehicleTrackdir(v);
-		Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
+		case VPF_NPF: { /* NPF */
+			Vehicle* last = GetLastVehicleInChain(v);
-		assert(trackdir != INVALID_TRACKDIR);
+			Trackdir trackdir = GetVehicleTrackdir(v);
-		NPFFoundTargetData ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, last->tile, trackdir_rev, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes, NPF_INFINITE_PENALTY);
+			Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
-		if (ftd.best_bird_dist == 0) {
-			/* Found target */
+			assert(trackdir != INVALID_TRACKDIR);
-			tfdd.tile = ftd.node.tile;
+			NPFFoundTargetData ftd = NPFRouteToDepotBreadthFirstTwoWay(v->tile, trackdir, false, last->tile, trackdir_rev, false, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes, NPF_INFINITE_PENALTY);
-			/* Our caller expects a number of tiles, so we just approximate that
+			if (ftd.best_bird_dist == 0) {
-			 * number by this. It might not be completely what we want, but it will
+				/* Found target */
-			 * work for now :-) We can possibly change this when the old pathfinder
+				tfdd.tile = ftd.node.tile;
-			 * is removed. */
+				/* Our caller expects a number of tiles, so we just approximate that
-			tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;
+				* number by this. It might not be completely what we want, but it will
-			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;
+				* work for now :-) We can possibly change this when the old pathfinder
-		}
+				* is removed. */
-	} else {
+				tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;
-		/* search in the forward direction first. */
+				if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;
-		DiagDirection i = TrainExitDir(v->direction, v->u.rail.track);
+			}
-		NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+		} break;
-		if (tfdd.best_length == (uint)-1){
-			tfdd.reverse = true;
+		default:
-			/* search in backwards direction */
+		case VPF_NTP: { /* NTP */
-			i = TrainExitDir(ReverseDir(v->direction), v->u.rail.track);
+			/* search in the forward direction first. */
+			DiagDirection i = TrainExitDir(v->direction, v->u.rail.track);
 			NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
-		}
+			if (tfdd.best_length == UINT_MAX){
+				tfdd.reverse = true;
+				/* search in backwards direction */
+				i = TrainExitDir(ReverseDir(v->direction), v->u.rail.track);
+				NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
+			}
+		} break;
 	}
 	return tfdd;
 }
 	} while ((v = v->Next()) != NULL);
 	if (sound) PlayVehicleSound(u, VSE_TRAIN_EFFECT);
 }
-static void TrainPlayLeaveStationSound(const Vehicle* v)
+void Train::PlayLeaveStationSound() const
 {
 	static const SoundFx sfx[] = {
 		SND_04_TRAIN,
 		SND_0A_TRAIN_HORN,
 		SND_0A_TRAIN_HORN,
 		SND_47_MAGLEV_2,
 		SND_41_MAGLEV
 	};
-	if (PlayVehicleSound(v, VSE_START)) return;
+	if (PlayVehicleSound(this, VSE_START)) return;
-	EngineID engtype = v->engine_type;
+	EngineID engtype = this->engine_type;
-	SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], v);
+	SndPlayVehicleFx(sfx[RailVehInfo(engtype)->engclass], this);
-}
-void Train::PlayLeaveStationSound() const
-{
-	TrainPlayLeaveStationSound(this);
 }
 static bool CheckTrainStayInDepot(Vehicle *v)
 {
 	/* bail out if not all wagons are in the same depot or not in a depot at all */
 		}
 	}
 	VehicleServiceInDepot(v);
 	InvalidateWindowClasses(WC_TRAINS_LIST);
-	TrainPlayLeaveStationSound(v);
+	v->PlayLeaveStationSound();
 	v->u.rail.track = TRACK_BIT_X;
 	if (v->direction & 2) v->u.rail.track = TRACK_BIT_Y;
 	v->vehstatus &= ~VS_HIDDEN;
 	assert((tracks & ~TRACK_BIT_MASK) == 0);
 	/* quick return in case only one possible track is available */
 	if (KillFirstBit(tracks) == TRACK_BIT_NONE) return FindFirstTrack(tracks);
-	if (_patches.yapf.rail_use_yapf) {
+	switch (_patches.pathfinder_for_trains) {
-		Trackdir trackdir = YapfChooseRailTrack(v, tile, enterdir, tracks, &path_not_found);
+		case VPF_YAPF: { /* YAPF */
-		if (trackdir != INVALID_TRACKDIR) {
+			Trackdir trackdir = YapfChooseRailTrack(v, tile, enterdir, tracks, &path_not_found);
-			best_track = TrackdirToTrack(trackdir);
+			if (trackdir != INVALID_TRACKDIR) {
-		} else {
+				best_track = TrackdirToTrack(trackdir);
-			best_track = FindFirstTrack(tracks);
+			} else {
-		}
+				best_track = FindFirstTrack(tracks);
-	} else if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */
+			}
-		void* perf = NpfBeginInterval();
+		} break;
-		NPFFindStationOrTileData fstd;
+		case VPF_NPF: { /* NPF */
-		NPFFillWithOrderData(&fstd, v);
+			void *perf = NpfBeginInterval();
-		/* The enterdir for the new tile, is the exitdir for the old tile */
-		Trackdir trackdir = GetVehicleTrackdir(v);
+			NPFFindStationOrTileData fstd;
-		assert(trackdir != 0xff);
+			NPFFillWithOrderData(&fstd, v);
+			/* The enterdir for the new tile, is the exitdir for the old tile */
-		NPFFoundTargetData ftd = NPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, &fstd, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes);
+			Trackdir trackdir = GetVehicleTrackdir(v);
+			assert(trackdir != INVALID_TRACKDIR);
-		if (ftd.best_trackdir == 0xff) {
-			/* We are already at our target. Just do something
+			NPFFoundTargetData ftd = NPFRouteToStationOrTile(tile - TileOffsByDiagDir(enterdir), trackdir, true, &fstd, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes);
-			 * @todo maybe display error?
-			 * @todo: go straight ahead if possible? */
+			if (ftd.best_trackdir == INVALID_TRACKDIR) {
-			best_track = FindFirstTrack(tracks);
+				/* We are already at our target. Just do something
-		} else {
+				 * @todo maybe display error?
-			/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
+				 * @todo: go straight ahead if possible? */
-			the direction we need to take to get there, if ftd.best_bird_dist is not 0,
+				best_track = FindFirstTrack(tracks);
-			we did not find our target, but ftd.best_trackdir contains the direction leading
+			} else {
-			to the tile closest to our target. */
+				/* If ftd.best_bird_dist is 0, we found our target and ftd.best_trackdir contains
-			if (ftd.best_bird_dist != 0) path_not_found = true;
+				 * the direction we need to take to get there, if ftd.best_bird_dist is not 0,
-			/* Discard enterdir information, making it a normal track */
+				 * we did not find our target, but ftd.best_trackdir contains the direction leading
-			best_track = TrackdirToTrack(ftd.best_trackdir);
+				 * to the tile closest to our target. */
-		}
+				if (ftd.best_bird_dist != 0) path_not_found = true;
+				/* Discard enterdir information, making it a normal track */
-		int time = NpfEndInterval(perf);
+				best_track = TrackdirToTrack(ftd.best_trackdir);
-		DEBUG(yapf, 4, "[NPFT] %d us - %d rounds - %d open - %d closed -- ", time, 0, _aystar_stats_open_size, _aystar_stats_closed_size);
+			}
-	} else {
-		void* perf = NpfBeginInterval();
+			int time = NpfEndInterval(perf);
+			DEBUG(yapf, 4, "[NPFT] %d us - %d rounds - %d open - %d closed -- ", time, 0, _aystar_stats_open_size, _aystar_stats_closed_size);
-		TrainTrackFollowerData fd;
+		} break;
-		FillWithStationData(&fd, v);
+		default:
-		/* New train pathfinding */
+		case VPF_NTP: { /* NTP */
-		fd.best_bird_dist = (uint)-1;
+			void *perf = NpfBeginInterval();
-		fd.best_track_dist = (uint)-1;
-		fd.best_track = INVALID_TRACKDIR;
+			TrainTrackFollowerData fd;
+			FillWithStationData(&fd, v);
-		NewTrainPathfind(tile - TileOffsByDiagDir(enterdir), v->dest_tile,
-			v->u.rail.compatible_railtypes, enterdir, (NTPEnumProc*)NtpCallbFindStation, &fd);
+			/* New train pathfinding */
+			fd.best_bird_dist = UINT_MAX;
-		/* check whether the path was found or only 'guessed' */
+			fd.best_track_dist = UINT_MAX;
-		if (fd.best_bird_dist != 0) path_not_found = true;
+			fd.best_track = INVALID_TRACKDIR;
-		if (fd.best_track == 0xff) {
+			NewTrainPathfind(tile - TileOffsByDiagDir(enterdir), v->dest_tile,
-			/* blaha */
+				v->u.rail.compatible_railtypes, enterdir, (NTPEnumProc*)NtpCallbFindStation, &fd);
-			best_track = FindFirstTrack(tracks);
-		} else {
+			/* check whether the path was found or only 'guessed' */
-			best_track = TrackdirToTrack(fd.best_track);
+			if (fd.best_bird_dist != 0) path_not_found = true;
-		}
+			if (fd.best_track == INVALID_TRACKDIR) {
-		int time = NpfEndInterval(perf);
+				/* blaha */
-		DEBUG(yapf, 4, "[NTPT] %d us - %d rounds - %d open - %d closed -- ", time, 0, 0, 0);
+				best_track = FindFirstTrack(tracks);
-	}
+			} else {
+				best_track = TrackdirToTrack(fd.best_track);
+			}
+			int time = NpfEndInterval(perf);
+			DEBUG(yapf, 4, "[NTPT] %d us - %d rounds - %d open - %d closed -- ", time, 0, 0, 0);
+		} break;
+	}
 	/* handle "path not found" state */
 	if (path_not_found) {
 		/* PF didn't find the route */
 		if (!HasBit(v->u.rail.flags, VRF_NO_PATH_TO_DESTINATION)) {
 			/* it is first time the problem occurred, set the "path not found" flag */
 	assert(v->u.rail.track);
 	int i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];
-	if (_patches.yapf.rail_use_yapf) {
+	switch (_patches.pathfinder_for_trains) {
-		reverse_best = YapfCheckReverseTrain(v);
+		case VPF_YAPF: { /* YAPF */
-	} else if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */
+			reverse_best = YapfCheckReverseTrain(v);
-		NPFFindStationOrTileData fstd;
+		} break;
-		NPFFoundTargetData ftd;
-		Trackdir trackdir, trackdir_rev;
+		case VPF_NPF: { /* NPF */
-		Vehicle* last = GetLastVehicleInChain(v);
+			NPFFindStationOrTileData fstd;
+			NPFFoundTargetData ftd;
-		NPFFillWithOrderData(&fstd, v);
+			Vehicle* last = GetLastVehicleInChain(v);
-		trackdir = GetVehicleTrackdir(v);
+			NPFFillWithOrderData(&fstd, v);
-		trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
-		assert(trackdir != 0xff);
+			Trackdir trackdir = GetVehicleTrackdir(v);
-		assert(trackdir_rev != 0xff);
+			Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
+			assert(trackdir != INVALID_TRACKDIR);
-		ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes);
+			assert(trackdir_rev != INVALID_TRACKDIR);
-		if (ftd.best_bird_dist != 0) {
-			/* We didn't find anything, just keep on going straight ahead */
+			ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, false, last->tile, trackdir_rev, false, &fstd, TRANSPORT_RAIL, 0, v->owner, v->u.rail.compatible_railtypes);
-			reverse_best = false;
+			if (ftd.best_bird_dist != 0) {
-		} else {
+				/* We didn't find anything, just keep on going straight ahead */
-			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) {
+				reverse_best = false;
-				reverse_best = true;
 			} else {
-				reverse_best = false;
+				if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) {
-			}
+					reverse_best = true;
-		}
+				} else {
-	} else {
+					reverse_best = false;
-		int best_track = -1;
+				}
-		uint reverse = 0;
+			}
-		uint best_bird_dist  = 0;
+		} break;
-		uint best_track_dist = 0;
+		default:
-		for (;;) {
+		case VPF_NTP: { /* NTP */
-			fd.best_bird_dist = (uint)-1;
+			int best_track = -1;
-			fd.best_track_dist = (uint)-1;
+			uint reverse = 0;
+			uint best_bird_dist  = 0;
-			NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, (DiagDirection)(reverse ^ i), (NTPEnumProc*)NtpCallbFindStation, &fd);
+			uint best_track_dist = 0;
-			if (best_track != -1) {
+			for (;;) {
-				if (best_bird_dist != 0) {
+				fd.best_bird_dist = UINT_MAX;
-					if (fd.best_bird_dist != 0) {
+				fd.best_track_dist = UINT_MAX;
-						/* neither reached the destination, pick the one with the smallest bird dist */
-						if (fd.best_bird_dist > best_bird_dist) goto bad;
+				NewTrainPathfind(v->tile, v->dest_tile, v->u.rail.compatible_railtypes, (DiagDirection)(reverse ^ i), (NTPEnumProc*)NtpCallbFindStation, &fd);
-						if (fd.best_bird_dist < best_bird_dist) goto good;
+				if (best_track != -1) {
+					if (best_bird_dist != 0) {
+						if (fd.best_bird_dist != 0) {
+							/* neither reached the destination, pick the one with the smallest bird dist */
+							if (fd.best_bird_dist > best_bird_dist) goto bad;
+							if (fd.best_bird_dist < best_bird_dist) goto good;
+						} else {
+							/* we found the destination for the first time */
+							goto good;
+						}
 					} else {
-						/* we found the destination for the first time */
+						if (fd.best_bird_dist != 0) {
-						goto good;
+							/* didn't find destination, but we've found the destination previously */
+							goto bad;
+						} else {
+							/* both old & new reached the destination, compare track length */
+							if (fd.best_track_dist > best_track_dist) goto bad;
+							if (fd.best_track_dist < best_track_dist) goto good;
+						}
 					}
-				} else {
-					if (fd.best_bird_dist != 0) {
+					/* if we reach this position, there's two paths of equal value so far.
-						/* didn't find destination, but we've found the destination previously */
+					 * pick one randomly. */
-						goto bad;
+					int r = GB(Random(), 0, 8);
-					} else {
+					if (_pick_track_table[i] == (v->direction & 3)) r += 80;
-						/* both old & new reached the destination, compare track length */
+					if (_pick_track_table[best_track] == (v->direction & 3)) r -= 80;
-						if (fd.best_track_dist > best_track_dist) goto bad;
+					if (r <= 127) goto bad;
-						if (fd.best_track_dist < best_track_dist) goto good;
-					}
 				}
-				/* if we reach this position, there's two paths of equal value so far.
-				 * pick one randomly. */
-				int r = GB(Random(), 0, 8);
-				if (_pick_track_table[i] == (v->direction & 3)) r += 80;
-				if (_pick_track_table[best_track] == (v->direction & 3)) r -= 80;
-				if (r <= 127) goto bad;
-			}
 good:;
-			best_track = i;
+				best_track = i;
-			best_bird_dist = fd.best_bird_dist;
+				best_bird_dist = fd.best_bird_dist;
-			best_track_dist = fd.best_track_dist;
+				best_track_dist = fd.best_track_dist;
-			reverse_best = reverse;
+				reverse_best = reverse;
 bad:;
-			if (reverse != 0) break;
+				if (reverse != 0) break;
-			reverse = 2;
+				reverse = 2;
-		}
+			}
+		} break;
 	}
 	return reverse_best != 0;
 }
 	DIR_N , DIR_NW, DIR_W , INVALID_DIR,
 	DIR_NE, DIR_N , DIR_SW, INVALID_DIR,
 	DIR_E , DIR_SE, DIR_S
 };
-static Direction GetNewVehicleDirectionByTile(TileIndex new_tile, TileIndex old_tile)
+static inline Direction GetNewVehicleDirectionByTile(TileIndex new_tile, TileIndex old_tile)
 {
 	uint offs = (TileY(new_tile) - TileY(old_tile) + 1) * 4 +
 							TileX(new_tile) - TileX(old_tile) + 1;
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
 }
-static int GetDirectionToVehicle(const Vehicle *v, int x, int y)
+static inline int GetDirectionToVehicle(const Vehicle *v, int x, int y)
 {
 	byte offs;
 	x -= v->x_pos;
 	if (x >= 0) {
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
 }
 /* Check if the vehicle is compatible with the specified tile */
-static bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
+static inline bool CheckCompatibleRail(const Vehicle *v, TileIndex tile)
 {
 	return
 		IsTileOwner(tile, v->owner) && (
 			!IsFrontEngine(v) ||
 			HasBit(v->u.rail.compatible_railtypes, GetRailType(tile))
 	{256 / 4, 256 / 2, 256 / 4, 2}, ///< monorail
 	{0,       256 / 2, 256 / 4, 2}, ///< maglev
 };
 /** Modify the speed of the vehicle due to a turn */
-static void AffectSpeedByDirChange(Vehicle* v, Direction new_dir)
+static inline void AffectSpeedByDirChange(Vehicle* v, Direction new_dir)
 {
 	if (_patches.realistic_acceleration) return;
 	DirDiff diff = DirDifference(v->direction, new_dir);
 	if (diff == DIRDIFF_SAME) return;
 	const RailtypeSlowdownParams *rsp = &_railtype_slowdown[v->u.rail.railtype];
 	v->cur_speed -= (diff == DIRDIFF_45RIGHT || diff == DIRDIFF_45LEFT ? rsp->small_turn : rsp->large_turn) * v->cur_speed >> 8;
 }
 /** Modify the speed of the vehicle due to a change in altitude */
-static void AffectSpeedByZChange(Vehicle *v, byte old_z)
+static inline void AffectSpeedByZChange(Vehicle *v, byte old_z)
 {
 	if (old_z == v->z_pos || _patches.realistic_acceleration) return;
 	const RailtypeSlowdownParams *rsp = &_railtype_slowdown[v->u.rail.railtype];
 				enterdir = DirToDiagDir(dir);
 				assert(IsValidDiagDirection(enterdir));
 				/* Get the status of the tracks in the new tile and mask
 				 * away the bits that aren't reachable. */
-				uint32 ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, 0) & _reachable_tracks[enterdir];
+				TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, 0, ReverseDiagDir(enterdir)) & _reachable_tracks[enterdir];
+				TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
-				/* Combine the from & to directions.
+				TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts));
-				 * Now, the lower byte contains the track status, and the byte at bit 16 contains
-				 * the signal status. */
+				TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);
-				uint32 tracks = ts | (ts >> 8);
+				if (_patches.pathfinder_for_trains != VPF_NTP && _patches.forbid_90_deg && prev == NULL) {
-				TrackBits bits = (TrackBits)(tracks & TRACK_BIT_MASK);
-				if ((_patches.new_pathfinding_all || _patches.yapf.rail_use_yapf) && _patches.forbid_90_deg && prev == NULL) {
 					/* We allow wagons to make 90 deg turns, because forbid_90_deg
 					 * can be switched on halfway a turn */
 					bits &= ~TrackCrossesTracks(FindFirstTrack(v->u.rail.track));
 				}
 				TrackBits chosen_track;
 				if (prev == NULL) {
 					/* Currently the locomotive is active. Determine which one of the
 					 * available tracks to choose */
 					chosen_track = TrackToTrackBits(ChooseTrainTrack(v, gp.new_tile, enterdir, bits));
-					assert(chosen_track & tracks);
+					assert(chosen_track & bits);
 					/* Check if it's a red signal and that force proceed is not clicked. */
-					if ((tracks >> 16) & chosen_track && v->u.rail.force_proceed == 0) {
+					if (red_signals & chosen_track && v->u.rail.force_proceed == 0) {
-						/* In front of a red signal
+						/* In front of a red signal */
-						 * find the first set bit in ts. need to do it in 2 steps, since
+						Trackdir i = FindFirstTrackdir(trackdirbits);
-						 * FIND_FIRST_BIT only handles 6 bits at a time. */
-						Trackdir i = FindFirstTrackdir((TrackdirBits)(uint16)ts);
 						if (!HasSignalOnTrackdir(gp.new_tile, ReverseTrackdir(i))) {
 							v->cur_speed = 0;
 							v->subspeed = 0;
 							v->progress = 255 - 100;
 			/* In a tunnel or on a bridge
 			 * - for tunnels, only the part when the vehicle is not visible (part of enter/exit tile too)
 			 * - for bridges, only the middle part - without the bridge heads */
 			if (!(v->vehstatus & VS_HIDDEN)) {
 				v->cur_speed =
-					min(v->cur_speed, GetBridge(GetBridgeType(v->tile))->speed);
+					min(v->cur_speed, GetBridgeSpec(GetBridgeType(v->tile))->speed);
 			}
 			if (!IsTileType(gp.new_tile, MP_TUNNELBRIDGE) || !HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {
 				v->x_pos = gp.x;
 				v->y_pos = gp.y;
 	if (!TrainCanLeaveTile(v)) return INVALID_TILE;
 	DiagDirection dir = TrainExitDir(v->direction, v->u.rail.track);
 	TileIndex tile = v->tile + TileOffsByDiagDir(dir);
-	/* not a crossing || wrong axis || wrong railtype || wrong owner */
+	/* not a crossing || wrong axis || unusable rail (wrong type or owner) */
 	if (!IsLevelCrossingTile(tile) || DiagDirToAxis(dir) == GetCrossingRoadAxis(tile) ||
-			!CheckCompatibleRail(v, tile) || GetTileOwner(tile) != v->owner) {
+			!CheckCompatibleRail(v, tile)) {
 		return INVALID_TILE;
 	}
 	return tile;
 }
 	DiagDirection dir = TrainExitDir(v->direction, v->u.rail.track);
 	/* Calculate next tile */
 	TileIndex tile = v->tile + TileOffsByDiagDir(dir);
 	/* Determine the track status on the next tile */
-	uint32 ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0) & _reachable_tracks[dir];
+	TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0, ReverseDiagDir(dir)) & _reachable_tracks[dir];
+	TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
+	TrackdirBits red_signals = TrackStatusToRedSignals(ts);
 	/* We are sure the train is not entering a depot, it is detected above */
-	/* no suitable trackbits at all || wrong railtype || not our track ||
+	/* mask unreachable track bits if we are forbidden to do 90deg turns */
-	 *   tunnel/bridge from opposite side || depot from opposite side */
+	TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);
-	if (GB(ts, 0, 16) == 0 || !CheckCompatibleRail(v, tile) || GetTileOwner(tile) != v->owner ||
+	if (_patches.pathfinder_for_trains != VPF_NTP && _patches.forbid_90_deg) {
-			(IsTileType(tile, MP_TUNNELBRIDGE) && GetTunnelBridgeDirection(tile) != dir) ||
+		bits &= ~TrackCrossesTracks(FindFirstTrack(v->u.rail.track));
-			(IsTileDepotType(tile, TRANSPORT_RAIL) && GetRailDepotDirection(tile) == dir) ) {
+	}
+	/* no suitable trackbits at all || unusable rail (wrong type or owner) */
+	if (bits == TRACK_BIT_NONE || !CheckCompatibleRail(v, tile)) {
 		return TrainApproachingLineEnd(v, false);
 	}
 	/* approaching red signal */
-	if ((ts & (ts >> 16)) != 0) return TrainApproachingLineEnd(v, true);
+	if ((trackdirbits & red_signals) != 0) return TrainApproachingLineEnd(v, true);
 	/* approaching a rail/road crossing? then make it red */
 	if (IsLevelCrossingTile(tile)) MaybeBarCrossingWithSound(tile);
 	return true;
 	const Vehicle *v = this;
 	do {
 		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
-		byte cost_factor = GetVehicleProperty(v, 0x0D, rvi->running_cost_base);
+		byte cost_factor = GetVehicleProperty(v, 0x0D, rvi->running_cost);
 		if (cost_factor == 0) continue;
-		cost += cost_factor * _price.running_rail[rvi->running_cost_class];
+		cost += cost_factor * GetPriceByIndex(rvi->running_cost_class);
 	} while ((v = GetNextVehicle(v)) != NULL);
 	return cost;
 }
 	if (_age_cargo_skip_counter == 0) this->cargo.AgeCargo();
 	this->tick_counter++;
 	if (IsFrontEngine(this)) {
+		if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;
 		this->current_order_time++;
 		TrainLocoHandler(this, false);
 		/* make sure vehicle wasn't deleted. */
 		if (this->current_order.type == OT_GOTO_STATION) {
 			TileIndex tile = GetStation(this->current_order.dest)->train_tile;
 			if (tile != 0) this->dest_tile = tile;
 		}
-		if ((this->vehstatus & VS_STOPPED) == 0) {
+		if (this->running_ticks != 0) {
 			/* running costs */
-			CommandCost cost(EXPENSES_TRAIN_RUN, this->GetRunningCost() / 364);
+			CommandCost cost(EXPENSES_TRAIN_RUN, this->GetRunningCost() * this->running_ticks / (364 * DAY_TICKS));
-			this->profit_this_year -= cost.GetCost() >> 8;
+			this->profit_this_year -= cost.GetCost();
+			this->running_ticks = 0;
 			SubtractMoneyFromPlayerFract(this->owner, cost);
 			InvalidateWindow(WC_VEHICLE_DETAILS, this->index);
 			InvalidateWindowClasses(WC_TRAINS_LIST);
 	Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
 		if (v->type == VEH_TRAIN && IsFrontEngine(v)) {
 			/* show warning if train is not generating enough income last 2 years (corresponds to a red icon in the vehicle list) */
-			if (_patches.train_income_warn && v->owner == _local_player && v->age >= 730 && v->profit_this_year < 0) {
+			if (_patches.train_income_warn && v->owner == _local_player && v->age >= 730 && v->GetDisplayProfitThisYear() < 0) {
-				SetDParam(1, v->profit_this_year);
+				SetDParam(1, v->GetDisplayProfitThisYear());
 				SetDParam(0, v->unitnumber);
 				AddNewsItem(
 					STR_TRAIN_IS_UNPROFITABLE,
 					NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),
 					v->index,

branch	NewGRF_ports
changeset 6878	7d1ff2f621c7
parent 6877	889301acc299
child 10184	fcf5fb2548eb