openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:5a9dc001e1ad
+:1c4a4a609f85
 #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 "player_func.h"
-#include "sound.h"
+#include "player_base.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 "signal_func.h"
+#include "variables.h"
+#include "autoreplace_gui.h"
+#include "gfx_func.h"
+#include "settings_type.h"
+#include "table/strings.h"
+#include "table/train_cmd.h"
 static bool TrainCheckIfLineEnds(Vehicle *v);
 static void TrainController(Vehicle *v, bool update_image);
+static TileIndex TrainApproachingCrossingTile(const Vehicle *v);
 static const byte _vehicle_initial_x_fract[4] = {10, 8, 4,  8};
 static const byte _vehicle_initial_y_fract[4] = { 8, 4, 8, 10};
-static const TrackBits _state_dir_table[4] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };
+/**
+* Determine the side in which the train will leave the tile
+*
+* @param direction vehicle direction
+* @param track vehicle track bits
+* @return side of tile the train will leave
+*/
+static inline DiagDirection TrainExitDir(Direction direction, TrackBits track)
+{
+	static const TrackBits state_dir_table[DIAGDIR_END] = { TRACK_BIT_RIGHT, TRACK_BIT_LOWER, TRACK_BIT_LEFT, TRACK_BIT_UPPER };
+	DiagDirection diagdir = DirToDiagDir(direction);
+	/* Determine the diagonal direction in which we will exit this tile */
+	if (!HasBit(direction, 0) && track != state_dir_table[diagdir]) {
+		diagdir = ChangeDiagDir(diagdir, DIAGDIRDIFF_90LEFT);
+	}
+	return diagdir;
+}
 /** Return the cargo weight multiplier to use for a rail vehicle
 * @param cargo Cargo type to get multiplier for
 * @return Cargo weight multiplier
 		if (total_power == 0) v->vehstatus |= VS_STOPPED;
 		v->u.rail.cached_power = total_power;
 		v->u.rail.cached_max_te = max_te;
 		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	}
 }
 /**
 	assert(IsFrontEngine(v) || IsFreeWagon(v));
 	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;
+	v->u.rail.compatible_railtypes = RAILTYPES_NONE;
+	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;
 			/* Some electric engines can be allowed to run on normal rail. It happens to all
 			 * existing electric engines when elrails are disabled and then re-enabled */
 			if (HasBit(u->u.rail.flags, VRF_EL_ENGINE_ALLOWED_NORMAL_RAIL)) {
 				u->u.rail.railtype = RAILTYPE_RAIL;
-				u->u.rail.compatible_railtypes |= (1 << RAILTYPE_RAIL);
+				u->u.rail.compatible_railtypes |= RAILTYPES_RAIL;
 			}
 			/* max speed is the minimum of the speed limits of all vehicles in the consist */
 			if ((rvi_u->railveh_type != RAILVEH_WAGON || _patches.wagon_speed_limits) && !UsesWagonOverride(u)) {
 				uint16 speed = GetVehicleProperty(u, 0x09, rvi_u->max_speed);
 		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
 };
 	StationID sid = GetStationIndex(tile);
 	assert(v->type == VEH_TRAIN);
 	/* When does a train drive through a station
 	 * first we deal with the "new nonstop handling" */
-	if (_patches.new_nonstop && o->flags & OF_NON_STOP && sid == o->dest) {
+	if (_patches.new_nonstop && o->flags & OFB_NON_STOP && sid == o->dest) {
 		return false;
 	}
 	if (v->last_station_visited == sid) return false;
-	if (sid != o->dest && (o->flags & OF_NON_STOP || _patches.new_nonstop)) {
+	if (sid != o->dest && (o->flags & OFB_NON_STOP || _patches.new_nonstop)) {
 		return false;
 	}
 	return true;
 }
 /** 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;
 			const Engine *e = GetEngine(p1);
 			v->reliability = e->reliability;
 			v->reliability_spd_dec = e->reliability_spd_dec;
 			v->max_age = e->lifelength * 366;
-			v->string_id = STR_SV_TRAIN_NAME;
+			v->name = NULL;
 			v->u.rail.railtype = rvi->railtype;
 			_new_vehicle_id = v->index;
 			v->service_interval = _patches.servint_trains;
 			v->date_of_last_service = _date;
 {
 	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 (IsFrontEngine(src_head)) {
 				UpdateTrainAcceleration(src_head);
 				InvalidateWindow(WC_VEHICLE_DETAILS, src_head->index);
 				/* Update the refit button and window */
 				InvalidateWindow(WC_VEHICLE_REFIT, src_head->index);
-				InvalidateWindowWidget(WC_VEHICLE_VIEW, src_head->index, 12);
+				InvalidateWindowWidget(WC_VEHICLE_VIEW, src_head->index, VVW_WIDGET_REFIT_VEH);
 			}
 			/* Update the depot window */
 			InvalidateWindow(WC_VEHICLE_DEPOT, src_head->tile);
 		}
 			UpdateTrainGroupID(dst_head);
 			if (IsFrontEngine(dst_head)) {
 				UpdateTrainAcceleration(dst_head);
 				InvalidateWindow(WC_VEHICLE_DETAILS, dst_head->index);
 				/* Update the refit button and window */
-				InvalidateWindowWidget(WC_VEHICLE_VIEW, dst_head->index, 12);
+				InvalidateWindowWidget(WC_VEHICLE_VIEW, dst_head->index, VVW_WIDGET_REFIT_VEH);
 				InvalidateWindow(WC_VEHICLE_REFIT, dst_head->index);
 			}
 			/* Update the depot window */
 			InvalidateWindow(WC_VEHICLE_DEPOT, dst_head->tile);
 		}
 		if (v->vehstatus & VS_STOPPED && v->u.rail.track == TRACK_BIT_DEPOT) {
 			DeleteVehicleNews(p1, STR_8814_TRAIN_IS_WAITING_IN_DEPOT);
 		}
 		v->vehstatus ^= VS_STOPPED;
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
 	}
 	return CommandCost();
 }
 	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
 {
 	int old = v->u.rail.last_speed;
 	if (spd != old) {
 		v->u.rail.last_speed = spd;
 		if (_patches.vehicle_speed || (old == 0) != (spd == 0))
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 	}
 }
 static void SwapTrainFlags(byte *swap_flag1, byte *swap_flag2)
 {
 	/* Update train's power incase tiles were different rail type */
 	TrainPowerChanged(v);
 }
-/* Check if the vehicle is a train and is on the tile we are testing */
-static void *TestTrainOnCrossing(Vehicle *v, void *data)
+/**
-{
+* Check if the vehicle is a train
-	if (v->tile != *(const TileIndex*)data || v->type != VEH_TRAIN) return NULL;
+* @param v vehicle on tile
+* @return v if it is a train, NULL otherwise
+*/
+static void *TrainOnTileEnum(Vehicle *v, void *)
+{
+	return (v->type == VEH_TRAIN) ? v : NULL;
+}
+/**
+* Checks if a train is approaching a rail-road crossing
+* @param v vehicle on tile
+* @param data tile with crossing we are testing
+* @return v if it is approaching a crossing, NULL otherwise
+*/
+static void *TrainApproachingCrossingEnum(Vehicle *v, void *data)
+{
+	/* not a train || not front engine || crashed */
+	if (v->type != VEH_TRAIN || !IsFrontEngine(v) || v->vehstatus & VS_CRASHED) return NULL;
+	TileIndex tile = *(TileIndex*)data;
+	if (TrainApproachingCrossingTile(v) != tile) return NULL;
 	return v;
 }
-static void DisableTrainCrossing(TileIndex tile)
-{
+/**
-	if (IsLevelCrossingTile(tile) &&
+* Finds a vehicle approaching rail-road crossing
-			VehicleFromPos(tile, &tile, TestTrainOnCrossing) == NULL && // empty?
+* @param tile tile to test
-			IsCrossingBarred(tile)) {
+* @return pointer to vehicle approaching the crossing
-		UnbarCrossing(tile);
+* @pre tile is a rail-road crossing
+*/
+static Vehicle *TrainApproachingCrossing(TileIndex tile)
+{
+	assert(IsLevelCrossingTile(tile));
+	DiagDirection dir = AxisToDiagDir(OtherAxis(GetCrossingRoadAxis(tile)));
+	TileIndex tile_from = tile + TileOffsByDiagDir(dir);
+	Vehicle *v = (Vehicle *)VehicleFromPos(tile_from, &tile, &TrainApproachingCrossingEnum);
+	if (v != NULL) return v;
+	dir = ReverseDiagDir(dir);
+	tile_from = tile + TileOffsByDiagDir(dir);
+	return (Vehicle *)VehicleFromPos(tile_from, &tile, &TrainApproachingCrossingEnum);
+}
+/**
+* Sets correct crossing state
+* @param tile tile to update
+* @param sound should we play sound?
+* @pre tile is a rail-road crossing
+*/
+void UpdateLevelCrossing(TileIndex tile, bool sound)
+{
+	assert(IsLevelCrossingTile(tile));
+	/* train on crossing || train approaching crossing */
+	bool new_state = VehicleFromPos(tile, NULL, &TrainOnTileEnum) || TrainApproachingCrossing(tile);
+	if (new_state != IsCrossingBarred(tile)) {
+		if (new_state && sound) {
+			SndPlayTileFx(SND_0E_LEVEL_CROSSING, tile);
+		}
+		SetCrossingBarred(tile, new_state);
 		MarkTileDirtyByTile(tile);
 	}
 }
+/**
+* Bars crossing and plays ding-ding sound if not barred already
+* @param tile tile with crossing
+* @pre tile is a rail-road crossing
+*/
+static inline void MaybeBarCrossingWithSound(TileIndex tile)
+{
+	if (!IsCrossingBarred(tile)) {
+		BarCrossing(tile);
+		SndPlayTileFx(SND_0E_LEVEL_CROSSING, tile);
+		MarkTileDirtyByTile(tile);
+	}
+}
 /**
 * Advances wagons for train reversing, needed for variable length wagons.
 * Needs to be called once before the train is reversed, and once after it.
 * @param v First vehicle in chain
 		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);
 		}
 	if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
 	/* Check if we were approaching a rail/road-crossing */
-	{
+	TileIndex crossing = TrainApproachingCrossingTile(v);
-		TileIndex tile = v->tile;
-		DiagDirection dir = DirToDiagDir(v->direction);
-		/* Determine the diagonal direction in which we will exit this tile */
-		if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[dir]) {
-			dir = ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT);
-		}
-		/* Calculate next tile */
-		tile += TileOffsByDiagDir(dir);
-		/* 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;
 	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);
+	/* update crossing we were approaching */
+	if (crossing != INVALID_TILE) UpdateLevelCrossing(crossing);
+	/* maybe we are approaching crossing now, after reversal */
+	crossing = TrainApproachingCrossingTile(v);
+	if (crossing != INVALID_TILE) MaybeBarCrossingWithSound(crossing);
 }
 /** Reverse train.
 * @param tile unused
 * @param flags type of operation
 	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
 			tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;
 			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;
 		}
 	} else {
 		/* search in the forward direction first. */
-		DiagDirection i = DirToDiagDir(v->direction);
+		DiagDirection i = TrainExitDir(v->direction, v->u.rail.track);
-		if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
-			i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
-		}
 		NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
 		if (tfdd.best_length == (uint)-1){
 			tfdd.reverse = true;
 			/* search in backwards direction */
-			i = ReverseDiagDir(DirToDiagDir(v->direction));
+			i = TrainExitDir(ReverseDir(v->direction), v->u.rail.track);
-			if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[i]) {
-				i = ChangeDiagDir(i, DIAGDIRDIFF_90LEFT);
-			}
 			NewTrainPathfind(tile, 0, v->u.rail.compatible_railtypes, i, (NTPEnumProc*)NtpCallbFindDepot, &tfdd);
 		}
 	}
 	return tfdd;
 	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
 	if (v->vehstatus & VS_CRASHED) return CMD_ERROR;
 	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, OF_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, OF_PART_OF_ORDERS);
-				ToggleBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
+				ToggleBit(v->current_order.flags, OF_HALT_IN_DEPOT);
-				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+				InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 			}
 			return CommandCost();
 		}
 		if (p2 & DEPOT_DONT_CANCEL) return CMD_ERROR; // Requested no cancelation of depot orders
 		if (flags & DC_EXEC) {
-			if (HasBit(v->current_order.flags, OFB_PART_OF_ORDERS)) {
+			if (HasBit(v->current_order.flags, OF_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);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return CommandCost();
 	}
 	/* check if at a standstill (not stopped only) in a depot
 	if (flags & DC_EXEC) {
 		if (v->current_order.type == OT_LOADING) v->LeaveStation();
 		v->dest_tile = tfdd.tile;
 		v->current_order.type = OT_GOTO_DEPOT;
-		v->current_order.flags = OF_NON_STOP;
+		v->current_order.flags = OFB_NON_STOP;
-		if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OFB_HALT_IN_DEPOT);
+		if (!(p2 & DEPOT_SERVICE)) SetBit(v->current_order.flags, OF_HALT_IN_DEPOT);
 		v->current_order.dest = GetDepotByTile(tfdd.tile)->index;
 		v->current_order.refit_cargo = CT_INVALID;
-		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		/* If there is no depot in front, reverse automatically */
 		if (tfdd.reverse) DoCommand(v->tile, v->index, 0, DC_EXEC, CMD_REVERSE_TRAIN_DIRECTION);
 	}
 	return CommandCost();
 			return true;
 		}
 		v->load_unload_time_rem = 0;
-		if (UpdateSignalsOnSegment(v->tile, DirToDiagDir(v->direction))) {
+		if (UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner)) {
 			InvalidateWindowClasses(WC_TRAINS_LIST);
 			return true;
 		}
 	}
 	v->cur_speed = 0;
 	v->UpdateDeltaXY(v->direction);
 	v->cur_image = v->GetImage(v->direction);
 	VehiclePositionChanged(v);
-	UpdateSignalsOnSegment(v->tile, DirToDiagDir(v->direction));
+	UpdateSignalsOnSegment(v->tile, INVALID_DIAGDIR, v->owner);
 	UpdateTrainAcceleration(v);
 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	return false;
 }
 static bool ProcessTrainOrder(Vehicle *v)
 {
 	switch (v->current_order.type) {
 		case OT_GOTO_DEPOT:
-			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return false;
+			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return false;
-			if ((v->current_order.flags & OF_SERVICE_IF_NEEDED) &&
+			if ((v->current_order.flags & OFB_SERVICE_IF_NEEDED) &&
 					!VehicleNeedsService(v)) {
 				UpdateVehicleTimetable(v, true);
 				v->cur_order_index++;
 			}
 			break;
 		v->cur_order_index++;
 	}
 	/* check if we've reached a non-stop station while TTDPatch nonstop is enabled.. */
 	if (_patches.new_nonstop &&
-			v->current_order.flags & OF_NON_STOP &&
+			v->current_order.flags & OFB_NON_STOP &&
 			IsTileType(v->tile, MP_STATION) &&
 			v->current_order.dest == GetStationIndex(v->tile)) {
 		UpdateVehicleTimetable(v, true);
 		v->cur_order_index++;
 	}
 void Train::MarkDirty()
 {
 	Vehicle *v = this;
 	do {
 		v->cur_image = v->GetImage(v->direction);
-		MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
+		MarkSingleVehicleDirty(v);
 	} while ((v = v->Next()) != NULL);
 	/* need to update acceleration and cached values since the goods on the train changed. */
 	TrainCargoChanged(this);
 	UpdateTrainAcceleration(this);
 							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;
 static void TrainMovedChangeSignals(TileIndex tile, DiagDirection dir)
 {
 	if (IsTileType(tile, MP_RAILWAY) &&
 			GetRailTileType(tile) == RAIL_TILE_SIGNALS) {
 		uint i = FindFirstBit2x64(GetTrackBits(tile) * 0x101 & _reachable_tracks[dir]);
-		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i]);
+		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i], GetTileOwner(tile));
 	}
 }
 static void SetVehicleCrashed(Vehicle *v)
 {
 	if (v->u.rail.crash_anim_pos != 0) return;
+	/* we may need to update crossing we were approaching */
+	TileIndex crossing = TrainApproachingCrossingTile(v);
 	v->u.rail.crash_anim_pos++;
-	Vehicle *u = v;
+	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
+	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+	if (v->u.rail.track == TRACK_BIT_DEPOT) {
+		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
+	}
+	RebuildVehicleLists();
 	BEGIN_ENUM_WAGONS(v)
 		v->vehstatus |= VS_CRASHED;
+		MarkSingleVehicleDirty(v);
 	END_ENUM_WAGONS(v)
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, u->index, STATUS_BAR);
+	/* must be updated after the train has been marked crashed */
+	if (crossing != INVALID_TILE) UpdateLevelCrossing(crossing);
 }
 static uint CountPassengersInTrain(const Vehicle* v)
 {
 	uint num = 0;
 	return num;
 }
 struct TrainCollideChecker {
 	Vehicle *v;
-	const Vehicle *v_skip;
 	uint num;
 };
 static void *FindTrainCollideEnum(Vehicle *v, void *data)
 {
 	TrainCollideChecker* tcc = (TrainCollideChecker*)data;
-	if (v != tcc->v &&
+	if (v->type != VEH_TRAIN) return NULL;
-			v != tcc->v_skip &&
-			v->type == VEH_TRAIN &&
+	/* get first vehicle now to make most usual checks faster */
-			v->u.rail.track != TRACK_BIT_DEPOT &&
+	Vehicle *coll = v->First();
-			abs(v->z_pos - tcc->v->z_pos) < 6 &&
-			abs(v->x_pos - tcc->v->x_pos) < 6 &&
+	/* can't collide with own wagons && can't crash in depot && the same height level */
-			abs(v->y_pos - tcc->v->y_pos) < 6 ) {
+	if (coll != tcc->v && v->u.rail.track != TRACK_BIT_DEPOT && abs(v->z_pos - tcc->v->z_pos) < 6) {
+		int x_diff = v->x_pos - tcc->v->x_pos;
-		Vehicle *coll = v->First();
+		int y_diff = v->y_pos - tcc->v->y_pos;
-		/* it can't collide with its own wagons */
+		/* needed to disable possible crash of competitor train in station by building diagonal track at its end */
-		if (tcc->v == coll ||
+		if (x_diff * x_diff + y_diff * y_diff > 25) return NULL;
-			(tcc->v->u.rail.track == TRACK_BIT_WORMHOLE && (tcc->v->direction & 2) != (v->direction & 2)))
-			return NULL;
-		/* two drivers + passengers killed in train tcc->v (if it was not crashed already) */
 		if (!(tcc->v->vehstatus & VS_CRASHED)) {
+			/* two drivers + passengers killed in train tcc->v (if it was not crashed already) */
 			tcc->num += 2 + CountPassengersInTrain(tcc->v);
 			SetVehicleCrashed(tcc->v);
 		}
 		if (!(coll->vehstatus & VS_CRASHED)) {
 	assert(v->u.rail.track == TRACK_BIT_WORMHOLE || TileVirtXY(v->x_pos, v->y_pos) == v->tile);
 	TrainCollideChecker tcc;
 	tcc.v = v;
-	tcc.v_skip = v->Next();
 	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;
 }
 	Vehicle *prev;
 	/* For every vehicle after and including the given vehicle */
 	for (prev = v->Previous(); v != NULL; prev = v, v = v->Next()) {
 		DiagDirection enterdir = DIAGDIR_BEGIN;
-		bool update_signals = false;
+		bool update_signals_crossing = false; // will we update signals or crossing state?
 		BeginVehicleMove(v);
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 		if (v->u.rail.track != TRACK_BIT_WORMHOLE) {
 			/* Not inside tunnel */
 						return;
 					}
 					if (v->current_order.type == OT_LEAVESTATION) {
 						v->current_order.Free();
-						InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+						InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 					}
 				}
 			} else {
 				/* A new tile is about to be entered. */
 							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 {
 				uint32 r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);
 				if (HasBit(r, VETS_CANNOT_ENTER)) {
 					goto invalid_rail;
 				}
-				if (IsLevelCrossingTile(v->tile) && v->Next() == NULL) {
-					UnbarCrossing(v->tile);
-					MarkTileDirtyByTile(v->tile);
-				}
 				if (IsFrontEngine(v)) v->load_unload_time_rem = 0;
 				if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {
 					v->tile = gp.new_tile;
 					assert(v->u.rail.track);
 				}
 				/* We need to update signal status, but after the vehicle position hash
 				 * has been updated by AfterSetTrainPos() */
-				update_signals = true;
+				update_signals_crossing = true;
 				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 */
 		if (prev == NULL) {
 			/* This is the first vehicle in the train */
 			AffectSpeedByZChange(v, old_z);
 		}
-		if (update_signals) {
+		if (update_signals_crossing) {
 			if (IsFrontEngine(v)) TrainMovedChangeSignals(gp.new_tile, enterdir);
 			/* Signals can only change when the first
 			 * (above) or the last vehicle moves. */
-			if (v->Next() == NULL) TrainMovedChangeSignals(gp.old_tile, ReverseDiagDir(enterdir));
+			if (v->Next() == NULL) {
+				TrainMovedChangeSignals(gp.old_tile, ReverseDiagDir(enterdir));
+				if (IsLevelCrossingTile(gp.old_tile)) UpdateLevelCrossing(gp.old_tile);
+			}
 		}
 	}
 	return;
 invalid_rail:
 	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)
 {
+	Vehicle *first = v->First();
 	/* Go to the last wagon and delete the link pointing there
 	 * *u is then the one-before-last wagon, and *v the last
 	 * one which will physicially be removed */
 	Vehicle *u = v;
 	for (; v->Next() != NULL; v = v->Next()) u = v;
 	u->SetNext(NULL);
-	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+	if (first == v) {
-	DeleteWindowById(WC_VEHICLE_VIEW, v->index);
+		/* Removing front vehicle (the last to go) */
+		DeleteWindowById(WC_VEHICLE_VIEW, v->index);
+		InvalidateWindow(WC_COMPANY, v->owner);
+	} else {
+		/* Recalculate cached train properties */
+		TrainConsistChanged(first);
+		InvalidateWindow(WC_VEHICLE_DETAILS, first->index);
+		/* Update the depot window if the first vehicle is in depot -
+		 * if v == first, then it is updated in PreDestructor() */
+		if (first->u.rail.track == TRACK_BIT_DEPOT) {
+			InvalidateWindow(WC_VEHICLE_DEPOT, first->tile);
+		}
+	}
 	RebuildVehicleLists();
-	InvalidateWindow(WC_COMPANY, v->owner);
+	MarkSingleVehicleDirty(v);
-	BeginVehicleMove(v);
-	EndVehicleMove(v);
+	/* 'v' shouldn't be accessed after it has been deleted */
+	TrackBits track = v->u.rail.track;
+	TileIndex tile = v->tile;
+	Owner owner = v->owner;
 	delete v;
+	v = NULL; // make sure nobody will won't try to read 'v' anymore
-	if (v->u.rail.track != TRACK_BIT_DEPOT && v->u.rail.track != TRACK_BIT_WORMHOLE)
-		SetSignalsOnBothDir(v->tile, FIND_FIRST_BIT(v->u.rail.track));
+	/* check if the wagon was on a road/rail-crossing */
+	if (IsLevelCrossingTile(tile)) UpdateLevelCrossing(tile);
-	/* Check if the wagon was on a road/rail-crossing and disable it if no
-	 * others are on it */
+	/* Update signals */
-	DisableTrainCrossing(v->tile);
+	if (IsTileType(tile, MP_TUNNELBRIDGE) || IsTileDepotType(tile, TRANSPORT_RAIL)) {
+		UpdateSignalsOnSegment(tile, INVALID_DIAGDIR, owner);
-	if ((v->u.rail.track == TRACK_BIT_WORMHOLE && v->vehstatus & VS_HIDDEN)) { // inside a tunnel
+	} else {
-		TileIndex endtile = CheckTunnelBusy(v->tile, NULL);
+		SetSignalsOnBothDir(tile, (Track)(FIND_FIRST_BIT(track)), owner);
-		if (endtile == INVALID_TILE) return; // tunnel is busy (error returned)
-		switch (v->direction) {
-			case 1:
-			case 5:
-				SetSignalsOnBothDir(v->tile, 0);
-				SetSignalsOnBothDir(endtile, 0);
-				break;
-			case 3:
-			case 7:
-				SetSignalsOnBothDir(v->tile, 1);
-				SetSignalsOnBothDir(endtile, 1);
-				break;
-			default:
-				break;
-		}
 	}
 }
 static void ChangeTrainDirRandomly(Vehicle *v)
 {
 			InvalidateWindow(WC_VEHICLE_VIEW, v->index);
 		}
 	}
 }
-static const byte _breakdown_speeds[16] = {
+/** Maximum speeds for train that is broken down or approaching line end */
+static const uint16 _breakdown_speeds[16] = {
 	225, 210, 195, 180, 165, 150, 135, 120, 105, 90, 75, 60, 45, 30, 15, 15
 };
+/**
+* Train is approaching line end, slow down and possibly reverse
+*
+* @param v front train engine
+* @param signal not line end, just a red signal
+* @return true iff we did NOT have to reverse
+*/
+static bool TrainApproachingLineEnd(Vehicle *v, bool signal)
+{
+	/* Calc position within the current tile */
+	uint x = v->x_pos & 0xF;
+	uint y = v->y_pos & 0xF;
+	/* for diagonal directions, 'x' will be 0..15 -
+	 * for other directions, it will be 1, 3, 5, ..., 15 */
+	switch (v->direction) {
+		case DIR_N : x = ~x + ~y + 25; break;
+		case DIR_NW: x = y;            /* FALLTHROUGH */
+		case DIR_NE: x = ~x + 16;      break;
+		case DIR_E : x = ~x + y + 9;   break;
+		case DIR_SE: x = y;            break;
+		case DIR_S : x = x + y - 7;    break;
+		case DIR_W : x = ~y + x + 9;   break;
+		default: break;
+	}
+	/* do not reverse when approaching red signal */
+	if (!signal && x + 4 >= TILE_SIZE) {
+		/* we are too near the tile end, reverse now */
+		v->cur_speed = 0;
+		ReverseTrainDirection(v);
+		return false;
+	}
+	/* slow down */
+	v->vehstatus |= VS_TRAIN_SLOWING;
+	uint16 break_speed = _breakdown_speeds[x & 0xF];
+	if (break_speed < v->cur_speed) v->cur_speed = break_speed;
+	return true;
+}
+/**
+* Determines whether train would like to leave the tile
+* @param v train to test
+* @return true iff vehicle is NOT entering or inside a depot or tunnel/bridge
+*/
+static bool TrainCanLeaveTile(const Vehicle *v)
+{
+	/* Exit if inside a tunnel/bridge or a depot */
+	if (v->u.rail.track == TRACK_BIT_WORMHOLE || v->u.rail.track == TRACK_BIT_DEPOT) return false;
+	TileIndex tile = v->tile;
+	/* entering a tunnel/bridge? */
+	if (IsTileType(tile, MP_TUNNELBRIDGE)) {
+		DiagDirection dir = GetTunnelBridgeDirection(tile);
+		if (DiagDirToDir(dir) == v->direction) return false;
+	}
+	/* entering a depot? */
+	if (IsTileDepotType(tile, TRANSPORT_RAIL)) {
+		DiagDirection dir = ReverseDiagDir(GetRailDepotDirection(tile));
+		if (DiagDirToDir(dir) == v->direction) return false;
+	}
+	return true;
+}
+/**
+* Determines whether train is approaching a rail-road crossing
+*   (thus making it barred)
+* @param v front engine of train
+* @return TileIndex of crossing the train is approaching, else INVALID_TILE
+* @pre v in non-crashed front engine
+*/
+static TileIndex TrainApproachingCrossingTile(const Vehicle *v)
+{
+	assert(IsFrontEngine(v));
+	assert(!(v->vehstatus & VS_CRASHED));
+	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 */
+	if (!IsLevelCrossingTile(tile) || DiagDirToAxis(dir) == GetCrossingRoadAxis(tile) ||
+			!CheckCompatibleRail(v, tile) || GetTileOwner(tile) != v->owner) {
+		return INVALID_TILE;
+	}
+	return tile;
+}
+/**
+* Checks for line end. Also, bars crossing at next tile if needed
+*
+* @param v vehicle we are checking
+* @return true iff we did NOT have to reverse
+*/
 static bool TrainCheckIfLineEnds(Vehicle *v)
 {
+	/* First, handle broken down train */
 	int t = v->breakdown_ctr;
 	if (t > 1) {
 		v->vehstatus |= VS_TRAIN_SLOWING;
 		uint16 break_speed = _breakdown_speeds[GB(~t, 4, 4)];
 		if (break_speed < v->cur_speed) v->cur_speed = break_speed;
 	} else {
 		v->vehstatus &= ~VS_TRAIN_SLOWING;
 	}
-	if (v->u.rail.track == TRACK_BIT_WORMHOLE) return true; // exit if inside a tunnel
+	if (!TrainCanLeaveTile(v)) return true;
-	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);
-		if (DiagDirToDir(dir) == v->direction) return true;
-	}
-	// depot?
-	/* XXX -- When enabled, this makes it possible to crash trains of others
-	     (by building a depot right against a station) */
-/*	if (IsTileType(tile, MP_RAILWAY) && GetRailTileType(tile) == RAIL_TILE_DEPOT_WAYPOINT)
-		return true;*/
 	/* Determine the non-diagonal direction in which we will exit this tile */
-	DiagDirection dir = DirToDiagDir(v->direction);
+	DiagDirection dir = TrainExitDir(v->direction, v->u.rail.track);
-	if (!(v->direction & 1) && v->u.rail.track != _state_dir_table[dir]) {
-		dir = ChangeDiagDir(dir, DIAGDIRDIFF_90LEFT);
-	}
 	/* Calculate next tile */
-	tile += TileOffsByDiagDir(dir);
+	TileIndex tile = v->tile + TileOffsByDiagDir(dir);
-	// determine the track status on the next tile.
+	/* Determine the track status on the next tile */
 	uint32 ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0) & _reachable_tracks[dir];
-	/* Calc position within the current tile ?? */
+	/* We are sure the train is not entering a depot, it is detected above */
-	uint x = v->x_pos & 0xF;
-	uint y = v->y_pos & 0xF;
+	/* no suitable trackbits at all || wrong railtype || not our track ||
+	 *   tunnel/bridge from opposite side || depot from opposite side */
-	switch (v->direction) {
+	if (GB(ts, 0, 16) == 0 || !CheckCompatibleRail(v, tile) || GetTileOwner(tile) != v->owner ||
-		case DIR_N : x = ~x + ~y + 24; break;
+			(IsTileType(tile, MP_TUNNELBRIDGE) && GetTunnelBridgeDirection(tile) != dir) ||
-		case DIR_NW: x = y;            /* FALLTHROUGH */
+			(IsTileDepotType(tile, TRANSPORT_RAIL) && GetRailDepotDirection(tile) == dir) ) {
-		case DIR_NE: x = ~x + 16;      break;
+		return TrainApproachingLineEnd(v, false);
-		case DIR_E : x = ~x + y + 8;   break;
+	}
-		case DIR_SE: x = y;            break;
-		case DIR_S : x = x + y - 8;    break;
+	/* approaching red signal */
-		case DIR_W : x = ~y + x + 8;   break;
+	if ((ts & (ts >> 16)) != 0) return TrainApproachingLineEnd(v, true);
-		default: break;
-	}
+	/* approaching a rail/road crossing? then make it red */
+	if (IsLevelCrossingTile(tile)) MaybeBarCrossingWithSound(tile);
-	if (GB(ts, 0, 16) != 0) {
-		/* If we approach a rail-piece which we can't enter, or the back of a depot, don't enter it! */
-		if (x + 4 >= TILE_SIZE &&
-				(!CheckCompatibleRail(v, tile) ||
-				(IsTileDepotType(tile, TRANSPORT_RAIL) &&
-				GetRailDepotDirection(tile) == dir))) {
-			v->cur_speed = 0;
-			ReverseTrainDirection(v);
-			return false;
-		}
-		if ((ts &= (ts >> 16)) == 0) {
-			/* make a rail/road crossing red */
-			if (IsLevelCrossingTile(tile)) {
-				if (!IsCrossingBarred(tile)) {
-					BarCrossing(tile);
-					SndPlayVehicleFx(SND_0E_LEVEL_CROSSING, v);
-					MarkTileDirtyByTile(tile);
-				}
-			}
-			return true;
-		}
-	} else if (x + 4 >= TILE_SIZE) {
-		v->cur_speed = 0;
-		ReverseTrainDirection(v);
-		return false;
-	}
-	/* slow down */
-	v->vehstatus |= VS_TRAIN_SLOWING;
-	uint16 break_speed = _breakdown_speeds[x & 0xF];
-	if (!(v->direction & 1)) break_speed >>= 1;
-	if (break_speed < v->cur_speed) v->cur_speed = break_speed;
 	return true;
 }
 static void TrainLocoHandler(Vehicle *v, bool mode)
 {
 	/* train has crashed? */
 	if (v->vehstatus & VS_CRASHED) {
 			/* If we were already heading for a depot but it has
 			 * suddenly moved farther away, we continue our normal
 			 * schedule? */
 			v->current_order.type = OT_DUMMY;
 			v->current_order.flags = 0;
-			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return;
 	}
 	const Depot* depot = GetDepotByTile(tfdd.tile);
 			!Chance16(3, 16)) {
 		return;
 	}
 	v->current_order.type = OT_GOTO_DEPOT;
-	v->current_order.flags = OF_NON_STOP;
+	v->current_order.flags = OFB_NON_STOP;
 	v->current_order.dest = depot->index;
 	v->dest_tile = tfdd.tile;
-	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
+	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 }
 void OnNewDay_Train(Vehicle *v)
 {
 	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);
 			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	NewGRF_ports
changeset 6872	1c4a4a609f85
parent 6871	5a9dc001e1ad
child 6877	889301acc299