/// <summary>Moves the air brake handle</summary>
		/// <param name="Train">The train</param>
		/// <param name="RelativeDirection">The direction: -1 for decrease, 1 for increase</param>
		internal static void ApplyAirBrakeHandle(Train Train, int RelativeDirection)
		{
			if (Train.Cars[Train.DriverCar].Specs.BrakeType == CarBrakeType.AutomaticAirBrake)
			{
				if (RelativeDirection == -1)
				{
					if (Train.Specs.AirBrake.Handle.Driver == AirBrakeHandleState.Service)
					{
						ApplyAirBrakeHandle(Train, AirBrakeHandleState.Lap);
					}
					else
					{
						ApplyAirBrakeHandle(Train, AirBrakeHandleState.Release);
					}
				}
				else if (RelativeDirection == 1)
				{
					if (Train.Specs.AirBrake.Handle.Driver == AirBrakeHandleState.Release)
					{
						ApplyAirBrakeHandle(Train, AirBrakeHandleState.Lap);
					}
					else
					{
						ApplyAirBrakeHandle(Train, AirBrakeHandleState.Service);
					}
				}
				Game.AddBlackBoxEntry(Game.BlackBoxEventToken.None);
			}
		}

 protected void enableTrainSound(Train train)
 {
     AudioSource audioSource = train.GetComponent<AudioSource>();
     if (audioSource) {
         audioSource.enabled = true;
     }
 }

    protected override void retrieve()
    {
        string trainName = selectedTrainStorage.Get();
        selectedTrainStorage.Delete();

        train = retrieve(trainName);
    }

 /// <summary>
 /// Инициализирует билет по поезду, в котором едет пассажир, типу вагона и
 /// пассажиру, который едет по этому билету. Устанавливает ссылки от себя 
 /// на поезд и на пассажира, а также  ссылки от поезда и от пассажира на себя.
 /// </summary>
 /// <param name="Train">Поезд, в котором едет пассажир.</param>
 /// <param name="Type">Тип вагона.</param>
 public Ticket(Train Train, string Type, Passenger Passenger)
 {
     _train      = Train;
     _type       = Type;
     _passenger  = Passenger;
     Associate(Train, Passenger);
 }

 [TestInitialize] public void TestInitialize() {
     TestDataFactory.Init();
     layout = TestDataFactory.Layout();
     stretch = layout.TrackStretches.First();
     train = TestDataFactory.CreateTrain1();
     target = new TrackStretchCoordinator(stretch);
 }

 public void Decrease(Train train, int passengersToDecrease)
 {
     if (!isSet(train)) {
         passengersPerTrain[train] = initialPassengers;
     }
     passengersPerTrain[train] -= passengersToDecrease;
 }

		/// <summary>Applies a reverser notch</summary>
		/// <param name="Train">The train</param>
		/// <param name="Value">The notch to apply</param>
		/// <param name="Relative">Whether this is an absolute value or relative to the previous</param>
		internal static void ApplyReverser(Train Train, int Value, bool Relative)
		{
			int a = Train.Specs.CurrentReverser.Driver;
			int r = Relative ? a + Value : Value;
			if (r < -1) r = -1;
			if (r > 1) r = 1;
			if (a != r)
			{
				Train.Specs.CurrentReverser.Driver = r;
				if (Train.Plugin != null)
				{
					Train.Plugin.UpdateReverser();
				}
				Game.AddBlackBoxEntry(Game.BlackBoxEventToken.None);
				// sound
				if (a == 0 & r != 0)
				{
					Sounds.SoundBuffer buffer = Train.Cars[Train.DriverCar].Sounds.ReverserOn.Buffer;
					if (buffer == null) return;
					OpenBveApi.Math.Vector3 pos = Train.Cars[Train.DriverCar].Sounds.ReverserOn.Position;
					Sounds.PlaySound(buffer, 1.0, 1.0, pos, Train, Train.DriverCar, false);
				}
				else if (a != 0 & r == 0)
				{
					Sounds.SoundBuffer buffer = Train.Cars[Train.DriverCar].Sounds.ReverserOff.Buffer;
					if (buffer == null) return;
					OpenBveApi.Math.Vector3 pos = Train.Cars[Train.DriverCar].Sounds.ReverserOff.Position;
					Sounds.PlaySound(buffer, 1.0, 1.0, pos, Train, Train.DriverCar, false);
				}
			}
		}

			/// <summary>Adds a delayed handle state change</summary>
			/// <param name="Train">The train to add the delayed state change to</param>
			/// <param name="Value">The value to add or subtract</param>
			/// <param name="Delay">The delay in seconds</param>
			internal void AddChange(Train Train, int Value, double Delay)
			{
				int n = DelayedChanges.Length;
				Array.Resize<HandleChange>(ref DelayedChanges, n + 1);
				DelayedChanges[n].Value = Value;
				DelayedChanges[n].Time = Game.SecondsSinceMidnight + Delay;
			}

        [TestMethod] public void AddsFirstTimetableCall() {
            var station = TestDataFactory.CreateStation1();
            var target = new Train(TrainCategory.Freight, "G1234");
            var call = new StationCall(station.Tracks.First(), new Time(12,30) , new Time(12,45));
            target.Add(call);

        }

    public Trainmovsegment()
    {
        this.lvtrain_id = new Train();

        Clear();
        StopLocation.LoadList();
    }

 public void AddExistingTrainTest()
 {
     Administration admin = new Administration();
     Train train = new Train(1, 1);
     admin.Add(train);
     Assert.AreEqual(false, admin.Add(train));
 }

 public void WhenSecondTimetableCallIsAfterLastThenThrows() {
     var station = TestDataFactory.CreateStation1();
     var target = new Train(TrainCategory.Freight, "G1234");
     var call1 = new StationCall(station.Tracks.First(), new Time(12, 30), new Time(12, 45));
     var call2 = new StationCall(station.Tracks.First(), new Time(12, 50), new Time(12, 55));
     target.Add(call1);
     target.Add(call2);
 }

 public void NextStationTest()
 {
     Station station = new Station("test");
     Train nextTrain = new Train(1, 2);
     station.NextTrain = nextTrain;
     Assert.AreEqual(nextTrain, station.NextTrain);
     Assert.AreEqual(1, nextTrain.TrainUnit);
 }

 public void LastStationTest()
 {
     Station station = new Station("test");
     Train lastTrain = new Train(1, 2);
     station.LastTrain = lastTrain;
     Assert.AreEqual(lastTrain, station.LastTrain);
     Assert.AreEqual(1, lastTrain.TrainUnit);
 }

 public void AddedTrainCanBeFoundTest()
 {
     Administration admin = new Administration();
     Train train = new Train(1, 1);
     admin.Add(train);
     Train foundTrain = admin.FindTrain(1);
     Assert.AreEqual(foundTrain, train);
 }

 public void WriteTrain(string filename, Train train, BaseFormater formater)
 {
     Stream fs = new FileStream(filename, FileMode.Create);
     foreach (IFilter filter in filters)
         fs = filter.Apply(fs, FilterMode.Write);
     formater.WriteTrain(train, fs);
     fs.Close();
 }

    private void addPlayer(Train train, NetworkPlayer owner, NetworkTrainPlayers players)
    {
        string newTrainName = RemoteTrainName.GetNameFor(train, owner);
        Train newTrain = clone(train, newTrainName);

        NetworkTrainPlayer player = NetworkTrainPlayerFactory.Create(newTrain, owner);
        players.AddPlayer(player);
    }

 public override Train ReadTrain(Stream stream)
 {
     sr = new BinaryReader(stream);
     Train train = new Train(sr.ReadInt32());
     int count = sr.ReadInt32();
     for (int i = 0; i < count; i++)
         train.AddCoach(ReadCoach());
     return train;
 }

 public override Train ReadTrain(Stream stream)
 {
     sr = new StreamReader(stream);
     Train train = new Train(Int32.Parse(sr.ReadLine()));
     int count = Int32.Parse(sr.ReadLine());
     for (int i = 0; i < count; i++)
         train.AddCoach(ReadCoach());
     return train;
 }

		/// <summary>Un-derails a train</summary>
		/// <param name="Train">The train</param>
		internal static void UnderailTrain(Train Train)
		{
			Train.Derailed = false;
			for (int i = 0; i < Train.Cars.Length; i++)
			{
				Train.Cars[i].Specs.CurrentRollDueToTopplingAngle = 0.0;
				Train.Cars[i].Derailed = false;
			}
		}