{

	uint16 max_speed = UINT16_MAX;

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

	v->tcache.cached_total_length = 0;

	v->compatible_railtypes = RAILTYPES_NONE;

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

	}

	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;

void UpdateTrainAcceleration(Train *v)

{

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

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

		}

	}

{

	if (IsFreeWagon(v)) return;

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

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

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

			}

	}

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

	}

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

	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)) {

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

			}

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

				RemoveVehicleFromGroup(src);

			}

				InvalidateWindowData(WC_VEHICLE_DEPOT, src->tile);

				ClearFrontEngine(src);

				ClearFreeWagon(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;

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

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

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

					NormaliseTrainConsist(first);

					TrainConsistChanged(first, false);

					UpdateTrainGroupID(first);

				}

			}

 */

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

{

}

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

{

	return

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

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

		);

}

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

	return true;

}

{

	DiagDirection exitdir = *(DiagDirection *)data;

}

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

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

								exitdir = ReverseDiagDir(exitdir);

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

							}

						}

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

					}

					v->direction = chosen_dir;

				}

					v->load_unload_time_rem = 0;

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

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

				}

		}

		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

		}

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

	}

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

 */

static TileIndex TrainApproachingCrossingTile(const Train *v)

{

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

	if (!TrainCanLeaveTile(v)) return INVALID_TILE;

	this->tick_counter++;

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

		this->current_order_time++;

{

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

		CheckVehicleBreakdown(this);

		AgeVehicle(this);