* @param same_length should length of vehicles stay the same?

 */

void TrainConsistChanged(Train *v, bool same_length)

{

	uint16 max_speed = UINT16_MAX;

	const RailVehicleInfo *rvi_v = RailVehInfo(v->engine_type);

	v->tcache.cached_total_length = 0;

	v->compatible_railtypes = RAILTYPES_NONE;

	bool train_can_tilt = true;

	for (Train *u = v; u != NULL; u = u->Next()) {

	v->tcache.cached_tilt = train_can_tilt;

	v->tcache.cached_max_curve_speed = GetTrainCurveSpeedLimit(v);

	/* 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);

		UpdateTrainAcceleration(v);

		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

	}

}

enum AccelType {

static int GetTrainAcceleration(Train *v, bool mode)

{

	int max_speed = v->tcache.cached_max_curve_speed;

	assert(max_speed == GetTrainCurveSpeedLimit(v)); // safety check, will be removed later

	int speed = v->cur_speed * 10 / 16; // km-ish/h -> mp/h

		StationID sid = GetStationIndex(v->tile);

		if (v->current_order.ShouldStopAtStation(v, sid)) {

			int station_ahead;

			int station_length;

			int stop_at = GetTrainStopLocation(sid, v->tile, v, &station_ahead, &station_length);

		return min(-force - resistance, -10000) / mass;

	}

}

void UpdateTrainAcceleration(Train *v)

{

	v->max_speed = v->tcache.cached_max_speed;

	uint power = v->tcache.cached_power;

	uint weight = v->tcache.cached_weight;

	assert(weight != 0);

		 * in the consist. Exclude articulated parts so that autoreplacing to

		 * engines with more articulated parts than before works correctly.

		 *

		 * Also skip counting rear ends of multiheaded engines */

		if (!IsArticulatedPart(v) && !IsRearDualheaded(v)) count++;

		if (v->track != TRACK_BIT_DEPOT || v->tile != tile ||

			return -1;

		}

	}

	return count;

}

 * always call with the front engine

 */

static void NormaliseTrainConsist(Train *v)

{

	if (IsFreeWagon(v)) return;

	for (; v != NULL; v = GetNextVehicle(v)) {

		if (!IsMultiheaded(v) || !IsTrainEngine(v)) continue;

		/* make sure that there are no free cars before next engine */

		Train *u;

				/* If moving only one vehicle, just count that. */

				src_len = 1;

			}

			if (src_len + dst_len > max_len) {

				/* Abort if we're adding too many wagons to a train. */

				/* Abort if we're making a train on a new row. */

				if (dst_head == NULL && IsTrainEngine(src)) return_cmd_error(STR_ERROR_TRAIN_TOO_LONG);

			}

		} else {

			/* Abort if we're creating a new train on an existing row. */

			if (src_len > max_len && src == src_head && IsTrainEngine(GetNextVehicle(src_head)))

				return_cmd_error(STR_ERROR_TRAIN_TOO_LONG);

		}

	}

	/* moving a loco to a new line?, then we need to assign a unitnumber. */

		UnitID unit_num = ((flags & DC_AUTOREPLACE) != 0 ? 0 : GetFreeUnitNumber(VEH_TRAIN));

		if (unit_num > _settings_game.vehicle.max_trains)

			return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);

		if (flags & DC_EXEC) src->unitnumber = unit_num;

	}

	/* When we move the front vehicle, the second vehicle might need a unitnumber */

		Vehicle *second = GetNextUnit(src);

		if (second != NULL && IsTrainEngine(second) && GetFreeUnitNumber(VEH_TRAIN) > _settings_game.vehicle.max_trains) {

			return_cmd_error(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME);

		}

	}

	}

	/* do it? */

	if (flags & DC_EXEC) {

		/* If we move the front Engine and if the second vehicle is not an engine

		   add the whole vehicle to the DEFAULT_GROUP */

			Vehicle *v = GetNextVehicle(src);

			if (v != NULL && IsTrainEngine(v)) {

				v->group_id   = src->group_id;

				src->group_id = DEFAULT_GROUP;

			}

		if (dst == NULL) {

			/* We make a new line in the depot, so we know already that we invalidate the window data */

			InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile);

			/* move the train to an empty line. for locomotives, we set the type to TS_Front. for wagons, 4. */

			if (IsTrainEngine(src)) {

					/* setting the type to 0 also involves setting up the orders field. */

					SetFrontEngine(src);

					assert(src->orders.list == NULL);

					/* Decrease the engines number of the src engine_type */

					if (!IsDefaultGroupID(src->group_id) && Group::IsValidID(src->group_id)) {

				}

			} else {

				SetFreeWagon(src);

			}

			dst_head = src;

		} else {

				/* the vehicle was previously a loco. need to free the order list and delete vehicle windows etc. */

				DeleteWindowById(WC_VEHICLE_VIEW, src->index);

				DeleteWindowById(WC_VEHICLE_ORDERS, src->index);

				DeleteWindowById(WC_VEHICLE_REFIT, src->index);

				DeleteWindowById(WC_VEHICLE_DETAILS, src->index);

				DeleteWindowById(WC_VEHICLE_TIMETABLE, src->index);

				DeleteVehicleOrders(src);

				RemoveVehicleFromGroup(src);

			}

				InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile);

				ClearFrontEngine(src);

				ClearFreeWagon(src);

				src->unitnumber = 0; // doesn't occupy a unitnumber anymore.

			}

			AddWagonToConsist(src->other_multiheaded_part, src);

		}

		/* If there is an engine behind first_engine we moved away, it should become new first_engine

		 * To do this, CmdMoveRailVehicle must be called once more

		 * we can't loop forever here because next time we reach this line we will have a front engine */

			/* As in CmdMoveRailVehicle src_head->group_id will be equal to DEFAULT_GROUP

			 * we need to save the group and reaffect it to src_head */

			const GroupID tmp_g = src_head->group_id;

			CmdMoveRailVehicle(0, flags, src_head->index | (INVALID_VEHICLE << 16), 1, text);

			SetTrainGroupID(src_head, tmp_g);

			src_head = NULL; // don't do anything more to this train since the new call will do it

		}

		if (src_head != NULL) {

			NormaliseTrainConsist(src_head);

			TrainConsistChanged(src_head, false);

			UpdateTrainGroupID(src_head);

				/* 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 */

			InvalidateWindow(WC_VEHICLE_DEPOT, src_head->tile);

		}

		if (dst_head != NULL) {

			NormaliseTrainConsist(dst_head);

			TrainConsistChanged(dst_head, false);

			UpdateTrainGroupID(dst_head);

				/* 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 */

			InvalidateWindow(WC_VEHICLE_DEPOT, dst_head->tile);

		return_cmd_error(STR_ERROR_TRAINS_CAN_ONLY_BE_ALTERED_INSIDE_A_DEPOT);

	}

	if (IsRearDualheaded(v)) return_cmd_error(STR_ERROR_REAR_ENGINE_FOLLOW_FRONT);

	if (flags & DC_EXEC) {

			DeleteWindowById(WC_VEHICLE_VIEW, first->index);

			DeleteWindowById(WC_VEHICLE_ORDERS, first->index);

			DeleteWindowById(WC_VEHICLE_REFIT, first->index);

			DeleteWindowById(WC_VEHICLE_DETAILS, first->index);

			DeleteWindowById(WC_VEHICLE_TIMETABLE, first->index);

		}

				/* 5. If the train still exists, update its acceleration, window, etc. */

				if (first != NULL) {

					NormaliseTrainConsist(first);

					TrainConsistChanged(first, false);

					UpdateTrainGroupID(first);

				}

			}

		} break;

		case 1: { // Delete wagon and all wagons after it given certain criteria

			/* Start deleting every vehicle after the selected one

 * @param v vehicle on tile

 * @param data tile with crossing we are testing

 * @return v if it is approaching a crossing, NULL otherwise

 */

static Vehicle *TrainApproachingCrossingEnum(Vehicle *v, void *data)

{

}

/**

 * Finds a vehicle approaching rail-road crossing

 * @param tile tile to test

	}

}

/** Free the reserved path in front of a vehicle. */

void FreeTrainTrackReservation(const Train *v, TileIndex origin, Trackdir orig_td)

{

	TileIndex tile = origin != INVALID_TILE ? origin : v->tile;

	Trackdir  td = orig_td != INVALID_TRACKDIR ? orig_td : v->GetVehicleTrackdir();

	bool      free_tile = tile != v->tile || !(IsRailwayStationTile(v->tile) || IsTileType(v->tile, MP_TUNNELBRIDGE));

	StationID station_id = IsRailwayStationTile(v->tile) ? GetStationIndex(v->tile) : INVALID_STATION;

 * @param mark_as_stuck Should the train be marked as stuck on a failed reservation?

 * @param first_tile_okay True if no path should be reserved if the current tile is a safe position.

 * @return True if a path could be reserved.

 */

bool TryPathReserve(Train *v, bool mark_as_stuck, bool first_tile_okay)

{

	/* We have to handle depots specially as the track follower won't look

	 * at the depot tile itself but starts from the next tile. If we are still

	 * inside the depot, a depot reservation can never be ours. */

	if (v->track == TRACK_BIT_DEPOT) {

		if (GetDepotWaypointReservation(v->tile)) {

/* Check if the vehicle is compatible with the specified tile */

static inline bool CheckCompatibleRail(const Train *v, TileIndex tile)

{

	return

		IsTileOwner(tile, v->owner) && (

			HasBit(v->compatible_railtypes, GetRailType(tile))

		);

}

struct RailtypeSlowdownParams {

	byte small_turn, large_turn;

static void SetVehicleCrashed(Train *v)

{

	if (v->crash_anim_pos != 0) return;

	/* Free a possible path reservation and try to mark all tiles occupied by the train reserved. */

		/* Remove all reservations, also the ones currently under the train

		 * and any railway station paltform reservation. */

		FreeTrainTrackReservation(v);

		for (const Train *u = v; u != NULL; u = u->Next()) {

			ClearPathReservation(u, u->tile, u->GetVehicleTrackdir());

			if (IsTileType(u->tile, MP_TUNNELBRIDGE)) {

	ModifyStationRatingAround(v->tile, v->owner, -160, 30);

	SndPlayVehicleFx(SND_13_BIG_CRASH, v);

	return true;

}

{

	DiagDirection exitdir = *(DiagDirection *)data;

}

static void TrainController(Train *v, Vehicle *nomove)

{

	Train *first = v->First();

	Train *prev;

					gp.x = v->x_pos;

					gp.y = v->y_pos;

				} else {

					/* Not inside depot */

					/* Reverse when we are at the end of the track already, do not move to the new position */

					uint32 r = VehicleEnterTile(v, gp.new_tile, gp.x, gp.y);

					if (HasBit(r, VETS_CANNOT_ENTER)) {

						goto invalid_rail;

					}

					if (HasBit(r, VETS_ENTERED_STATION)) {

								DiagDirection exitdir = TrackdirToExitdir(i);

								TileIndex o_tile = TileAddByDiagDir(gp.new_tile, exitdir);

								exitdir = ReverseDiagDir(exitdir);

								/* check if a train is waiting on the other side */

							}

						}

						/* If we would reverse but are currently in a PBS block and

						 * reversing of stuck trains is disabled, don't reverse. */

						if (_settings_game.pf.wait_for_pbs_path == 255 && UpdateSignalsOnSegment(v->tile, enterdir, v->owner) == SIGSEG_PBS) {

					goto invalid_rail;

				}

				if (!HasBit(r, VETS_ENTERED_WORMHOLE)) {

					Track track = FindFirstTrack(chosen_track);

					Trackdir tdir = TrackDirectionToTrackdir(track, chosen_dir);

						SetSignalStateByTrackdir(gp.new_tile, tdir, SIGNAL_STATE_RED);

						MarkTileDirtyByTile(gp.new_tile);

					}

					/* Clear any track reservation when the last vehicle leaves the tile */

					if (v->Next() == NULL) ClearPathReservation(v, v->tile, v->GetVehicleTrackdir());

						v->cur_speed -= (diff == DIRDIFF_45RIGHT || diff == DIRDIFF_45LEFT ? rsp->small_turn : rsp->large_turn) * v->cur_speed >> 8;

					}

					direction_changed = true;

					v->direction = chosen_dir;

				}

					v->load_unload_time_rem = 0;

					/* If we are approching a crossing that is reserved, play the sound now. */

					TileIndex crossing = TrainApproachingCrossingTile(v);

					if (crossing != INVALID_TILE && GetCrossingReservation(crossing)) SndPlayTileFx(SND_0E_LEVEL_CROSSING, crossing);

				v->cur_speed =

					min(v->cur_speed, GetBridgeSpec(GetBridgeType(v->tile))->speed);

			}

			if (IsTileType(gp.new_tile, MP_TUNNELBRIDGE) && HasBit(VehicleEnterTile(v, gp.new_tile, gp.x, gp.y), VETS_ENTERED_WORMHOLE)) {

				/* Perform look-ahead on tunnel exit. */

					TryReserveRailTrack(gp.new_tile, DiagDirToDiagTrack(GetTunnelBridgeDirection(gp.new_tile)));

					CheckNextTrainTile(v);

				}

			} else {

				v->x_pos = gp.x;

				v->y_pos = gp.y;

		if (prev == NULL) {

			/* This is the first vehicle in the train */

			AffectSpeedByZChange(v, old_z);

		}

		if (update_signals_crossing) {

				if (TrainMovedChangeSignals(gp.new_tile, enterdir)) {

					/* We are entering a block with PBS signals right now, but

					 * not through a PBS signal. This means we don't have a

					 * reservation right now. As a conventional signal will only

					 * ever be green if no other train is in the block, getting

					 * a path should always be possible. If the player built

				TrainMovedChangeSignals(gp.old_tile, ReverseDiagDir(enterdir));

				if (IsLevelCrossingTile(gp.old_tile)) UpdateLevelCrossing(gp.old_tile);

			}

		}

		/* Do not check on every tick to save some computing time. */

	}

	if (direction_changed) first->tcache.cached_max_curve_speed = GetTrainCurveSpeedLimit(first);

	return;

 * @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 Train *v)

{

	assert(!(v->vehstatus & VS_CRASHED));

	if (!TrainCanLeaveTile(v)) return INVALID_TILE;

	DiagDirection dir = TrainExitDir(v->direction, v->track);

	TileIndex tile = v->tile + TileOffsByDiagDir(dir);

bool Train::Tick()

{

	if (_age_cargo_skip_counter == 0) this->cargo.AgeCargo();

	this->tick_counter++;

		if (!(this->vehstatus & VS_STOPPED)) this->running_ticks++;

		this->current_order_time++;

		if (!TrainLocoHandler(this, false)) return false;

}

void Train::OnNewDay()

{

	if ((++this->day_counter & 7) == 0) DecreaseVehicleValue(this);

		CheckVehicleBreakdown(this);

		AgeVehicle(this);

		CheckIfTrainNeedsService(this);

		CheckOrders(this);