openttd-ottdgrfs: comparison src/train

equal deleted inserted replaced

-:eec5a7dcbf61
+:fcf5fb2548eb
 #include "tile_cmd.h"
 #include "landscape.h"
 #include "gui.h"
 #include "station_map.h"
 #include "tunnel_map.h"
-#include "timetable.h"
 #include "articulated_vehicles.h"
 #include "command_func.h"
 #include "pathfind.h"
 #include "npf.h"
-#include "station.h"
+#include "station_base.h"
-#include "news.h"
+#include "news_func.h"
-#include "engine.h"
+#include "engine_func.h"
 #include "player_func.h"
 #include "player_base.h"
 #include "depot.h"
 #include "waypoint.h"
 #include "vehicle_gui.h"
 #include "signal_func.h"
 #include "variables.h"
 #include "autoreplace_gui.h"
 #include "gfx_func.h"
 #include "settings_type.h"
+#include "order_func.h"
 #include "table/strings.h"
 #include "table/train_cmd.h"
 static bool TrainCheckIfLineEnds(Vehicle *v);
-static void TrainController(Vehicle *v, bool update_image);
+static void TrainController(Vehicle *v, Vehicle *nomove, 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};
 /**
 * Recalculates the cached total power of a train. Should be called when the consist is changed
 * @param v First vehicle of the consist.
 */
-void TrainPowerChanged(Vehicle* v)
+void TrainPowerChanged(Vehicle *v)
 {
 	uint32 total_power = 0;
 	uint32 max_te = 0;
 	for (const Vehicle *u = v; u != NULL; u = u->Next()) {
 /**
 * Recalculates the cached weight of a train and its vehicles. Should be called each time the cargo on
 * the consist changes.
 * @param v First vehicle of the consist.
 */
-static void TrainCargoChanged(Vehicle* v)
+static void TrainCargoChanged(Vehicle *v)
 {
 	uint32 weight = 0;
 	for (Vehicle *u = v; u != NULL; u = u->Next()) {
 		uint32 vweight = GetCargo(u->cargo_type)->weight * u->cargo.Count() * FreightWagonMult(u->cargo_type) / 16;
 * Recalculates the cached stuff of a train. Should be called each time a vehicle is added
 * to/removed from the chain, and when the game is loaded.
 * Note: this needs to be called too for 'wagon chains' (in the depot, without an engine)
 * @param v First vehicle of the chain.
 */
-void TrainConsistChanged(Vehicle* v)
+void TrainConsistChanged(Vehicle *v)
 {
-	uint16 max_speed = 0xFFFF;
+	uint16 max_speed = UINT16_MAX;
 	assert(v->type == VEH_TRAIN);
 	assert(IsFrontEngine(v) || IsFreeWagon(v));
 	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);
 		/* Cache wagon override sprite group. NULL is returned if there is none */
 		u->u.rail.cached_override = GetWagonOverrideSpriteSet(u->engine_type, u->cargo_type, u->u.rail.first_engine);
 		/* Reset color map */
 		u->colormap = PAL_NONE;
+		/* Set user defined data (must be done before other properties) */
+		u->u.rail.user_def_data = GetVehicleProperty(u, 0x25, rvi_u->user_def_data);
 		if (rvi_u->visual_effect != 0) {
 			u->u.rail.cached_vis_effect = rvi_u->visual_effect;
 		} else {
 			if (IsTrainWagon(u) || IsArticulatedPart(u)) {
 		if (u->cargo_type == rvi_u->cargo_type && u->cargo_subtype == 0) {
 			/* Set cargo capacity if we've not been refitted */
 			u->cargo_cap = GetVehicleProperty(u, 0x14, rvi_u->capacity);
 		}
-		u->u.rail.user_def_data = GetVehicleProperty(u, 0x25, rvi_u->user_def_data);
 		/* check the vehicle length (callback) */
 		uint16 veh_len = CALLBACK_FAILED;
 		if (HasBit(EngInfo(u->engine_type)->callbackmask, CBM_VEHICLE_LENGTH)) {
 			veh_len = GetVehicleCallback(CBID_VEHICLE_LENGTH, 0, 0, u->engine_type, u);
 		}
 	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);
+	if (IsFrontEngine(v)) {
+		UpdateTrainAcceleration(v);
+		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
+	}
 }
 enum AccelType {
 	AM_ACCEL,
 	AM_BRAKE
 };
-static bool TrainShouldStop(const Vehicle* v, TileIndex tile)
-{
-	const Order* o = &v->current_order;
-	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 & OFB_NON_STOP && sid == o->dest) {
-		return false;
-	}
-	if (v->last_station_visited == sid) return false;
-	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)
 {
-	static const int absolute_max_speed = 2000;
+	static const int absolute_max_speed = UINT16_MAX;
 	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 */
 			max_speed += max_speed / 5;
 		}
 	}
 	if (IsTileType(v->tile, MP_STATION) && IsFrontEngine(v)) {
-		if (TrainShouldStop(v, v->tile)) {
+		if (v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) {
 			int station_length = GetStationByTile(v->tile)->GetPlatformLength(v->tile, DirToDiagDir(v->direction));
 			int st_max_speed = 120;
 			int delta_v = v->cur_speed / (station_length + 1);
 	} else {
 		return min((-force - resistance) / (mass * 4), -10000 / (mass * 4));
 	}
 }
-static void UpdateTrainAcceleration(Vehicle* v)
+void UpdateTrainAcceleration(Vehicle *v)
 {
 	assert(IsFrontEngine(v));
 	v->max_speed = v->u.rail.cached_max_speed;
 	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)) {
+		/* Check that the wagon can drive on the track in question */
+		if (!IsCompatibleRail(rvi->railtype, GetRailType(tile))) return CMD_ERROR;
 		/* Allow for the wagon and the articulated parts, plus one to "terminate" the list. */
 		Vehicle **vl = (Vehicle**)alloca(sizeof(*vl) * (num_vehicles + 1));
 		memset(vl, 0, sizeof(*vl) * (num_vehicles + 1));
 		if (!Vehicle::AllocateList(vl, num_vehicles))
 			v->z_pos = GetSlopeZ(x, y);
 			v->owner = _current_player;
 			v->u.rail.track = TRACK_BIT_DEPOT;
 			v->vehstatus = VS_HIDDEN | VS_DEFPAL;
-			v->subtype = 0;
+//			v->subtype = 0;
 			SetTrainWagon(v);
 			if (u != NULL) {
 				u->SetNext(v);
 			} else {
 				SetFreeWagon(v);
 				InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 			}
 			v->cargo_type = rvi->cargo_type;
-			v->cargo_subtype = 0;
+//			v->cargo_subtype = 0;
 			v->cargo_cap = rvi->capacity;
 			v->value = value.GetCost();
 //			v->day_counter = 0;
 			v->u.rail.railtype = rvi->railtype;
 	return value;
 }
 /** Move all free vehicles in the depot to the train */
-static void NormalizeTrainVehInDepot(const Vehicle* u)
+static void NormalizeTrainVehInDepot(const Vehicle *u)
 {
-	const Vehicle* v;
+	const Vehicle *v;
 	FOR_ALL_VEHICLES(v) {
 		if (v->type == VEH_TRAIN && IsFreeWagon(v) &&
 				v->tile == u->tile &&
 				v->u.rail.track == TRACK_BIT_DEPOT) {
 				break;
 		}
 	}
 }
-static CommandCost EstimateTrainCost(EngineID engine, const RailVehicleInfo* rvi)
+static CommandCost EstimateTrainCost(EngineID engine, const RailVehicleInfo *rvi)
 {
 	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)
+static void AddRearEngineToMultiheadedTrain(Vehicle *v, Vehicle *u, bool building)
 {
 	u = new (u) Train();
 	u->direction = v->direction;
 	u->owner = v->owner;
 	u->tile = v->tile;
 	u->x_pos = v->x_pos;
 	u->y_pos = v->y_pos;
 	u->z_pos = v->z_pos;
 	u->u.rail.track = TRACK_BIT_DEPOT;
 	u->vehstatus = v->vehstatus & ~VS_STOPPED;
-	u->subtype = 0;
+//	u->subtype = 0;
 	SetMultiheaded(u);
 	u->spritenum = v->spritenum + 1;
 	u->cargo_type = v->cargo_type;
 	u->cargo_subtype = v->cargo_subtype;
 	u->cargo_cap = v->cargo_cap;
 		if (!IsTileOwner(tile, _current_player)) return CMD_ERROR;
 	}
 	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;
 	if (rvi->railveh_type == RAILVEH_WAGON) return CmdBuildRailWagon(p1, tile, flags);
 	CommandCost value = EstimateTrainCost(p1, rvi);
 	uint num_vehicles =
 		(rvi->railveh_type == RAILVEH_MULTIHEAD ? 2 : 1) +
 		CountArticulatedParts(p1, false);
 	if (!(flags & DC_QUERY_COST)) {
+		/* 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;
 		/* Allow for the dual-heads and the articulated parts, plus one to "terminate" the list. */
 		Vehicle **vl = (Vehicle**)alloca(sizeof(*vl) * (num_vehicles + 1));
 		memset(vl, 0, sizeof(*vl) * (num_vehicles + 1));
-		if (!Vehicle::AllocateList(vl, num_vehicles))
+		if (!Vehicle::AllocateList(vl, num_vehicles)) {
 			return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);
+		}
 		Vehicle *v = vl[0];
 		UnitID unit_num = HasBit(p2, 0) ? 0 : GetFreeUnitNumber(VEH_TRAIN);
 		if (unit_num > _patches.max_trains)
 			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->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;
+//			v->cargo_subtype = 0;
 			v->cargo_cap = rvi->capacity;
 			v->max_speed = rvi->max_speed;
 			v->value = value.GetCost();
 			v->last_station_visited = INVALID_STATION;
-			v->dest_tile = 0;
+//			v->dest_tile = 0;
 			v->engine_type = p1;
 			const Engine *e = GetEngine(p1);
 			v->reliability = e->reliability;
 			v->date_of_last_service = _date;
 			v->build_year = _cur_year;
 			v->cur_image = 0xAC2;
 			v->random_bits = VehicleRandomBits();
-			v->vehicle_flags = 0;
+//			v->vehicle_flags = 0;
 			if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) SetBit(v->vehicle_flags, VF_BUILT_AS_PROTOTYPE);
 			v->group_id = DEFAULT_GROUP;
-			v->subtype = 0;
+//			v->subtype = 0;
 			SetFrontEngine(v);
 			SetTrainEngine(v);
 			VehiclePositionChanged(v);
 			} else {
 				AddArticulatedParts(vl, VEH_TRAIN);
 			}
 			TrainConsistChanged(v);
-			UpdateTrainAcceleration(v);
 			UpdateTrainGroupID(v);
 			if (!HasBit(p2, 1)) { // check if the cars should be added to the new vehicle
 				NormalizeTrainVehInDepot(v);
 			}
 			InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 			RebuildVehicleLists();
 			InvalidateWindow(WC_COMPANY, v->owner);
-			if (IsLocalPlayer())
+			if (IsLocalPlayer()) {
 				InvalidateAutoreplaceWindow(v->engine_type, v->group_id); // updates the replace Train window
+			}
 			GetPlayer(_current_player)->num_engines[p1]++;
 		}
 	}
 					/* setting the type to 0 also involves setting up the orders field. */
 					SetFrontEngine(src);
 					assert(src->orders == NULL);
 					src->num_orders = 0;
-					// Decrease the engines number of the src engine_type
+					/* Decrease the engines number of the src engine_type */
 					if (!IsDefaultGroupID(src->group_id) && IsValidGroupID(src->group_id)) {
 						GetGroup(src->group_id)->num_engines[src->engine_type]--;
 					}
-					// If we move an engine to a new line affect it to the DEFAULT_GROUP
+					/* If we move an engine to a new line affect it to the DEFAULT_GROUP */
 					src->group_id = DEFAULT_GROUP;
 				}
 			} else {
 				SetFreeWagon(src);
 			}
 			/* link in the wagon(s) in the chain. */
 			{
 				Vehicle *v;
-				for (v = src; GetNextVehicle(v) != NULL; v = GetNextVehicle(v));
+				for (v = src; GetNextVehicle(v) != NULL; v = GetNextVehicle(v)) {}
 				GetLastEnginePart(v)->SetNext(dst->Next());
 			}
 			dst->SetNext(src);
 		}
 		if (src_head != NULL) {
 			NormaliseTrainConsist(src_head);
 			TrainConsistChanged(src_head);
 			UpdateTrainGroupID(src_head);
 			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, VVW_WIDGET_REFIT_VEH);
 			}
 			/* Update the depot window */
 		if (dst_head != NULL) {
 			NormaliseTrainConsist(dst_head);
 			TrainConsistChanged(dst_head);
 			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, VVW_WIDGET_REFIT_VEH);
 				InvalidateWindow(WC_VEHICLE_REFIT, dst_head->index);
 			}
 			/* Update the depot window */
 				first = UnlinkWagon(v, first);
 				DeleteDepotHighlightOfVehicle(v);
 				delete v;
 				/* 4 If the second wagon was an engine, update it to front_engine
-					* which UnlinkWagon() has changed to TS_Free_Car */
+				 * which UnlinkWagon() has changed to TS_Free_Car */
 				if (switch_engine) SetFrontEngine(first);
 				/* 5. If the train still exists, update its acceleration, window, etc. */
 				if (first != NULL) {
 					NormaliseTrainConsist(first);
 					TrainConsistChanged(first);
 					UpdateTrainGroupID(first);
-					if (IsFrontEngine(first)) {
+					if (IsFrontEngine(first)) InvalidateWindow(WC_VEHICLE_REFIT, first->index);
-						InvalidateWindow(WC_VEHICLE_DETAILS, first->index);
-						InvalidateWindow(WC_VEHICLE_REFIT, first->index);
-						UpdateTrainAcceleration(first);
-					}
 				}
 				/* (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, TS_FRONT)) {
-					Vehicle *tmp;
+					for (v = first; v != NULL;) {
-					for (v = first; v != NULL; v = tmp) {
+						Vehicle *tmp = GetNextVehicle(v);
-						tmp = GetNextVehicle(v);
 						DoCommand(v->tile, v->index | INVALID_VEHICLE << 16, 0, DC_EXEC, CMD_MOVE_RAIL_VEHICLE);
+						v = tmp;
 					}
 				}
 			}
 		} break;
 		case 1: { /* Delete wagon and all wagons after it given certain criteria */
 			/* Start deleting every vehicle after the selected one
 			 * If we encounter a matching rear-engine to a front-engine
 			 * earlier in the chain (before deletion), leave it alone */
-			Vehicle *tmp;
+			for (Vehicle *tmp; v != NULL; v = tmp) {
-			for (; v != NULL; v = tmp) {
 				tmp = GetNextVehicle(v);
 				if (IsMultiheaded(v)) {
 					if (IsTrainEngine(v)) {
 						/* We got a front engine of a multiheaded set. Now we will sell the rear end too */
 			/* 3. If it is still a valid train after selling, update its acceleration and cached values */
 			if (flags & DC_EXEC && first != NULL) {
 				NormaliseTrainConsist(first);
 				TrainConsistChanged(first);
 				UpdateTrainGroupID(first);
-				if (IsFrontEngine(first)) UpdateTrainAcceleration(first);
-				InvalidateWindow(WC_VEHICLE_DETAILS, first->index);
 				InvalidateWindow(WC_VEHICLE_REFIT, first->index);
 			}
 		} break;
 	}
 	return cost;
 #undef MKIT
 	uint32 x = _delta_xy_table[direction];
 	this->x_offs        = GB(x,  0, 8);
 	this->y_offs        = GB(x,  8, 8);
-	this->sprite_width  = GB(x, 16, 8);
+	this->x_extent      = GB(x, 16, 8);
-	this->sprite_height = GB(x, 24, 8);
+	this->y_extent      = GB(x, 24, 8);
-	this->z_height      = 6;
+	this->z_extent      = 6;
 }
 static void UpdateVarsAfterSwap(Vehicle *v)
 {
 	v->UpdateDeltaXY(v->direction);
 	BeginVehicleMove(v);
 	VehiclePositionChanged(v);
 	EndVehicleMove(v);
 }
-static inline 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))
+		if (_patches.vehicle_speed || (old == 0) != (spd == 0)) {
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
+		}
 	}
 }
 static void SwapTrainFlags(byte *swap_flag1, byte *swap_flag2)
 {
 	assert(IsLevelCrossingTile(tile));
 	DiagDirection dir = AxisToDiagDir(GetCrossingRailAxis(tile));
 	TileIndex tile_from = tile + TileOffsByDiagDir(dir);
-	Vehicle *v = (Vehicle *)VehicleFromPos(tile_from, &tile, &TrainApproachingCrossingEnum);
+	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);
+	return (Vehicle*)VehicleFromPos(tile_from, &tile, &TrainApproachingCrossingEnum);
 }
 /**
 * Sets correct crossing state
 }
 /**
 * Advances wagons for train reversing, needed for variable length wagons.
-* Needs to be called once before the train is reversed, and once after it.
+* This one is called before the train is reversed.
 * @param v First vehicle in chain
-* @param before Set to true for the call before reversing, false otherwise
 */
-static void AdvanceWagons(Vehicle *v, bool before)
+static void AdvanceWagonsBeforeSwap(Vehicle *v)
 {
 	Vehicle *base = v;
-	Vehicle *first = base->Next();
+	Vehicle *first = base;                    // first vehicle to move
+	Vehicle *last = GetLastVehicleInChain(v); // last vehicle to move
 	uint length = CountVehiclesInChain(v);
 	while (length > 2) {
-		/* find pairwise matching wagon
+		last = last->Previous();
-		 * start<>end, start+1<>end-1, ... */
+		first = first->Next();
-		Vehicle *last = first;
-		for (uint i = length - 3; i > 0; i--) last = last->Next();
+		int differential = base->u.rail.cached_veh_length - last->u.rail.cached_veh_length;
+		/* do not update images now
+		 * negative differential will be handled in AdvanceWagonsAfterSwap() */
+		for (int i = 0; i < differential; i++) TrainController(first, last->Next(), false);
+		base = first; // == base->Next()
+		length -= 2;
+	}
+}
+/**
+* Advances wagons for train reversing, needed for variable length wagons.
+* This one is called after the train is reversed.
+* @param v First vehicle in chain
+*/
+static void AdvanceWagonsAfterSwap(Vehicle *v)
+{
+	/* first of all, fix the situation when the train was entering a depot */
+	Vehicle *dep = v; // last vehicle in front of just left depot
+	while (dep->Next() != NULL && (dep->u.rail.track == TRACK_BIT_DEPOT || dep->Next()->u.rail.track != TRACK_BIT_DEPOT)) {
+		dep = dep->Next(); // find first vehicle outside of a depot, with next vehicle inside a depot
+	}
+	Vehicle *leave = dep->Next(); // first vehicle in a depot we are leaving now
+	if (leave != NULL) {
+		/* 'pull' next wagon out of the depot, so we won't miss it (it could stay in depot forever) */
+		int d = TicksToLeaveDepot(dep);
+		if (d <= 0) {
+			leave->vehstatus &= ~VS_HIDDEN; // move it out of the depot
+			leave->u.rail.track = AxisToTrackBits(DiagDirToAxis(GetRailDepotDirection(leave->tile)));
+			for (int i = 0; i >= d; i--) TrainController(leave, NULL, false); // maybe move it, and maybe let another wagon leave
+		}
+	} else {
+		dep = NULL; // no vehicle in a depot, so no vehicle leaving a depot
+	}
+	Vehicle *base = v;
+	Vehicle *first = base;                    // first vehicle to move
+	Vehicle *last = GetLastVehicleInChain(v); // last vehicle to move
+	uint length = CountVehiclesInChain(v);
+	/* we have to make sure all wagons that leave a depot because of train reversing are moved coorectly
+	 * they have already correct spacing, so we have to make sure they are moved how they should */
+	bool nomove = (dep == NULL); // if there is no vehicle leaving a depot, limit the number of wagons moved immediatelly
+	while (length > 2) {
+		/* we reached vehicle (originally) in front of a depot, stop now
+		 * (we would move wagons that are alredy moved with new wagon length) */
+		if (base == dep) break;
+		/* the last wagon was that one leaving a depot, so do not move it anymore */
+		if (last == dep) nomove = true;
+		last = last->Previous();
+		first = first->Next();
 		int differential = last->u.rail.cached_veh_length - base->u.rail.cached_veh_length;
-		if (before) differential *= -1;
+		/* do not update images now */
-		if (differential > 0) {
+		for (int i = 0; i < differential; i++) TrainController(first, (nomove ? last->Next() : NULL), false);
-			/* disconnect last car to make sure only this subset moves */
-			Vehicle *tempnext = last->Next();
+		base = first; // == base->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);
-		}
-		base = first;
-		first = first->Next();
 		length -= 2;
 	}
 }
 	/* Check if we were approaching a rail/road-crossing */
 	TileIndex crossing = TrainApproachingCrossingTile(v);
 	/* count number of vehicles */
-	int r = 0;  ///< number of vehicles - 1
+	int r = CountVehiclesInChain(v) - 1;  // number of vehicles - 1
-	for (const Vehicle *u = v; (u = u->Next()) != NULL;) { r++; }
+	AdvanceWagonsBeforeSwap(v);
-	AdvanceWagons(v, true);
 	/* swap start<>end, start+1<>end-1, ... */
 	int l = 0;
 	do {
 		ReverseTrainSwapVeh(v, l++, r--);
 	} while (l <= r);
-	AdvanceWagons(v, false);
+	AdvanceWagonsAfterSwap(v);
 	if (IsTileDepotType(v->tile, TRANSPORT_RAIL)) {
 		InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	}
 	Vehicle *v = GetVehicle(p1);
 	if (v->type != VEH_TRAIN || !CheckOwnership(v->owner)) return CMD_ERROR;
-	if (p2) {
+	if (p2 != 0) {
 		/* turn a single unit around */
 		if (IsMultiheaded(v) || HasBit(EngInfo(v->engine_type)->callbackmask, CBM_VEHICLE_ARTIC_ENGINE)) {
 			return_cmd_error(STR_ONLY_TURN_SINGLE_UNIT);
 		}
 			bool found = YapfFindNearestRailDepotTwoWay(v, max_distance, NPF_INFINITE_PENALTY, &tfdd.tile, &tfdd.reverse);
 			tfdd.best_length = found ? max_distance / 2 : UINT_MAX; // some fake distance or NOT_FOUND
 		} break;
 		case VPF_NPF: { /* NPF */
-			Vehicle* last = GetLastVehicleInChain(v);
+			const Vehicle *last = GetLastVehicleInChain(v);
 			Trackdir trackdir = GetVehicleTrackdir(v);
 			Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
 			assert(trackdir != INVALID_TRACKDIR);
 			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);
 			if (ftd.best_bird_dist == 0) {
 				/* Found target */
 				tfdd.tile = ftd.node.tile;
 				/* Our caller expects a number of tiles, so we just approximate that
-				* number by this. It might not be completely what we want, but it will
+				 * number by this. It might not be completely what we want, but it will
-				* work for now :-) We can possibly change this when the old pathfinder
+				 * work for now :-) We can possibly change this when the old pathfinder
-				* is removed. */
+				 * is removed. */
 				tfdd.best_length = ftd.best_path_dist / NPF_TILE_LENGTH;
 				if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE)) tfdd.reverse = true;
 			}
 		} break;
 	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 (v->current_order.IsType(OT_GOTO_DEPOT)) {
-		if (!!(p2 & DEPOT_SERVICE) == HasBit(v->current_order.flags, OF_HALT_IN_DEPOT)) {
+		bool halt_in_depot = v->current_order.GetDepotActionType() & ODATFB_HALT;
+		if (!!(p2 & DEPOT_SERVICE) == 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, OF_PART_OF_ORDERS);
+				v->current_order.SetDepotOrderType(ODTF_MANUAL);
-				ToggleBit(v->current_order.flags, OF_HALT_IN_DEPOT);
+				v->current_order.SetDepotActionType(halt_in_depot ? ODATF_SERVICE_ONLY : ODATFB_HALT);
 				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, OF_PART_OF_ORDERS)) {
+			/* If the orders to 'goto depot' are in the orders list (forced servicing),
-				v->cur_order_index++;
+			 * then skip to the next order; effectively cancelling this forced service */
-			}
+			if (v->current_order.GetDepotOrderType() & ODTFB_PART_OF_ORDERS) v->cur_order_index++;
-			v->current_order.type = OT_DUMMY;
+			v->current_order.MakeDummy();
-			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return CommandCost();
 	}
 	TrainFindDepotData tfdd = FindClosestTrainDepot(v, 0);
 	if (tfdd.best_length == (uint)-1) return_cmd_error(STR_883A_UNABLE_TO_FIND_ROUTE_TO);
 	if (flags & DC_EXEC) {
-		if (v->current_order.type == OT_LOADING) v->LeaveStation();
+		if (v->current_order.IsType(OT_LOADING)) v->LeaveStation();
 		v->dest_tile = tfdd.tile;
-		v->current_order.type = OT_GOTO_DEPOT;
+		v->current_order.MakeGoToDepot(GetDepotByTile(tfdd.tile)->index, ODTF_MANUAL);
-		v->current_order.flags = OFB_NON_STOP;
+		if (!(p2 & DEPOT_SERVICE)) v->current_order.SetDepotActionType(ODATFB_HALT);
-		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, 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);
 	}
 static const int8 _vehicle_smoke_pos[8] = {
 	1, 1, 1, 0, -1, -1, -1, 0
 };
-static void HandleLocomotiveSmokeCloud(const Vehicle* v)
+static void HandleLocomotiveSmokeCloud(const Vehicle *v)
 {
 	bool sound = false;
-	if (v->vehstatus & VS_TRAIN_SLOWING || v->load_unload_time_rem != 0 || v->cur_speed < 2)
+	if (v->vehstatus & VS_TRAIN_SLOWING || v->load_unload_time_rem != 0 || v->cur_speed < 2) {
 		return;
+	}
-	const Vehicle* u = v;
+	const Vehicle *u = v;
 	do {
 		const RailVehicleInfo *rvi = RailVehInfo(v->engine_type);
 		int effect_offset = GB(v->u.rail.cached_vis_effect, 0, 4) - 8;
 		byte effect_type = GB(v->u.rail.cached_vis_effect, 4, 2);
 			x = -x;
 			y = -y;
 		}
 		switch (effect_type) {
-		case 0:
+			case 0:
-			/* steam smoke. */
+				/* steam smoke. */
-			if (GB(v->tick_counter, 0, 4) == 0) {
+				if (GB(v->tick_counter, 0, 4) == 0) {
-				CreateEffectVehicleRel(v, x, y, 10, EV_STEAM_SMOKE);
+					CreateEffectVehicleRel(v, x, y, 10, EV_STEAM_SMOKE);
-				sound = true;
+					sound = true;
-			}
+				}
-			break;
+				break;
-		case 1:
+			case 1:
-			/* diesel smoke */
+				/* 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);
+					CreateEffectVehicleRel(v, 0, 0, 10, EV_DIESEL_SMOKE);
-				sound = true;
+					sound = true;
-			}
+				}
-			break;
+				break;
-		case 2:
+			case 2:
-			/* blue spark */
+				/* 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);
+					CreateEffectVehicleRel(v, 0, 0, 10, EV_ELECTRIC_SPARK);
-				sound = true;
+					sound = true;
-			}
+				}
-			break;
+				break;
+			default:
+				break;
 		}
 	} while ((v = v->Next()) != NULL);
 	if (sound) PlayVehicleSound(u, VSE_TRAIN_EFFECT);
 }
 	InvalidateWindowData(WC_VEHICLE_DEPOT, v->tile);
 	return false;
 }
-/* Check for station tiles */
+/** Check for station tiles */
 struct TrainTrackFollowerData {
 	TileIndex dest_coords;
-	StationID station_index; // station index we're heading for
+	StationID station_index; ///< station index we're heading for
 	uint best_bird_dist;
 	uint best_track_dist;
 	TrackdirByte best_track;
 };
 		}
 		return false;
 	}
 }
-static void FillWithStationData(TrainTrackFollowerData* fd, const Vehicle* v)
+static void FillWithStationData(TrainTrackFollowerData *fd, const Vehicle *v)
 {
 	fd->dest_coords = v->dest_tile;
-	if (v->current_order.type == OT_GOTO_STATION) {
+	fd->station_index = v->current_order.IsType(OT_GOTO_STATION) ? v->current_order.GetDestination() : INVALID_STATION;
-		fd->station_index = v->current_order.dest;
-	} else {
-		fd->station_index = INVALID_STATION;
-	}
 }
 static const byte _initial_tile_subcoord[6][4][3] = {
 {{ 15, 8, 1 }, { 0, 0, 0 }, { 0, 8, 5 }, { 0,  0, 0 }},
 {{  0, 0, 0 }, { 8, 0, 3 }, { 0, 0, 0 }, { 8, 15, 7 }},
 {{ 15, 8, 2 }, { 0, 0, 0 }, { 0, 0, 0 }, { 8, 15, 6 }},
 {{ 15, 7, 0 }, { 8, 0, 4 }, { 0, 0, 0 }, { 0,  0, 0 }},
 {{  0, 0, 0 }, { 0, 0, 0 }, { 0, 8, 4 }, { 7, 15, 0 }},
 };
-static const uint32 _reachable_tracks[4] = {
-	0x10091009,
-	0x00160016,
-	0x05200520,
-	0x2A002A00,
-};
 static const byte _search_directions[6][4] = {
 	{ 0, 9, 2, 9 }, ///< track 1
 	{ 9, 1, 9, 3 }, ///< track 2
 	{ 9, 0, 3, 9 }, ///< track upper
 	{ 1, 9, 9, 2 }, ///< track lower
 };
 static const byte _pick_track_table[6] = {1, 3, 2, 2, 0, 0};
 /* choose a track */
-static Track ChooseTrainTrack(Vehicle* v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
+static Track ChooseTrainTrack(Vehicle *v, TileIndex tile, DiagDirection enterdir, TrackBits tracks)
 {
 	Track best_track;
 	/* pathfinders are able to tell that route was only 'guessed' */
 	bool path_not_found = false;
 			/* and notify user about the event */
 			if (_patches.lost_train_warn && v->owner == _local_player) {
 				SetDParam(0, v->unitnumber);
 				AddNewsItem(
 					STR_TRAIN_IS_LOST,
-					NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),
+					NM_SMALL, NF_VIEWPORT | NF_VEHICLE, NT_ADVICE, DNC_NONE,
 					v->index,
 					0);
 			}
 		}
 	} else {
 static bool CheckReverseTrain(Vehicle *v)
 {
 	if (_opt.diff.line_reverse_mode != 0 ||
 			v->u.rail.track == TRACK_BIT_DEPOT || v->u.rail.track == TRACK_BIT_WORMHOLE ||
-			!(v->direction & 1))
+			!(v->direction & 1)) {
 		return false;
+	}
 	TrainTrackFollowerData fd;
 	FillWithStationData(&fd, v);
 	uint reverse_best = 0;
 	assert(v->u.rail.track);
-	int i = _search_directions[FIND_FIRST_BIT(v->u.rail.track)][DirToDiagDir(v->direction)];
 	switch (_patches.pathfinder_for_trains) {
-		case VPF_YAPF: { /* YAPF */
+		case VPF_YAPF: /* YAPF */
 			reverse_best = YapfCheckReverseTrain(v);
-		} break;
+			break;
 		case VPF_NPF: { /* NPF */
 			NPFFindStationOrTileData fstd;
 			NPFFoundTargetData ftd;
-			Vehicle* last = GetLastVehicleInChain(v);
+			Vehicle *last = GetLastVehicleInChain(v);
 			NPFFillWithOrderData(&fstd, v);
 			Trackdir trackdir = GetVehicleTrackdir(v);
 			Trackdir trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));
 			}
 		} break;
 		default:
 		case VPF_NTP: { /* NTP */
+			int i = _search_directions[FindFirstTrack(v->u.rail.track)][DirToDiagDir(v->direction)];
 			int best_track = -1;
 			uint reverse = 0;
 			uint best_bird_dist  = 0;
 			uint best_track_dist = 0;
 	}
 	return reverse_best != 0;
 }
-static bool ProcessTrainOrder(Vehicle *v)
+TileIndex Train::GetOrderStationLocation(StationID station)
 {
-	switch (v->current_order.type) {
+	if (station == this->last_station_visited) this->last_station_visited = INVALID_STATION;
-		case OT_GOTO_DEPOT:
-			if (!(v->current_order.flags & OFB_PART_OF_ORDERS)) return false;
+	return GetStation(station)->xy;
-			if ((v->current_order.flags & OFB_SERVICE_IF_NEEDED) &&
-					!VehicleNeedsService(v)) {
-				UpdateVehicleTimetable(v, true);
-				v->cur_order_index++;
-			}
-			break;
-		case OT_LOADING:
-		case OT_LEAVESTATION:
-			return false;
-		default: break;
-	}
-	/**
-	 * Reversing because of order change is allowed only just after leaving a
-	 * station (and the difficulty setting to allowed, of course)
-	 * this can be detected because only after OT_LEAVESTATION, current_order
-	 * will be reset to nothing. (That also happens if no order, but in that case
-	 * it won't hit the point in code where may_reverse is checked)
-	 */
-	bool may_reverse = v->current_order.type == OT_NOTHING;
-	/* check if we've reached the waypoint? */
-	if (v->current_order.type == OT_GOTO_WAYPOINT && v->tile == v->dest_tile) {
-		UpdateVehicleTimetable(v, true);
-		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 & OFB_NON_STOP &&
-			IsTileType(v->tile, MP_STATION) &&
-			v->current_order.dest == GetStationIndex(v->tile)) {
-		UpdateVehicleTimetable(v, true);
-		v->cur_order_index++;
-	}
-	/* Get the current order */
-	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;
-	const Order *order = GetVehicleOrder(v, v->cur_order_index);
-	/* If no order, do nothing. */
-	if (order == NULL) {
-		v->current_order.Free();
-		v->dest_tile = 0;
-		return false;
-	}
-	/* If it is unchanged, keep it. */
-	if (order->type  == v->current_order.type &&
-			order->flags == v->current_order.flags &&
-			order->dest  == v->current_order.dest)
-		return false;
-	/* Otherwise set it, and determine the destination tile. */
-	v->current_order = *order;
-	v->dest_tile = 0;
-	InvalidateVehicleOrder(v);
-	switch (order->type) {
-		case OT_GOTO_STATION:
-			if (order->dest == v->last_station_visited)
-				v->last_station_visited = INVALID_STATION;
-			v->dest_tile = GetStation(order->dest)->xy;
-			break;
-		case OT_GOTO_DEPOT:
-			v->dest_tile = GetDepot(order->dest)->xy;
-			break;
-		case OT_GOTO_WAYPOINT:
-			v->dest_tile = GetWaypoint(order->dest)->xy;
-			break;
-		default:
-			return false;
-	}
-	return may_reverse && CheckReverseTrain(v);
 }
 void Train::MarkDirty()
 {
 	Vehicle *v = this;
 	/* check if a train ever visited this station before */
 	Station *st = GetStation(station);
 	if (!(st->had_vehicle_of_type & HVOT_TRAIN)) {
 		st->had_vehicle_of_type |= HVOT_TRAIN;
 		SetDParam(0, st->index);
-		uint32 flags = v->owner == _local_player ?
-			NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ARRIVAL_PLAYER, 0) :
-			NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ARRIVAL_OTHER,  0);
 		AddNewsItem(
 			STR_8801_CITIZENS_CELEBRATE_FIRST,
-			flags,
+			NM_THIN, NF_VIEWPORT | NF_VEHICLE, v->owner == _local_player ? NT_ARRIVAL_PLAYER : NT_ARRIVAL_OTHER, DNC_NONE,
 			v->index,
 			0
 		);
 	}
 	v->BeginLoading();
-	v->current_order.dest = 0;
 }
 static byte AfterSetTrainPos(Vehicle *v, bool new_tile)
 {
 	byte old_z = v->z_pos;
 	{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 inline 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;
 		uint16 spd = v->cur_speed + rsp->z_down;
 		if (spd <= v->max_speed) v->cur_speed = spd;
 	}
 }
-static const DiagDirection _otherside_signal_directions[] = {
-	DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_SW, DIAGDIR_SE, INVALID_DIAGDIR, INVALID_DIAGDIR,
-	DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NW, DIAGDIR_NE
-};
 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]);
+		TrackdirBits tracks = TrackBitsToTrackdirBits(GetTrackBits(tile)) & DiagdirReachesTrackdirs(dir);
-		UpdateSignalsOnSegment(tile, _otherside_signal_directions[i], GetTileOwner(tile));
+		Trackdir trackdir = FindFirstTrackdir(tracks);
+		UpdateSignalsOnSegment(tile, TrackdirToExitdir(trackdir), GetTileOwner(tile));
 	}
 }
 static void SetVehicleCrashed(Vehicle *v)
 	/* must be updated after the train has been marked crashed */
 	if (crossing != INVALID_TILE) UpdateLevelCrossing(crossing);
 }
-static uint CountPassengersInTrain(const Vehicle* v)
+static uint CountPassengersInTrain(const Vehicle *v)
 {
 	uint num = 0;
 	BEGIN_ENUM_WAGONS(v)
 		if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) num += v->cargo.Count();
 	END_ENUM_WAGONS(v)
 	return num;
 }
 struct TrainCollideChecker {
-	Vehicle *v;
+	Vehicle *v;  ///< vehicle we are testing for collision
-	uint num;
+	uint num;    ///< number of dead if train collided
 };
 static void *FindTrainCollideEnum(Vehicle *v, void *data)
 {
-	TrainCollideChecker* tcc = (TrainCollideChecker*)data;
+	TrainCollideChecker *tcc = (TrainCollideChecker*)data;
 	if (v->type != VEH_TRAIN) return NULL;
 	/* get first vehicle now to make most usual checks faster */
 	Vehicle *coll = v->First();
 	/* any dead -> no crash */
 	if (tcc.num == 0) return;
 	SetDParam(0, tcc.num);
 	AddNewsItem(STR_8868_TRAIN_CRASH_DIE_IN_FIREBALL,
-		NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, 0),
+		NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, DNC_NONE,
 		v->index,
 		0
 	);
 	ModifyStationRatingAround(v->tile, v->owner, -160, 30);
 		if (diff == DIRDIFF_90RIGHT || (v->cur_speed <= 5 && diff <= DIRDIFF_REVERSE)) return v;
 	}
 	return NULL;
 }
-static void TrainController(Vehicle *v, bool update_image)
+static void TrainController(Vehicle *v, Vehicle *nomove, bool update_image)
 {
 	Vehicle *prev;
 	/* For every vehicle after and including the given vehicle */
-	for (prev = v->Previous(); v != NULL; prev = v, v = v->Next()) {
+	for (prev = v->Previous(); v != nomove; prev = v, v = v->Next()) {
 		DiagDirection enterdir = DIAGDIR_BEGIN;
 		bool update_signals_crossing = false; // will we update signals or crossing state?
 		BeginVehicleMove(v);
 		GetNewVehiclePosResult gp = GetNewVehiclePos(v);
 					if (HasBit(r, VETS_ENTERED_STATION)) {
 						TrainEnterStation(v, r >> VETS_STATION_ID_OFFSET);
 						return;
 					}
-					if (v->current_order.type == OT_LEAVESTATION) {
+					if (v->current_order.IsType(OT_LEAVESTATION)) {
 						v->current_order.Free();
 						InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 					}
 				}
 			} else {
 				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. */
-				TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, 0, ReverseDiagDir(enterdir)) & _reachable_tracks[enterdir];
+				TrackStatus ts = GetTileTrackStatus(gp.new_tile, TRANSPORT_RAIL, 0, ReverseDiagDir(enterdir));
-				TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
+				TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(enterdir);
-				TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts));
+				TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs;
+				TrackBits red_signals = TrackdirBitsToTrackBits(TrackStatusToRedSignals(ts) & reachable_trackdirs);
 				TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);
 				if (_patches.pathfinder_for_trains != VPF_NTP && _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 */
 		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);
 		}
 			v->direction = ChangeDir(v->direction, delta[GB(Random(), 0, 2)]);
 			BeginVehicleMove(v);
 			v->UpdateDeltaXY(v->direction);
 			v->cur_image = v->GetImage(v->direction);
 			/* Refrain from updating the z position of the vehicle when on
-			   a bridge, because AfterSetTrainPos will put the vehicle under
+			 * a bridge, because AfterSetTrainPos will put the vehicle under
-			   the bridge in that case */
+			 * the bridge in that case */
 			if (v->u.rail.track != TRACK_BIT_WORMHOLE) AfterSetTrainPos(v, false);
 		}
 	} while ((v = v->Next()) != NULL);
 }
 	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 */
-	TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0, ReverseDiagDir(dir)) & _reachable_tracks[dir];
+	TrackStatus ts = GetTileTrackStatus(tile, TRANSPORT_RAIL, 0, ReverseDiagDir(dir));
-	TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts);
+	TrackdirBits reachable_trackdirs = DiagdirReachesTrackdirs(dir);
-	TrackdirBits red_signals = TrackStatusToRedSignals(ts);
+	TrackdirBits trackdirbits = TrackStatusToTrackdirBits(ts) & reachable_trackdirs;
+	TrackdirBits red_signals = TrackStatusToRedSignals(ts) & reachable_trackdirs;
 	/* We are sure the train is not entering a depot, it is detected above */
 	/* mask unreachable track bits if we are forbidden to do 90deg turns */
 	TrackBits bits = TrackdirBitsToTrackBits(trackdirbits);
 	}
 	/* exit if train is stopped */
 	if (v->vehstatus & VS_STOPPED && v->cur_speed == 0) return;
-	if (ProcessTrainOrder(v)) {
+	if (ProcessOrders(v) && CheckReverseTrain(v)) {
 		v->load_unload_time_rem = 0;
 		v->cur_speed = 0;
 		v->subspeed = 0;
 		ReverseTrainDirection(v);
 		return;
 	}
 	v->HandleLoading(mode);
-	if (v->current_order.type == OT_LOADING) return;
+	if (v->current_order.IsType(OT_LOADING)) return;
 	if (CheckTrainStayInDepot(v)) return;
 	if (!mode) HandleLocomotiveSmokeCloud(v);
 		if (v->cur_speed != 0) return;
 	} else {
 		TrainCheckIfLineEnds(v);
 		do {
-			TrainController(v, true);
+			TrainController(v, NULL, true);
 			CheckTrainCollision(v);
 			if (v->cur_speed <= 0x100)
 				break;
 		} while (--j != 0);
 	}
 		/* Delete flooded standalone wagon chain */
 		if (++this->u.rail.crash_anim_pos >= 4400) DeleteVehicleChain(this);
 	}
 }
-#define MAX_ACCEPTABLE_DEPOT_DIST 16
 static void CheckIfTrainNeedsService(Vehicle *v)
 {
-	if (_patches.servint_trains == 0 || !VehicleNeedsService(v)) return;
+	static const uint MAX_ACCEPTABLE_DEPOT_DIST = 16;
+	if (_patches.servint_trains == 0 || !v->NeedsAutomaticServicing()) return;
 	if (v->IsInDepot()) {
 		VehicleServiceInDepot(v);
 		return;
 	}
 	TrainFindDepotData tfdd = FindClosestTrainDepot(v, MAX_ACCEPTABLE_DEPOT_DIST);
 	/* Only go to the depot if it is not too far out of our way. */
 	if (tfdd.best_length == (uint)-1 || tfdd.best_length > MAX_ACCEPTABLE_DEPOT_DIST) {
-		if (v->current_order.type == OT_GOTO_DEPOT) {
+		if (v->current_order.IsType(OT_GOTO_DEPOT)) {
 			/* 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.MakeDummy();
-			v->current_order.flags = 0;
 			InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 		}
 		return;
 	}
-	const Depot* depot = GetDepotByTile(tfdd.tile);
+	const Depot *depot = GetDepotByTile(tfdd.tile);
-	if (v->current_order.type == OT_GOTO_DEPOT &&
+	if (v->current_order.IsType(OT_GOTO_DEPOT) &&
-			v->current_order.dest != depot->index &&
+			v->current_order.GetDestination() != depot->index &&
 			!Chance16(3, 16)) {
 		return;
 	}
-	v->current_order.type = OT_GOTO_DEPOT;
+	v->current_order.MakeGoToDepot(depot->index, ODTFB_SERVICE);
-	v->current_order.flags = OFB_NON_STOP;
-	v->current_order.dest = depot->index;
 	v->dest_tile = tfdd.tile;
 	InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);
 }
 void Train::OnNewDay()
 		CheckIfTrainNeedsService(this);
 		CheckOrders(this);
 		/* update destination */
-		if (this->current_order.type == OT_GOTO_STATION) {
+		if (this->current_order.IsType(OT_GOTO_STATION)) {
-			TileIndex tile = GetStation(this->current_order.dest)->train_tile;
+			TileIndex tile = GetStation(this->current_order.GetDestination())->train_tile;
 			if (tile != 0) this->dest_tile = tile;
 		}
 		if (this->running_ticks != 0) {
 			/* running costs */
 			if (_patches.train_income_warn && v->owner == _local_player && v->age >= 730 && v->GetDisplayProfitThisYear() < 0) {
 				SetDParam(1, v->GetDisplayProfitThisYear());
 				SetDParam(0, v->unitnumber);
 				AddNewsItem(
 					STR_TRAIN_IS_UNPROFITABLE,
-					NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0),
+					NM_SMALL, NF_VIEWPORT | NF_VEHICLE, NT_ADVICE, DNC_NONE,
 					v->index,
 					0);
 			}
 			v->profit_last_year = v->profit_this_year;
 						SetTrainEngine(u);
 						u->spritenum--;
 					}
 					Vehicle *w;
-					for (w = u->Next(); w != NULL && (w->engine_type != u->engine_type || w->u.rail.other_multiheaded_part != NULL); w = GetNextVehicle(w));
+					for (w = u->Next(); w != NULL && (w->engine_type != u->engine_type || w->u.rail.other_multiheaded_part != NULL); w = GetNextVehicle(w)) {}
 					if (w != NULL) {
 						/* we found a car to partner with this engine. Now we will make sure it face the right way */
 						if (IsTrainEngine(w)) {
 							ClearTrainEngine(w);
 							w->spritenum++;

branch	NewGRF_ports
changeset 10184	fcf5fb2548eb
parent 6878	7d1ff2f621c7
child 10200	aba3af04cdbd