openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:ebf0ece7d8f6
+:eee46cb39750
 #include "stdafx.h"
 #include "openttd.h"
 #include "bridge_map.h"
 #include "debug.h"
-#include "functions.h"
+#include "tile_cmd.h"
 #include "landscape.h"
 #include "gui.h"
 #include "station_map.h"
 #include "table/strings.h"
-#include "strings.h"
-#include "map.h"
-#include "tile.h"
 #include "tunnel_map.h"
-#include "vehicle.h"
 #include "timetable.h"
 #include "articulated_vehicles.h"
-#include "command.h"
+#include "command_func.h"
 #include "pathfind.h"
 #include "npf.h"
 #include "station.h"
 #include "table/train_cmd.h"
 #include "news.h"
 #include "engine.h"
 #include "player.h"
-#include "sound.h"
 #include "depot.h"
 #include "waypoint.h"
 #include "vehicle_gui.h"
 #include "train.h"
 #include "bridge.h"
 #include "newgrf_callbacks.h"
 #include "newgrf_engine.h"
 #include "newgrf_sound.h"
 #include "newgrf_text.h"
-#include "direction.h"
+#include "direction_func.h"
 #include "yapf/yapf.h"
-#include "date.h"
 #include "cargotype.h"
 #include "group.h"
 #include "table/sprites.h"
+#include "tunnelbridge_map.h"
+#include "strings_func.h"
+#include "functions.h"
+#include "window_func.h"
+#include "date_func.h"
+#include "vehicle_func.h"
+#include "sound_func.h"
+#include "variables.h"
+#include "autoreplace_gui.h"
+#include "gfx_func.h"
 #include "ai/ai.h"
 static bool TrainCheckIfLineEnds(Vehicle *v);
 static void TrainController(Vehicle *v, bool update_image);
 static const byte _vehicle_initial_x_fract[4] = {10, 8, 4,  8};
 	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
 	EngineID first_engine = IsFrontEngine(v) ? v->engine_type : INVALID_ENGINE;
 	v->u.rail.cached_total_length = 0;
 	v->u.rail.compatible_railtypes = 0;
+	bool train_can_tilt = true;
 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
 		const RailVehicleInfo *rvi_u = RailVehInfo(u->engine_type);
 		/* Check the v->first cache. */
 		assert(u->First() == v);
+		if (!HasBit(EngInfo(u->engine_type)->misc_flags, EF_RAIL_TILTS)) train_can_tilt = false;
 		/* update the 'first engine' */
 		u->u.rail.first_engine = v == u ? INVALID_ENGINE : first_engine;
 		u->u.rail.railtype = rvi_u->railtype;
 		v->u.rail.cached_total_length += u->u.rail.cached_veh_length;
 	}
 	/* store consist weight/max speed in cache */
 	v->u.rail.cached_max_speed = max_speed;
+	v->u.rail.cached_tilt = train_can_tilt;
 	/* recalculate cached weights and power too (we do this *after* the rest, so it is known which wagons are powered and need extra weight added) */
 	TrainCargoChanged(v);
 }
-/* These two arrays are used for realistic acceleration. XXX: How should they
-* be interpreted? */
-static const byte _curve_neighbours45[8][2] = {
-	{7, 1},
-	{0, 2},
-	{1, 3},
-	{2, 4},
-	{3, 5},
-	{4, 6},
-	{5, 7},
-	{6, 0},
-};
-static const byte _curve_neighbours90[8][2] = {
-	{6, 2},
-	{7, 3},
-	{0, 4},
-	{1, 5},
-	{2, 6},
-	{3, 7},
-	{4, 0},
-	{5, 1},
-};
 enum AccelType {
 	AM_ACCEL,
 	AM_BRAKE
 };
 }
 /** new acceleration*/
 static int GetTrainAcceleration(Vehicle *v, bool mode)
 {
-	int max_speed = 2000;
+	static const int absolute_max_speed = 2000;
+	int max_speed = absolute_max_speed;
 	int speed = v->cur_speed * 10 / 16; // km-ish/h -> mp/h
 	int curvecount[2] = {0, 0};
 	/*first find the curve speed limit */
 	int numcurve = 0;
 	int sum = 0;
 	int pos = 0;
 	int lastpos = -1;
 	for (const Vehicle *u = v; u->Next() != NULL; u = u->Next(), pos++) {
-		Direction dir = u->direction;
+		Direction this_dir = u->direction;
-		Direction ndir = u->Next()->direction;
+		Direction next_dir = u->Next()->direction;
-		int i;
+		DirDiff dirdiff = DirDifference(this_dir, next_dir);
-		for (i = 0; i < 2; i++) {
+		if (dirdiff == DIRDIFF_SAME) continue;
-			if ( _curve_neighbours45[dir][i] == ndir) {
-				curvecount[i]++;
+		if (dirdiff == DIRDIFF_45LEFT) curvecount[0]++;
-				if (lastpos != -1) {
+		if (dirdiff == DIRDIFF_45RIGHT) curvecount[1]++;
-					numcurve++;
+		if (dirdiff == DIRDIFF_45LEFT || dirdiff == DIRDIFF_45RIGHT) {
-					sum += pos - lastpos;
+			if (lastpos != -1) {
-					if (pos - lastpos == 1) {
+				numcurve++;
-						max_speed = 88;
+				sum += pos - lastpos;
-					}
+				if (pos - lastpos == 1) {
+					max_speed = 88;
 				}
-				lastpos = pos;
+			}
-			}
+			lastpos = pos;
 		}
 		/*if we have a 90 degree turn, fix the speed limit to 60 */
-		if (_curve_neighbours90[dir][0] == ndir ||
+		if (dirdiff == DIRDIFF_90LEFT || dirdiff == DIRDIFF_90RIGHT) {
-				_curve_neighbours90[dir][1] == ndir) {
 			max_speed = 61;
 		}
 	}
-	if (numcurve > 0) sum /= numcurve;
 	if ((curvecount[0] != 0 || curvecount[1] != 0) && max_speed > 88) {
 		int total = curvecount[0] + curvecount[1];
 		if (curvecount[0] == 1 && curvecount[1] == 1) {
-			max_speed = 0xFFFF;
+			max_speed = absolute_max_speed;
 		} else if (total > 1) {
+			if (numcurve > 0) sum /= numcurve;
 			max_speed = 232 - (13 - Clamp(sum, 1, 12)) * (13 - Clamp(sum, 1, 12));
 		}
 	}
-	max_speed += (max_speed / 2) * v->u.rail.railtype;
+	if (max_speed != absolute_max_speed) {
+		/* Apply the engine's rail type curve speed advantage, if it slowed by curves */
+		const RailtypeInfo *rti = GetRailTypeInfo(v->u.rail.railtype);
+		max_speed += (max_speed / 2) * rti->curve_speed;
+		if (v->u.rail.cached_tilt) {
+			/* Apply max_speed bonus of 20% for a tilting train */
+			max_speed += max_speed / 5;
+		}
+	}
 	if (IsTileType(v->tile, MP_STATION) && IsFrontEngine(v)) {
 		if (TrainShouldStop(v, v->tile)) {
 			int station_length = GetStationByTile(v->tile)->GetPlatformLength(v->tile, DirToDiagDir(v->direction));
-			int delta_v;
+			int st_max_speed = 120;
-			max_speed = 120;
+			int delta_v = v->cur_speed / (station_length + 1);
-			delta_v = v->cur_speed / (station_length + 1);
+			if (v->max_speed > (v->cur_speed - delta_v)) {
-			if (v->max_speed > (v->cur_speed - delta_v))
+				st_max_speed = v->cur_speed - (delta_v / 10);
-				max_speed = v->cur_speed - (delta_v / 10);
+			}
-			max_speed = max(max_speed, 25 * station_length);
+			st_max_speed = max(st_max_speed, 25 * station_length);
+			max_speed = min(max_speed, st_max_speed);
 		}
 	}
 	int mass = v->u.rail.cached_weight;
 	int power = v->u.rail.cached_power * 746;
 	if (HasBit(this->u.rail.flags, VRF_REVERSE_DIRECTION)) direction = ReverseDir(direction);
 	if (is_custom_sprite(img)) {
 		base = GetCustomVehicleSprite(this, (Direction)(direction + 4 * IS_CUSTOM_SECONDHEAD_SPRITE(img)));
 		if (base != 0) return base;
-		img = orig_rail_vehicle_info[this->engine_type].image_index;
+		img = _orig_rail_vehicle_info[this->engine_type].image_index;
 	}
 	base = _engine_sprite_base[img] + ((direction + _engine_sprite_add[img]) & _engine_sprite_and[img]);
 	if (this->cargo.Count() >= this->cargo_cap / 2U) base += _wagon_full_adder[img];
 	SpriteID image = 0;
 	if (is_custom_sprite(img)) {
 		image = GetCustomVehicleIcon(engine, DIR_W);
 		if (image == 0) {
-			img = orig_rail_vehicle_info[engine].image_index;
+			img = _orig_rail_vehicle_info[engine].image_index;
 		} else {
 			y += _traininfo_vehicle_pitch;
 		}
 	}
 	if (image == 0) {
 		DrawSprite(image, pal, x - 14, y);
 		x += 15;
 		image = 0;
 		if (is_custom_sprite(img)) {
 			image = GetCustomVehicleIcon(engine, DIR_E);
-			if (image == 0) img = orig_rail_vehicle_info[engine].image_index;
+			if (image == 0) img = _orig_rail_vehicle_info[engine].image_index;
 		}
 		if (image == 0) {
 			image =
 				((6 + _engine_sprite_add[img + 1]) & _engine_sprite_and[img + 1]) +
 				_engine_sprite_base[img + 1];
 	DrawSprite(image, pal, x, y);
 }
 static CommandCost CmdBuildRailWagon(EngineID engine, TileIndex tile, uint32 flags)
 {
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	const RailVehicleInfo *rvi = RailVehInfo(engine);
-	CommandCost value((GetEngineProperty(engine, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8);
+	CommandCost value(EXPENSES_NEW_VEHICLES, (GetEngineProperty(engine, 0x17, rvi->base_cost) * _price.build_railwagon) >> 8);
 	uint num_vehicles = 1 + CountArticulatedParts(engine, false);
 	if (!(flags & DC_QUERY_COST)) {
 		/* Allow for the wagon and the articulated parts, plus one to "terminate" the list. */
 			}
 			GetPlayer(_current_player)->num_engines[engine]++;
 		}
 	}
-	return CommandCost(value);
+	return value;
 }
 /** Move all free vehicles in the depot to the train */
 static void NormalizeTrainVehInDepot(const Vehicle* u)
 {
 	}
 }
 static CommandCost EstimateTrainCost(EngineID engine, const RailVehicleInfo* rvi)
 {
-	return CommandCost(GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5);
+	return CommandCost(EXPENSES_NEW_VEHICLES, GetEngineProperty(engine, 0x17, rvi->base_cost) * (_price.build_railvehicle >> 3) >> 5);
 }
 static void AddRearEngineToMultiheadedTrain(Vehicle* v, Vehicle* u, bool building)
 {
 	u = new (u) Train();
 	if (!(flags & DC_QUERY_COST)) {
 		if (!IsTileDepotType(tile, TRANSPORT_RAIL)) return CMD_ERROR;
 		if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
 	}
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	const RailVehicleInfo *rvi = RailVehInfo(p1);
 	/* Check if depot and new engine uses the same kind of tracks */
 	/* We need to see if the engine got power on the tile to avoid eletric engines in non-electric depots */
 	if (!HasPowerOnRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 {
 	UnlinkWagon(v, v->First());
 	if (dest == NULL) return;
 	Vehicle *next = dest->Next();
+	v->SetNext(NULL);
 	dest->SetNext(v);
 	v->SetNext(next);
 	ClearFreeWagon(v);
 	ClearFrontEngine(v);
 }
 			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
 		if (flags & DC_EXEC) src->unitnumber = unit_num;
 	}
-	if (dst_head != NULL) {
+	/*
-		/* Check NewGRF Callback 0x1D */
+	 * Check whether the vehicles in the source chain are in the destination
-		uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, dst_head->engine_type, src, dst_head);
+	 * chain. This can easily be done by checking whether the first vehicle
-		if (callback != CALLBACK_FAILED) {
+	 * of the source chain is in the destination chain as the Next/Previous
-			if (callback == 0xFD) return_cmd_error(STR_INCOMPATIBLE_RAIL_TYPES);
+	 * pointers always make a doubly linked list of it where the assumption
-			if (callback < 0xFD) {
+	 * v->Next()->Previous() == v holds (assuming v->Next() != NULL).
-				StringID error = GetGRFStringID(GetEngineGRFID(dst_head->engine_type), 0xD000 + callback);
+	 */
-				return_cmd_error(error);
+	bool src_in_dst = false;
-			}
+	for (Vehicle *v = dst_head; !src_in_dst && v != NULL; v = v->Next()) src_in_dst = v == src;
-		}
+	/*
+	 * If the source chain is in the destination chain then the user is
+	 * only reordering the vehicles, thus not attaching a new vehicle.
+	 * Therefor the 'allow wagon attach' callback does not need to be
+	 * called. If it would be called strange things would happen because
+	 * one 'attaches' an already 'attached' vehicle causing more trouble
+	 * than it actually solves (infinite loops and such).
+	 */
+	if (dst_head != NULL && !src_in_dst) {
+		/*
+		 * When performing the 'allow wagon attach' callback, we have to check
+		 * that for each and every wagon, not only the first one. This means
+		 * that we have to test one wagon, attach it to the train and then test
+		 * the next wagon till we have reached the end. We have to restore it
+		 * to the state it was before we 'tried' attaching the train when the
+		 * attaching fails or succeeds because we are not 'only' doing this
+		 * in the DC_EXEC state.
+		 */
+		Vehicle *dst_tail = dst_head;
+		while (dst_tail->Next() != NULL) dst_tail = dst_tail->Next();
+		Vehicle *orig_tail = dst_tail;
+		Vehicle *next_to_attach = src;
+		Vehicle *src_previous = src->Previous();
+		while (next_to_attach != NULL) {
+			/* Back up and clear the first_engine data to avoid using wagon override group */
+			EngineID first_engine = next_to_attach->u.rail.first_engine;
+			next_to_attach->u.rail.first_engine = INVALID_ENGINE;
+			uint16 callback = GetVehicleCallbackParent(CBID_TRAIN_ALLOW_WAGON_ATTACH, 0, 0, dst_head->engine_type, next_to_attach, dst_head);
+			/* Restore original first_engine data */
+			next_to_attach->u.rail.first_engine = first_engine;
+			if (callback != CALLBACK_FAILED) {
+				StringID error = STR_NULL;
+				if (callback == 0xFD) error = STR_INCOMPATIBLE_RAIL_TYPES;
+				if (callback < 0xFD) error = GetGRFStringID(GetEngineGRFID(dst_head->engine_type), 0xD000 + callback);
+				if (error != STR_NULL) {
+					/*
+					 * The attaching is not allowed. In this case 'next_to_attach'
+					 * can contain some vehicles of the 'source' and the destination
+					 * train can have some too. We 'just' add the to-be added wagons
+					 * to the chain and then split it where it was previously
+					 * separated, i.e. the tail of the original destination train.
+					 * Furthermore the 'previous' link of the original source vehicle needs
+					 * to be restored, otherwise the train goes missing in the depot.
+					 */
+					dst_tail->SetNext(next_to_attach);
+					orig_tail->SetNext(NULL);
+					if (src_previous != NULL) src_previous->SetNext(src);
+					return_cmd_error(error);
+				}
+			}
+			/* Only check further wagons if told to move the chain */
+			if (!HasBit(p2, 0)) break;
+			/*
+			 * Adding a next wagon to the chain so we can test the other wagons.
+			 * First 'take' the first wagon from 'next_to_attach' and move it
+			 * to the next wagon. Then add that to the tail of the destination
+			 * train and update the tail with the new vehicle.
+			 */
+			Vehicle *to_add = next_to_attach;
+			next_to_attach = next_to_attach->Next();
+			to_add->SetNext(NULL);
+			dst_tail->SetNext(to_add);
+			dst_tail = dst_tail->Next();
+		}
+		/*
+		 * When we reach this the attaching is allowed. It also means that the
+		 * chain of vehicles to attach is empty, so we do not need to merge that.
+		 * This means only the splitting needs to be done.
+		 * Furthermore the 'previous' link of the original source vehicle needs
+		 * to be restored, otherwise the train goes missing in the depot.
+		 */
+		orig_tail->SetNext(NULL);
+		if (src_previous != NULL) src_previous->SetNext(src);
 	}
 	/* do it? */
 	if (flags & DC_EXEC) {
 		/* If we move the front Engine and if the second vehicle is not an engine
 	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (HASBITS(v->vehstatus, VS_CRASHED)) return_cmd_error(STR_CAN_T_SELL_DESTROYED_VEHICLE);
-	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 	while (IsArticulatedPart(v)) v = v->Previous();
 	Vehicle *first = v->First();
 	/* make sure the vehicle is stopped in the depot */
 	if (CheckTrainStoppedInDepot(first) < 0) {
 		}
 		InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
 		RebuildVehicleLists();
 	}
-	CommandCost cost;
+	CommandCost cost(EXPENSES_NEW_VEHICLES);
 	switch (p2) {
 		case 0: case 2: { /* Delete given wagon */
 			bool switch_engine = false;    // update second wagon to engine?
 			byte ori_subtype = v->subtype; // backup subtype of deleted wagon in case DeleteVehicle() changes
 }
 /* Check if the vehicle is a train and is on the tile we are testing */
 static void *TestTrainOnCrossing(Vehicle *v, void *data)
 {
-	if (v->tile != *(const TileIndex*)data || v->type != VEH_TRAIN) return NULL;
+	if (v->type != VEH_TRAIN) return NULL;
 	return v;
 }
 static void DisableTrainCrossing(TileIndex tile)
 {
 	if (IsLevelCrossingTile(tile) &&
-			VehicleFromPos(tile, &tile, TestTrainOnCrossing) == NULL && // empty?
+			IsCrossingBarred(tile) &&
-			IsCrossingBarred(tile)) {
+			VehicleFromPos(tile, NULL, &TestTrainOnCrossing) == NULL) { // empty?
 		UnbarCrossing(tile);
 		MarkTileDirtyByTile(tile);
 	}
 }
 		if (differential > 0) {
 			/* disconnect last car to make sure only this subset moves */
 			Vehicle *tempnext = last->Next();
 			last->SetNext(NULL);
+			/* do not update images now because the wagons are disconnected
+			 * and that could cause problems with NewGRFs */
 			for (int i = 0; i < differential; i++) TrainController(first, false);
 			last->SetNext(tempnext);
 		}
 		/* Check if the train left a rail/road-crossing */
 		DisableTrainCrossing(tile);
 	}
 	/* count number of vehicles */
-	int r = -1;
+	int r = 0;  ///< number of vehicles - 1
-	const Vehicle *u = v;
+	for (const Vehicle *u = v; (u = u->Next()) != NULL;) { r++; }
-	do r++; while ((u = u->Next()) != NULL);
 	AdvanceWagons(v, true);
 	/* swap start<>end, start+1<>end-1, ... */
 	int l = 0;
 	AdvanceWagons(v, false);
 	if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
+	/* update all images */
+	for (Vehicle *u = v; u != NULL; u = u->Next()) { u->cur_image = u->GetImage(u->direction); }
 	ClrBit(v->u.rail.flags, VRF_REVERSING);
 }
 /** Reverse train.
 	Vehicle *v = GetVehicle(p1);
 	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (CheckTrainStoppedInDepot(v) < 0) return_cmd_error(STR_TRAIN_MUST_BE_STOPPED);
+	if (v->vehstatus & VS_CRASHED) return_cmd_error(STR_CAN_T_REFIT_DESTROYED_VEHICLE);
 	/* Check cargo */
 	if (new_cid >= NUM_CARGO) return CMD_ERROR;
-	SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
+	CommandCost cost(EXPENSES_TRAIN_RUN);
-	CommandCost cost;
 	uint num = 0;
 	do {
 		/* XXX: We also refit all the attached wagons en-masse if they
 		 * can be refitted. This is how TTDPatch does it.  TODO: Have
 			}
 			break;
 		case 1:
 			/* diesel smoke */
-			if (u->cur_speed <= 40 && CHANCE16(15, 128)) {
+			if (u->cur_speed <= 40 && Chance16(15, 128)) {
 				CreateEffectVehicleRel(v, 0, 0, 10, EV_DIESEL_SMOKE);
 				sound = true;
 			}
 			break;
 		case 2:
 			/* blue spark */
-			if (GB(v->tick_counter, 0, 2) == 0 && CHANCE16(1, 45)) {
+			if (GB(v->tick_counter, 0, 2) == 0 && Chance16(1, 45)) {
 				CreateEffectVehicleRel(v, 0, 0, 10, EV_ELECTRIC_SPARK);
 				sound = true;
 			}
 			break;
 		}
 							TileX(new_tile) - TileX(old_tile) + 1;
 	assert(offs < 11);
 	return _new_vehicle_direction_table[offs];
 }
-static Direction GetNewVehicleDirection(const Vehicle *v, int x, int y)
-{
-	uint offs = (y - v->y_pos + 1) * 4 + (x - v->x_pos + 1);
-	assert(offs < 11);
-	return _new_vehicle_direction_table[offs];
-}
 static int GetDirectionToVehicle(const Vehicle *v, int x, int y)
 {
 	byte offs;
 	x -= v->x_pos;
 	tcc.num = 0;
 	/* find colliding vehicles */
 	if (v->u.rail.track == TRACK_BIT_WORMHOLE) {
 		VehicleFromPos(v->tile, &tcc, FindTrainCollideEnum);
-		if (IsBridgeTile(v->tile)) {
+		VehicleFromPos(GetOtherTunnelBridgeEnd(v->tile), &tcc, FindTrainCollideEnum);
-			VehicleFromPos(GetOtherBridgeEnd(v->tile), &tcc, FindTrainCollideEnum);
-		} else {
-			VehicleFromPos(GetOtherTunnelEnd(v->tile), &tcc, FindTrainCollideEnum);
-		}
 	} else {
 		VehicleFromPosXY(v->x_pos, v->y_pos, &tcc, FindTrainCollideEnum);
 	}
 	/* any dead -> no crash */
 	ModifyStationRatingAround(v->tile, v->owner, -160, 30);
 	SndPlayVehicleFx(SND_13_BIG_CRASH, v);
 }
-struct VehicleAtSignalData {
-	TileIndex tile;
-	Direction direction;
-};
 static void *CheckVehicleAtSignal(Vehicle *v, void *data)
 {
-	const VehicleAtSignalData* vasd = (VehicleAtSignalData*)data;
+	Direction dir = *(Direction*)data;
-	if (v->type == VEH_TRAIN && IsFrontEngine(v) && v->tile == vasd->tile) {
+	if (v->type == VEH_TRAIN && IsFrontEngine(v)) {
-		DirDiff diff = ChangeDirDiff(DirDifference(v->direction, vasd->direction), DIRDIFF_90RIGHT);
+		DirDiff diff = ChangeDirDiff(DirDifference(v->direction, dir), DIRDIFF_90RIGHT);
 		if (diff == DIRDIFF_90RIGHT || (v->cur_speed <= 5 && diff <= DIRDIFF_REVERSE)) return v;
 	}
 	return NULL;
 }
 							v->cur_speed = 0;
 							v->subspeed = 0;
 							v->progress = 255 - 10;
 							if (++v->load_unload_time_rem < _patches.wait_twoway_signal * 73) {
 								TileIndex o_tile = gp.new_tile + TileOffsByDiagDir(enterdir);
-								VehicleAtSignalData vasd;
+								Direction rdir = ReverseDir(dir);
-								vasd.tile = o_tile;
-								vasd.direction = ReverseDir(dir);
 								/* check if a train is waiting on the other side */
-								if (VehicleFromPos(o_tile, &vasd, CheckVehicleAtSignal) == NULL) return;
+								if (VehicleFromPos(o_tile, &rdir, &CheckVehicleAtSignal) == NULL) return;
 							}
 						}
 						goto reverse_train_direction;
 					}
 				} else {
 				if (prev == NULL) AffectSpeedByDirChange(v, chosen_dir);
 				v->direction = chosen_dir;
 			}
 		} else {
-			/* In tunnel or on a bridge */
+			/* 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);
 			}
 				continue;
 			}
 		}
 		/* update image of train, as well as delta XY */
-		Direction newdir = GetNewVehicleDirection(v, gp.x, gp.y);
+		v->UpdateDeltaXY(v->direction);
-		v->UpdateDeltaXY(newdir);
+		if (update_image) v->cur_image = v->GetImage(v->direction);
-		if (update_image) v->cur_image = v->GetImage(newdir);
 		v->x_pos = gp.x;
 		v->y_pos = gp.y;
 		/* update the Z position of the vehicle */
 	v->cur_speed = 0;
 	v->subspeed = 0;
 	ReverseTrainDirection(v);
 }
-extern TileIndex CheckTunnelBusy(TileIndex tile, uint *length);
 /**
 * Deletes/Clears the last wagon of a crashed train. It takes the engine of the
 * train, then goes to the last wagon and deletes that. Each call to this function
 * will remove the last wagon of a crashed train. If this wagon was on a crossing,
-* or inside a tunnel, recalculate the signals as they might need updating
+* or inside a tunnel/bridge, recalculate the signals as they might need updating
 * @param v the Vehicle of which last wagon is to be removed
 */
 static void DeleteLastWagon(Vehicle *v)
 {
 	/* Go to the last wagon and delete the link pointing there
 	/* Check if the wagon was on a road/rail-crossing and disable it if no
 	 * others are on it */
 	DisableTrainCrossing(v->tile);
-	if ((v->u.rail.track == TRACK_BIT_WORMHOLE && v->vehstatus & VS_HIDDEN)) { // inside a tunnel
+	if (v->u.rail.track == TRACK_BIT_WORMHOLE) { // inside a tunnel / bridge
-		TileIndex endtile = CheckTunnelBusy(v->tile, NULL);
+		TileIndex endtile = GetOtherTunnelBridgeEnd(v->tile);
-		if (endtile == INVALID_TILE) return; // tunnel is busy (error returned)
+		if (GetVehicleTunnelBridge(v->tile, endtile) != NULL) return; // tunnel / bridge is busy
-		switch (v->direction) {
+		DiagDirection dir = GetTunnelBridgeDirection(v->tile);
-			case 1:
-			case 5:
+		/* v->direction is "random", so it cannot be used to determine the direction of the track */
-				SetSignalsOnBothDir(v->tile, 0);
+		UpdateSignalsOnSegment(v->tile, dir);
-				SetSignalsOnBothDir(endtile, 0);
+		UpdateSignalsOnSegment(endtile, ReverseDiagDir(dir));
-				break;
-			case 3:
-			case 7:
-				SetSignalsOnBothDir(v->tile, 1);
-				SetSignalsOnBothDir(endtile, 1);
-				break;
-			default:
-				break;
-		}
 	}
 }
 static void ChangeTrainDirRandomly(Vehicle *v)
 {
 	if (state == 4 && !(v->vehstatus & VS_HIDDEN)) {
 		CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
 	}
 	uint32 r;
-	if (state <= 200 && CHANCE16R(1, 7, r)) {
+	if (state <= 200 && Chance16R(1, 7, r)) {
 		int index = (r * 10 >> 16);
 		Vehicle *u = v;
 		do {
 			if (--index < 0) {
 	if (v->u.rail.track == TRACK_BIT_DEPOT) return true; // exit if inside a depot
 	TileIndex tile = v->tile;
 	if (IsTileType(tile, MP_TUNNELBRIDGE)) {
-		DiagDirection dir = IsTunnel(tile) ? GetTunnelDirection(tile) : GetBridgeRampDirection(tile);
+		DiagDirection dir = GetTunnelBridgeDirection(tile);
 		if (DiagDirToDir(dir) == v->direction) return true;
 	}
 	// depot?
 	/* XXX -- When enabled, this makes it possible to crash trains of others
 			v->cur_speed = 0;
 			ReverseTrainDirection(v);
 			return false;
 		}
 		if ((ts &= (ts >> 16)) == 0) {
-			/* make a rail/road crossing red */
+			/* make a rail/road crossing red
-			if (IsLevelCrossingTile(tile)) {
+			 * do not make crossing red behind depot the train is entering */
+			if (IsLevelCrossingTile(tile) && (!IsTileDepotType(v->tile, TRANSPORT_RAIL) || GetRailDepotDirection(v->tile) == dir)) {
 				if (!IsCrossingBarred(tile)) {
 					BarCrossing(tile);
 					SndPlayVehicleFx(SND_0E_LEVEL_CROSSING, v);
 					MarkTileDirtyByTile(tile);
 				}
 	const Depot* depot = GetDepotByTile(tfdd.tile);
 	if (v->current_order.type == OT_GOTO_DEPOT &&
 			v->current_order.dest != depot->index &&
-			!CHANCE16(3, 16)) {
+			!Chance16(3, 16)) {
 		return;
 	}
 	v->current_order.type = OT_GOTO_DEPOT;
 	v->current_order.flags = OF_NON_STOP;
 			if (tile != 0) v->dest_tile = tile;
 		}
 		if ((v->vehstatus & VS_STOPPED) == 0) {
 			/* running costs */
-			CommandCost cost(v->GetRunningCost() / 364);
+			CommandCost cost(EXPENSES_TRAIN_RUN, v->GetRunningCost() / 364);
 			v->profit_this_year -= cost.GetCost() >> 8;
-			SET_EXPENSES_TYPE(EXPENSES_TRAIN_RUN);
 			SubtractMoneyFromPlayerFract(v->owner, cost);
 			InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 			InvalidateWindowClasses(WC_TRAINS_LIST);
 		}

branch	noai
changeset 9723	eee46cb39750
parent 9722	ebf0ece7d8f6
child 9724	b39bc69bb2f2