MSTSLocomotive.cs

// COPYRIGHT 2009, 2010, 2011, 2012, 2013 by the Open Rails project.
// 
// This file is part of Open Rails.
// 
// Open Rails is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Open Rails is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Open Rails.  If not, see <http://www.gnu.org/licenses/>.

/* LOCOMOTIVE CLASSES
 * 
 * Used as a base for Steam, Diesel and Electric locomotive classes.
 * 
 * A locomotive is represented by two classes:
 *  MSTSLocomotive - defines the behaviour, ie physics, motion, power generated etc
 *  MSTSLocomotiveViewer - defines the appearance in a 3D viewer including animation for wipers etc
 *  
 * Both these classes derive from corresponding classes for a basic TrainCar
 *  TrainCar - provides for movement, rolling friction, etc
 *  TrainCarViewer - provides basic animation for running gear, wipers, etc
 *  
 * Locomotives can either be controlled by a player, 
 * or controlled by the train's MU signals for brake and throttle etc.
 * The player controlled loco generates the MU signals which pass along to every
 * unit in the train.
 * For AI trains, the AI software directly generates the MU signals - there is no
 * player controlled train.
 * 
 * The end result of the physics calculations for the the locomotive is
 * a TractiveForce and a FrictionForce ( generated by the TrainCar class )
 * 
 */

//#define ALLOW_ORTS_SPECIFIC_ENG_PARAMETERS

// Debug for Advanced Adhesion Model
// #define DEBUG_ADHESION

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Orts.Common;
using Orts.Formats.Msts;
using Orts.MultiPlayer;
using Orts.Parsers.Msts;
using Orts.Simulation.Physics;
using Orts.Simulation.RollingStocks.SubSystems;
using Orts.Simulation.RollingStocks.SubSystems.Brakes;
using Orts.Simulation.RollingStocks.SubSystems.Brakes.MSTS;
using Orts.Simulation.RollingStocks.SubSystems.Controllers;
using Orts.Simulation.RollingStocks.SubSystems.PowerSupplies;
using Orts.Simulation.RollingStocks.SubSystems.PowerTransmissions;
using ORTS.Common;
using ORTS.Scripting.Api;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using Event = Orts.Common.Event;

namespace Orts.Simulation.RollingStocks
{

    ///////////////////////////////////////////////////
    ///   SIMULATION BEHAVIOUR
    ///////////////////////////////////////////////////

    public enum CabViewType
    {
        Front = 0,
        Rear = 1,
        Void = 2
    }

    /// <summary>
    /// Adds Throttle, Direction, Horn, Sander and Wiper control
    /// to the basic TrainCar.
    /// Use as a base for Electric, Diesel or Steam locomotives.
    /// </summary>
    public partial class MSTSLocomotive : MSTSWagon
    {

        public enum CombinedControl
        {
            None,
            ThrottleDynamic,
            ThrottleAir,
            ThrottleDynamicAir,
            DynamicAir,
        }

        public enum SoundState
        {
            Stopped,
            Sound,
            ContinuousSound
        }

        // simulation parameters
        public bool ManualHorn = false;
        public bool TCSHorn = false;
        public bool Horn = false;
        protected bool PreviousHorn = false;

        protected float HornTimerS = 30.0f;
        protected float? HornStartTime;
        public bool HornRecent { get; private set; }

        public bool ManualBell = false;
        public SoundState BellState = SoundState.Stopped;
        public bool Bell = false;
        protected bool PreviousBell = false;

        protected float BellTimerS;
        protected float? BellStartTime;
        public bool BellRecent { get; private set; }

        public bool VacuumExhausterPressed = false;
        public bool FastVacuumExhausterFitted = false;

        public bool AlerterSnd;
        public bool VigilanceMonitor;
        public bool Sander;
        public bool Wiper;
        public bool BailOff;
        public bool DynamicBrake;
        public float MaxPowerW;
        public float MaxForceN;
        public float AbsTractionSpeedMpS;
        public float MaxCurrentA = 0;
        public float MaxSpeedMpS = 1e3f;
        public float UnloadingSpeedMpS;
        public float MainResPressurePSI = 130;
        public float BrakePipeFlowM3pS;
        public float MaximumMainReservoirPipePressurePSI;
        public bool CompressorIsOn;
        public bool CompressorIsMechanical = false;
        public float AverageForceN;
        public float PowerOnDelayS;
        public bool CabLightOn;
        public bool ShowCab = true;
        public bool MilepostUnitsMetric;
        public int DPUnitID;
        public float DrvWheelWeightKg; // current weight on locomotive drive wheels, includes drag factor (changes as mass changes)
        public float InitialDrvWheelWeightKg; // initialising weight on locomotive drive wheels, includes drag factor
        public bool CabRadioOn;
        public bool OnLineCabRadio;
        public string OnLineCabRadioURL;

        public float ZeroSpeedAdhesionBase;

        public float FilteredBrakePipeFlowM3pS;
        public IIRFilter AFMFilter;

        // Water trough filling
        public bool HasWaterScoop = false; // indicates whether loco + tender have a water scoop or not
        public float ScoopMaxPickupSpeedMpS = 200.0f; // Maximum scoop pickup speed - used in steam locomotive viewer
        public bool ScoopIsBroken = false; // becomes broken if activated where there is no trough
        public bool RefillingFromTrough = false; // refilling from through is ongoing
        public float WaterScoopFillElevationM; // height water has to be raised to fill tender
        public float WaterScoopDepthM; // depth that water scoop goes into trough (pan)
        public float WaterScoopWidthM; // width of water scoop
        public float WaterScoopVelocityMpS; // Velocity of water entering water scoop
        public float WaterScoopDragForceN; // drag force due to scoop being in water trough
        public float WaterScoopedQuantityLpS; // Amount of water scooped up by water scoop per second
        public float WaterScoopInputAmountL; // Water scooped in elapsed time
        public float WaterScoopMinSpeedMpS; // Minimum speed for water pickup
        public bool IsWaterScoopDown = false;
        public bool WaterScoopDown;
        public const float GravitationalAccelerationFtpSpS = 32.26f;
        public float TenderWaterLevelFraction;
        public float WaterScoopTotalWaterL;
        bool WaterScoopOverTroughFlag = false;
        bool WaterScoopNotFittedFlag = false;
        bool WaterScoopSlowSpeedFlag = false;
        bool WaterScoopDirectionFlag = false;
        public bool IsWaterScoopPlayerLocomotive = false;
        bool WaterScoopSoundOn = false;
        public float MaxTotalCombinedWaterVolumeUKG;
        public MSTSNotchController WaterController = new MSTSNotchController(0, 1, 0.01f);
        public float CombinedTenderWaterVolumeUKG          // Decreased by running injectors and increased by refilling
        {          
            get { return WaterController.CurrentValue * MaxTotalCombinedWaterVolumeUKG; }
            set { WaterController.CurrentValue = value / MaxTotalCombinedWaterVolumeUKG; }
        }

        public float CurrentLocomotiveSteamHeatBoilerWaterCapacityL
        {
            get {
                if (IsSteamHeatFitted)
                {
                 return WaterController.CurrentValue * MaximumSteamHeatBoilerWaterTankCapacityL;
                }
                else
                {
                    return 0;
                }
            }

            set { WaterController.CurrentValue = value / MaximumSteamHeatBoilerWaterTankCapacityL; }
        }
        public float IsTenderRequired = 1.0f;  // Flag indicates that a tender is required for operation of the locomotive. Typically tank locomotives do not require a tender. Assume by default that tender is required.

        public float BoilerPressurePSI;     // Steam Gauge pressure - what the engineer sees.
        public float MaxBoilerPressurePSI = 180f;  // maximum boiler pressure, safety valve setting

        public float SandingSteamUsageLBpS;       // Sanding Steam Usage

        // Vacuum Reservoir and Exhauster Settings

        // Steam heating Flags
        public bool IsSteamInitial = true;        // To initialise steam heat
        public bool IsSteamHeatFirstTime = true;  // Flag for first pass at steam heating.
        public bool IsSteamHeatFitted = false;    // Is steam heating fitted to locomotive
        public float CurrentSteamHeatPressurePSI = 0.0f;   // Current pressure in steam heat system

        public string LocomotiveName; // Name of locomotive from ENG file

        // Carriage Steam Heating Parameters
        public float MaxSteamHeatPressurePSI;    // Maximum Steam heating pressure
        public Interpolator SteamHeatPressureToTemperaturePSItoF;
        public Interpolator SteamDensityPSItoLBpFT3;   // saturated steam density given pressure
        public Interpolator SteamHeatPSItoBTUpLB;      // total heat in saturated steam given pressure
        public bool IsSteamHeatingBoilerFitted = false;   // Flag to indicate when steam heat boiler van is fitted
        public float CalculatedCarHeaterSteamUsageLBpS;

        // Adhesion Debug
        // Commented out as never used
        //bool DebugSpeedReached;
        //float DebugSpeedIncrement = 5.0f; // Speed increment for debug display - in mph
        //float DebugSpeed = 5.0f; // Initialise at 5 mph
        //float DebugTimer = 0.0f;

        // Adhesion parameters
        public enum SlipControlType
        {
            None,
            Full
        }
        public SlipControlType SlipControlSystem;
        float BaseFrictionCoefficientFactor;  // Factor used to adjust Curtius formula depending upon weather conditions
        float SlipFrictionCoefficientFactor;
        public float SteamStaticWheelForce;
        public float SteamTangentialWheelForce;
        public float SteamDrvWheelWeightLbs;  // Weight on each drive axle
        public float PreviousThrottleSetting = 0.0f;  // Holds the value of the previous throttle setting for calculating the correct antislip speed
        float DebugTimer; // Used for debugging adhesion coefficient
        bool DebugSpeedReached = false; // Used for debugging adhesion coefficient
        float DebugSpeedIncrement = 1; // Used for debugging adhesion coefficient
        float DebugSpeed = 1; // Used for debugging adhesion coefficient

        // parameters for Track Sander based upon compressor air and abrasive table for 1/2" sand blasting nozzle @ 50psi
        public float MaxTrackSandBoxCapacityM3; // Capacity of sandbox
        public float MaxTrackSanderAirComsumptionForwardM3pS;
        public float MaxTrackSanderAirComsumptionReverseM3pS = 0;
        public float MaxTrackSanderSandConsumptionForwardM3pS;
        public float CurrentTrackSanderAirConsumptionM3pS;
        public float CurrentTrackSanderSandConsumptionM3pS;
        public float CurrentTrackSandBoxCapacityM3; 
        public float MaxTrackSanderSandConsumptionReverseM3pS = 0;
        public float SandWeightKgpM3 = 1600; // One cubic metre of sand weighs about 1.54-1.78 tonnes. 
        public float MaxTrackSanderSteamConsumptionForwardLbpS;
        public float MaxTrackSanderSteamConsumptionReverseLbpS = 0;


        // Vacuum Braking parameters
        readonly static float OneAtmospherePSI = Bar.ToPSI(1);
        public bool SmallSteamEjectorIsOn = false;
        public bool LargeSteamEjectorIsOn = false;
        public bool VacuumPumpOperating = false;
        public float SteamEjectorSmallPressurePSI = 0.0f;
        public float SteamEjectorLargePressurePSI = 0.0f;
        public bool VacuumPumpFitted;
        public bool SmallEjectorControllerFitted = false;
        public float VacuumPumpResistanceN;
        public float EjectorSmallSteamConsumptionLbpS;
        public float EjectorLargeSteamConsumptionLbpS;
        public float SteamEjectorSmallSetting = 0.0f;
        public float SteamEjectorLargeSetting = 0.0f;
        public float MaxVaccuumMaxPressurePSI = 110.0f;  // Value for the boiler pressure when maximum vacuum will be produced for the steam ejector 
        public float SmallEjectorFeedFraction = 0.35f;
        public float LargeEjectorFeedFraction = 1.0f;
        public bool LargeEjectorControllerFitted = false;
        public float VacuumPumpChargingRateInHgpS = 0.0f;
        public bool VacuumBrakeEQFitted = false;  // Flag to indicate that equalising resevoir fitted to vacuum brakes
        public float HUDNetBPLossGainPSI;
        public float SmallEjectorBrakePipeChargingRatePSIorInHgpS;
        public float LargeEjectorBrakePipeChargingRatePSIorInHgpS;
        public float ExhausterHighSBPChargingRatePSIorInHgpS;  // Rate for Exhauster in high speed mode
        public float ExhausterLowSBPChargingRatePSIorInHgpS;  // Rate for Exhauster in high speed mode
        public bool VacuumBrakeCutoffActivated = false;
        public bool BrakeFlagDecrease = false;
        public bool BrakeFlagIncrease = false;

        private bool _SmallEjectorSoundOn = false;
        public bool SmallEjectorSoundOn
        {
            get => _SmallEjectorSoundOn;
            set
            {
                if (value != _SmallEjectorSoundOn)
                {
                    SignalEvent(value? Event.SmallEjectorOn : Event.SmallEjectorOff);
                    _SmallEjectorSoundOn = value;
                }
            }
        }

        private bool _LargeEjectorSoundOn = false;
        public bool LargeEjectorSoundOn
        {
            get => _LargeEjectorSoundOn;
            set
            {
                if (value != _LargeEjectorSoundOn)
                {
                    SignalEvent(value? Event.LargeEjectorOn : Event.LargeEjectorOff);
                    _LargeEjectorSoundOn = value;
                }
            }
       }

        public bool DriveWheelOnlyBrakes = false;
        public bool SteamEngineBrakeFitted = false;
        public bool TrainBrakeFitted = false;
        public bool EngineBrakeFitted = false;
        public bool BrakemanBrakeFitted = false;
        public bool VacuumExhausterIsOn = false;
        public float VacuumBrakesMainResVolumeM3 = Me3.FromFt3(200.0f); // Main vacuum reservoir volume
        public float VacuumBrakesMainResMaxVacuumPSIAorInHg = Vac.ToPress(23);
        public float VacuumBrakesExhausterRestartVacuumPSIAorInHg = Vac.ToPress(21);
        public float VacuumBrakesMainResChargingRatePSIAorInHgpS = Bar.ToPSI(Bar.FromInHg(0.2f));
        public float VacuumMainResVacuumPSIAorInHg = Vac.ToPress(23); // Vacuum currently in Main Reservoir

        // Set values for display in HUD
        public float WagonCoefficientFrictionHUD;
        public float LocomotiveCoefficientFrictionHUD;
        public float HuDGearMaximumTractiveForce;

        public PressureUnit MainPressureUnit = PressureUnit.None;
        public Dictionary<BrakeSystemComponent, PressureUnit> BrakeSystemPressureUnits = new Dictionary<BrakeSystemComponent, PressureUnit>
        {
            { BrakeSystemComponent.MainReservoir, PressureUnit.None },
            { BrakeSystemComponent.EqualizingReservoir, PressureUnit.None },
            { BrakeSystemComponent.AuxiliaryReservoir, PressureUnit.None },
            { BrakeSystemComponent.EmergencyReservoir, PressureUnit.None },
            { BrakeSystemComponent.MainPipe, PressureUnit.None },
            { BrakeSystemComponent.BrakePipe, PressureUnit.None },
            { BrakeSystemComponent.BrakeCylinder, PressureUnit.None }
        };

        protected float OdometerResetPositionM = 0;
        protected bool OdometerCountingUp = true;
        protected bool OdometerCountingForwards = true;
        public bool OdometerResetButtonPressed = false;

        public bool OdometerVisible { get; private set; }
        public float OdometerM
        {
            get
            {
                if (Train == null)
                    return 0;

                return OdometerCountingForwards ? Train.DistanceTravelledM - OdometerResetPositionM : OdometerResetPositionM - Train.DistanceTravelledM;
            }
        }

        // ENG file data
        public string CabSoundFileName;
        public string CVFFileName;
        public float MaxMainResPressurePSI;
        public float MainResVolumeM3;
        public float TrainBrakePipeLeakPSIorInHgpS = 0.0f;    // Air leakage from train brake pipe - should normally be no more then 5psi/min - default off
        public float CompressorRestartPressurePSI = 110;
        public float CompressorChargingRateM3pS = 0.075f;
        public bool CompressorIsMUControlled = false;
        public float MainResChargingRatePSIpS = 0.4f;
        public float EngineBrakeReleaseRatePSIpS = 12.5f;
        public float EngineBrakeApplyRatePSIpS = 12.5f;
        public float BrakePipeTimeFactorS = 0.0015f;
        public float BrakePipeDischargeTimeFactor;
        public float BrakeServiceTimeFactorPSIpS;
        public float BrakeEmergencyTimeFactorPSIpS;
        public float BrakePipeChargingRatePSIorInHgpS;
        public float BrakePipeQuickChargingRatePSIpS;
        public InterpolatorDiesel2D TractiveForceCurves;
        public InterpolatorDiesel2D DynamicBrakeForceCurves;
        public float DynamicBrakeSpeed1MpS = MpS.FromKpH(5);
        public float DynamicBrakeSpeed2MpS = MpS.FromKpH(30);
        public float DynamicBrakeSpeed3MpS = MpS.FromKpH(999);
        public float DynamicBrakeSpeed4MpS = MpS.FromKpH(999);
        public float DynamicBrakeRatioAtSpeed4 = 0;
        public float MaxDynamicBrakeForceN;
        public float DynamicBrakeMaxCurrentA;
        public float DynamicBrakeDelayS;
        public bool DynamicBrakeAutoBailOff;
        public bool DynamicBrakePartialBailOff;
        public bool UsingRearCab;
        public bool BrakeOverchargeSoundOn = false;
        protected bool DynamicBrakeBlendingEnabled; // dynamic brake blending is configured
        public bool DynamicBrakeAvailable; // dynamic brake is available
        AirSinglePipe airPipeSystem;
        public double? DynamicBrakeCommandStartTime;
        protected bool DynamicBrakeBlendingOverride; // true when DB lever >0% should always override the blending. When false, the bigger command is applied.
        protected bool DynamicBrakeBlendingForceMatch = true; // if true, dynamic brake blending tries to achieve the same braking force as the airbrake would have.
        protected bool DynamicBrakeControllerSetupLock; // if true if dynamic brake lever will lock until dynamic brake is available

        public float DynamicBrakeBlendingPercent { get; protected set; } = -1;

        public CombinedControl CombinedControlType;
        public float CombinedControlSplitPosition;
        public bool HasSmoothStruc;

        bool controlTrailerBrakeSystemSet = false;

        public float MaxContinuousForceN;
        public float SpeedOfMaxContinuousForceMpS;  // Speed where maximum tractive effort occurs
        public float MSTSSpeedOfMaxContinuousForceMpS;  // Speed where maximum tractive effort occurs - MSTS parameter if used
        public float ContinuousForceTimeFactor = 1800;
        public bool AntiSlip;
        public bool AdvancedAdhesionModel = false; // flag set depending upon adhesion model used.
        public float SanderSpeedEffectUpToMpS;
        public float SanderSpeedOfMpS = 30.0f;
        public string EngineOperatingProcedures;

        public bool EmergencyButtonPressed { get; set; }
        public bool EmergencyCausesPowerDown { get; private set; }
        public bool EmergencyCausesThrottleDown { get; private set; }
        public bool EmergencyEngagesHorn { get; private set; }
        public bool WheelslipCausesThrottleDown { get; private set; }

        public float BrakeRestoresPowerAtBrakePipePressurePSI;
        public float BrakeCutsPowerAtBrakePipePressurePSI;
        public bool DoesVacuumBrakeCutPower { get; private set; }
        public bool DoesBrakeCutPower { get; private set; }
        public float BrakeCutsPowerAtBrakeCylinderPressurePSI { get; private set; }
        public bool DoesHornTriggerBell { get; private set; }
        public bool DPSyncTrainApplication { get; private set; }
        public bool DPSyncTrainRelease { get; private set; }
        public bool DPSyncEmergency { get; private set; }
        public bool DPSyncIndependent { get; private set; } = true;

        protected const float DefaultCompressorRestartToMaxSysPressureDiff = 35;    // Used to check if difference between these two .eng parameters is correct, and to correct it
        protected const float DefaultMaxMainResToCompressorRestartPressureDiff = 10; // Used to check if difference between these two .eng parameters is correct, and to correct it
        protected const float DefaultMaxCompressorRestartPressure = 135; // Max value to be inserted if .eng parameters are corrected
        protected const float DefaultMainResVolume = 0.78f; // Value to be inserted if .eng parameters are corrected
        protected const float DefaultMaxMainResPressure = 140; // Max value to be inserted if .eng parameters are corrected

        public List<CabView> CabViewList = new List<CabView>();
        public CabView3D CabView3D;

        public MSTSNotchController SteamHeatController = new MSTSNotchController(0, 1, 0.1f);

        public MSTSNotchController ThrottleController;
        public ScriptedBrakeController TrainBrakeController;
        public ScriptedBrakeController EngineBrakeController;
        public ScriptedBrakeController BrakemanBrakeController;
        public AirSinglePipe.ValveState EngineBrakeState = AirSinglePipe.ValveState.Lap;
        public MSTSNotchController DynamicBrakeController;
        public MSTSNotchController GearBoxController;
        public MSTSNotchController DPThrottleController;
        public MSTSNotchController DPDynamicBrakeController;

        private int PreviousGearBoxNotch;
        private int previousChangedGearBoxNotch;

        public float EngineBrakeIntervention = -1;
        public float TrainBrakeIntervention = -1;
        public float ThrottleIntervention = -1;
        public float DynamicBrakeIntervention = -1;

        public enum TractionMotorTypes
        {
            DC,
            AC,
        }
        public TractionMotorTypes TractionMotorType = TractionMotorTypes.DC;
        public List<ElectricMotor> TractionMotors = new List<ElectricMotor>();

        public ILocomotivePowerSupply LocomotivePowerSupply => PowerSupply as ILocomotivePowerSupply;
        public ScriptedTrainControlSystem TrainControlSystem;

        public IIRFilter CurrentFilter;
        public IIRFilter AdhesionFilter;
        public float SaveAdhesionFilter;
        public float AdhesionConditions;

        public float FilteredMotiveForceN;

        public double CommandStartTime;

        public double LastBrakeSoundTime = 0;

        public float PowerReduction = 0;

        // Cruise Control
        public CruiseControl CruiseControl;
        //       public MultiPositionController MultiPositionController;
        public List<MultiPositionController> MultiPositionControllers;

        public MSTSLocomotive(Simulator simulator, string wagPath)
            : base(simulator, wagPath)
        {
          //  BrakePipeChargingRatePSIpS = Simulator.Settings.BrakePipeChargingRate;
                        
            MilepostUnitsMetric = Simulator.TRK.Tr_RouteFile.MilepostUnitsMetric;
            BrakeCutsPowerAtBrakeCylinderPressurePSI = 4.0f;

            LocomotiveAxles.Add(new Axle());
            CurrentFilter = new IIRFilter(IIRFilter.FilterTypes.Butterworth, 1, IIRFilter.HzToRad(0.5f), 0.001f);
            AdhesionFilter = new IIRFilter(IIRFilter.FilterTypes.Butterworth, 1, IIRFilter.HzToRad(1f), 0.001f);
            AFMFilter = new IIRFilter(IIRFilter.FilterTypes.Butterworth, 1, IIRFilter.HzToRad(0.1f), 1.0f);

            TrainBrakeController = new ScriptedBrakeController(this);
            EngineBrakeController = new ScriptedBrakeController(this);
            BrakemanBrakeController = new ScriptedBrakeController(this);
            MultiPositionControllers = new List<MultiPositionController>();
            ThrottleController = new MSTSNotchController();
            DynamicBrakeController = new MSTSNotchController();
            TrainControlSystem = new ScriptedTrainControlSystem(this);
        }

        /// <summary>
        /// This initializer is called when we haven't loaded this type of car before
        /// and must read it new from the wag file.
        /// </summary>
        public override void LoadFromWagFile(string wagFilePath)
        {
            base.LoadFromWagFile(wagFilePath);

            // Assumes that CabViewList[0] is the front cab
            // and that CabViewList[1] is the rear cab, if present.
            // Could be extended to more than 2 cabs.
            if (CVFFileName != null)
            {
                var cabView = BuildCabView(WagFilePath, CVFFileName);
                if (cabView != null)
                {
                    CabViewList.Add(cabView);
                    var reverseCVFFileName = Path.Combine(
                        Path.GetDirectoryName(CVFFileName), // Some CVF paths begin with "..\..\", so Path.GetDirectoryName() is needed.
                        Path.GetFileNameWithoutExtension(CVFFileName) + "_rv.cvf"
                    );

                    {
                        cabView = BuildCabView(WagFilePath, reverseCVFFileName);
                        if (cabView != null)
                            CabViewList.Add(cabView);
                    }
                    // practically never happens, but never say never
                    if (CabViewList.Count == 2 && CabViewList[1].CabViewType == CabViewType.Front && CabViewList[0].CabViewType == CabViewType.Rear)
                    {
                        cabView = CabViewList[1];
                        CabViewList.Insert(0, cabView);
                        CabViewList.RemoveAt(2);
                    }
                    // only one cabview, and it looks rear; insert a void one at first place to maintain fast indexing
                    else if (CabViewList.Count == 1 && CabViewList[0].CabViewType == CabViewType.Rear)
                    {
                        UsingRearCab = true;
                        CabViewList.Add(CabViewList[0]);
                        CabViewList[0].CabViewType = CabViewType.Void;
                    }
                }
                CabView3D = BuildCab3DView();
                if (CabViewList.Count == 0 & CabView3D == null)
                    Trace.TraceWarning("{0} locomotive's CabView references non-existent {1}", wagFilePath, CVFFileName);
            }

            DrvWheelWeightKg = InitialDrvWheelWeightKg;

            // If DrvWheelWeight is not in ENG file, then set drivewheel weight the same as locomotive mass

            if (DrvWheelWeightKg == 0) // if DrvWheelWeightKg not in ENG file.
            {
                DrvWheelWeightKg = MassKG; // set Drive wheel weight to total wagon mass if not in ENG file
                InitialDrvWheelWeightKg = MassKG; // // set Initial Drive wheel weight as well, as it is used as a reference
            }

            CorrectBrakingParams();
            CheckCoherence();
            GetPressureUnit();
            IsDriveable = true;

            MoveParamsToAxle();
        }

        protected void CheckCoherence()
        {
            if (!TrainBrakeController.IsValid())
                TrainBrakeController = new ScriptedBrakeController(this); //create a blank one

            if (!EngineBrakeController.IsValid())
                EngineBrakeController = null;

            if (!BrakemanBrakeController.IsValid())
                BrakemanBrakeController = null;

            if (ThrottleController == null)
            {
                //If no controller so far, we create a default one
                ThrottleController = new MSTSNotchController();
                ThrottleController.StepSize = 0.1f;
            }
            DPThrottleController = (MSTSNotchController)ThrottleController.Clone();

            // need to test for Dynamic brake problem on 3DTS and SLI
            if (DynamicBrakeController.IsValid())
            {
                if (DynamicBrakeController.NotchCount() <= 3)
                {
                    HasSmoothStruc = true;
                }
                if (DynamicBrakeController.NotchCount() > 3)
                    DPDynamicBrakeController = (MSTSNotchController)DynamicBrakeController.Clone();
                else
                    DPDynamicBrakeController = BuildDPDynamicBrakeController();
            }
            else
            {
                DynamicBrakeController = null;
                DPDynamicBrakeController = null;
            }

            if (DynamicBrakeForceCurves == null && MaxDynamicBrakeForceN > 0)
            {
                DynamicBrakeForceCurves = new InterpolatorDiesel2D(2);
                Interpolator interp = new Interpolator(2);
                interp[0] = 0;
                interp[100] = 0;
                DynamicBrakeForceCurves[0] = interp;
                interp = new Interpolator(7);
                interp[0] = 0;
                interp[DynamicBrakeSpeed1MpS] = 0;
                interp[DynamicBrakeSpeed2MpS] = MaxDynamicBrakeForceN;
                interp[DynamicBrakeSpeed3MpS] = MaxDynamicBrakeForceN;
                interp[DynamicBrakeSpeed4MpS] = DynamicBrakeRatioAtSpeed4 * MaxDynamicBrakeForceN;
                interp[DynamicBrakeSpeed4MpS + 0.5f] = 0;
                interp[100] = 0;
                DynamicBrakeForceCurves[1] = interp;
            }
        }
         
        protected MSTSNotchController BuildDPDynamicBrakeController()
        {
            var dpDynController = new MSTSNotchController();
            CabView cabView = null;
            CVCMultiStateDisplay msDisplay = null;
            if (CabView3D != null)
                cabView = CabView3D;
            else if (CabViewList.Count > 0)
            {
                if (CabViewList[0].CabViewType == CabViewType.Front)
                    cabView = CabViewList[0];
                else
                    cabView = CabViewList[1];
            }
            if (cabView != null)
            {
                try
                {
                    msDisplay = (CVCMultiStateDisplay) cabView.CVFFile.CabViewControls.Where(
                        control => control is CVCMultiStateDisplay &&
                        (((CVCMultiStateDisplay) control).ControlType.Type == CABViewControlTypes.DYNAMIC_BRAKE_DISPLAY ||
                        ((CVCMultiStateDisplay) control).ControlType.Type == CABViewControlTypes.CPH_DISPLAY)).First();
                }
                catch
                {

                }
                if (msDisplay != null)
                {
                    if (msDisplay.ControlType.Type == CABViewControlTypes.DYNAMIC_BRAKE_DISPLAY)
                    {
                        foreach (var switchval in msDisplay.Values)
                            dpDynController.AddNotch((float) switchval);
                    }
                    else
                    {
                        foreach (var switchval in msDisplay.Values)
                        {
                            if (switchval<CombinedControlSplitPosition)
                                continue;
                            dpDynController.AddNotch((float)(switchval - CombinedControlSplitPosition) / (1 - CombinedControlSplitPosition));
                        }
                    }
                }
            }
            if (cabView == null || msDisplay == null)
            // Use default Dash9 arrangement if no display is found
            {
                var switchval = 0f;
                while (switchval <= 1)
                {
                    if (switchval == 0.99f)
                        switchval = 1;
                    dpDynController.AddNotch(switchval);
                    switchval += 0.11f;
                }
            }


            return dpDynController;
        }


        protected void GetPressureUnit()
        {
            switch (Simulator.Settings.PressureUnit)
            {
                default:
                case "Automatic":
                    if (CabViewList.Count > 0)
                    {
                        Dictionary<CABViewControlTypes, BrakeSystemComponent> brakeSystemComponents = new Dictionary<CABViewControlTypes, BrakeSystemComponent>
                        {
                            { CABViewControlTypes.MAIN_RES, BrakeSystemComponent.MainReservoir },
                            { CABViewControlTypes.EQ_RES, BrakeSystemComponent.EqualizingReservoir },
                            { CABViewControlTypes.BRAKE_CYL, BrakeSystemComponent.BrakeCylinder },
                            { CABViewControlTypes.BRAKE_PIPE, BrakeSystemComponent.BrakePipe }
                        };

                        Dictionary<CABViewControlUnits, PressureUnit> pressureUnits = new Dictionary<CABViewControlUnits, PressureUnit>
                        {
                            { CABViewControlUnits.KILOPASCALS, PressureUnit.KPa },
                            { CABViewControlUnits.BAR, PressureUnit.Bar },
                            { CABViewControlUnits.PSI, PressureUnit.PSI },
                            { CABViewControlUnits.INCHES_OF_MERCURY, PressureUnit.InHg },
                            { CABViewControlUnits.KGS_PER_SQUARE_CM, PressureUnit.KgfpCm2 }
                       };

                        CabViewControls cvcList = CabViewList[0].CVFFile.CabViewControls;
                        foreach (CabViewControl cvc in cvcList)
                        {
                            if (brakeSystemComponents.TryGetValue(cvc.ControlType.Type, out var component) && pressureUnits.TryGetValue(cvc.Units, out var unit))
                            {
                                BrakeSystemPressureUnits[component] = unit;
                            }
                        }
                    }

                    // Manual rules :
                    BrakeSystemPressureUnits[BrakeSystemComponent.MainPipe] = BrakeSystemPressureUnits[BrakeSystemComponent.MainReservoir]; // Main Pipe is supplied by Main Reservoir
                    BrakeSystemPressureUnits[BrakeSystemComponent.AuxiliaryReservoir] = BrakeSystemPressureUnits[BrakeSystemComponent.BrakePipe]; // Auxiliary Reservoir is supplied by Brake Pipe (in single pipe brakes)
                    BrakeSystemPressureUnits[BrakeSystemComponent.EmergencyReservoir] = BrakeSystemPressureUnits[BrakeSystemComponent.BrakePipe]; // Emergency Reservoir is supplied by Brake Pipe

                    foreach (BrakeSystemComponent component in BrakeSystemPressureUnits.Keys.ToList())
                    {
                        if (BrakeSystemPressureUnits[component] == PressureUnit.None)
                        {
                            BrakeSystemPressureUnits[component] = (MilepostUnitsMetric ? PressureUnit.Bar : PressureUnit.PSI);
                        }
                    }
                    break;

                case "bar":
                    foreach (BrakeSystemComponent component in BrakeSystemPressureUnits.Keys.ToList())
                    {
                        BrakeSystemPressureUnits[component] = PressureUnit.Bar;
                    }
                    break;

                case "PSI":
                    foreach (BrakeSystemComponent component in BrakeSystemPressureUnits.Keys.ToList())
                    {
                        BrakeSystemPressureUnits[component] = PressureUnit.PSI;
                    }
                    break;

                case "inHg":
                    foreach (BrakeSystemComponent component in BrakeSystemPressureUnits.Keys.ToList())
                    {
                        BrakeSystemPressureUnits[component] = PressureUnit.InHg;
                    }
                    break;

                case "kgf/cm^2":
                    foreach (BrakeSystemComponent component in BrakeSystemPressureUnits.Keys.ToList())
                    {
                        BrakeSystemPressureUnits[component] = PressureUnit.KgfpCm2;
                    }
                    break;
            }

            // The main pressure unit is the one that is the most present in the brake system
            MainPressureUnit = BrakeSystemPressureUnits.Values.ToList()
                .GroupBy(x => x)
                .OrderByDescending(x => x.Count())
                .First().Key;
        }

        protected CabView BuildCabView(string wagFilePath, string cvfFileName)
        {
            var viewPointList = new List<ViewPoint>();
            var extendedCVF = new ExtendedCVF();
            bool noseAhead = false;

            var cvfBasePath = Path.Combine(Path.GetDirectoryName(wagFilePath), "CABVIEW");
            var cvfFilePath = Path.Combine(cvfBasePath, cvfFileName);
            if (!File.Exists(cvfFilePath))
                return null;

            var cvfFile = new CabViewFile(cvfFilePath, cvfBasePath);
            var viewPoint = new ViewPoint();
            if (cvfFile.Locations.Count <= 0) return null; //check for Protrain's dummy cab
            // Set up camera locations for the cab views
            for (int i = 0; i < cvfFile.Locations.Count; ++i)
            {
                if (i >= cvfFile.Locations.Count || i >= cvfFile.Directions.Count)
                {
                    Trace.TraceWarning("Skipped cab view camera {1} missing Position and Direction in {0}", cvfFilePath, i);
                    break;
                }
                viewPoint = new ViewPoint();
                viewPoint.Location = cvfFile.Locations[i];
                viewPoint.StartDirection = cvfFile.Directions[i];
                viewPoint.RotationLimit = new Vector3(0, 0, 0);  // cab views have a fixed head position
                viewPointList.Add(viewPoint);
            }
            var cabViewType = new CabViewType();
            cabViewType = ((viewPointList[0].StartDirection.Y >= 90 && viewPointList[0].StartDirection.Y <= 270)
                || (viewPointList[0].StartDirection.Y <= -90 && viewPointList[0].StartDirection.Y >= -270)) ? CabViewType.Rear : CabViewType.Front;
            var wag = this as MSTSWagon;
            var wagFolderSlash = Path.GetDirectoryName(wag.WagFilePath) + @"\";
            string shapeFilePath;
            bool boundingLimitsFound = false;
            ShapeDescriptorFile shapeFile = new ShapeDescriptorFile();
            if (wag.FreightShapeFileName != null)
            {
                shapeFilePath = wagFolderSlash + wag.FreightShapeFileName;
                if (shapeFilePath != null && File.Exists(shapeFilePath + "d"))
                {
                    shapeFile = new ShapeDescriptorFile(shapeFilePath + "d");
                    if (shapeFile.shape.ESD_Bounding_Box != null) boundingLimitsFound = true;
                }
            }
            if (!boundingLimitsFound)
            {
                shapeFilePath = wagFolderSlash + wag.MainShapeFileName;
                if (shapeFilePath != null && File.Exists(shapeFilePath + "d"))
                {
                    shapeFile = new ShapeDescriptorFile(shapeFilePath + "d");
                    if (shapeFile.shape.ESD_Bounding_Box != null) boundingLimitsFound = true;
                }
            }
            if (boundingLimitsFound)
            {
                if (cabViewType == CabViewType.Front)
                    noseAhead = (viewPointList[0].Location.Z + 0.5f < shapeFile.shape.ESD_Bounding_Box.Max.Z) ? true : false;
                else if (cabViewType == CabViewType.Rear)
                    noseAhead = (viewPointList[0].Location.Z - 0.5f > shapeFile.shape.ESD_Bounding_Box.Min.Z) ? true : false;
            }
            if (!(this is MSTSSteamLocomotive))
            {
                InitializeFromORTSSpecific(cvfFilePath, extendedCVF);
            }
            return new CabView(cvfFile, viewPointList, extendedCVF, cabViewType, noseAhead);
        }

        protected CabView3D BuildCab3DView()
        {
            if (Cab3DShapeFileName == null)
                return null;

            var extendedCVF = new ExtendedCVF();
            bool noseAhead = false;

            var cab3dBasePath = Path.Combine(Path.GetDirectoryName(WagFilePath), "CABVIEW3D");
            var shapeFilePath = Path.Combine(cab3dBasePath, Cab3DShapeFileName);
            if (!File.Exists(shapeFilePath))
                return null;

            var cvfBasePath = cab3dBasePath;
            var cvfFilePath = Path.Combine(cvfBasePath, Path.ChangeExtension(Cab3DShapeFileName, "cvf"));
            if (!File.Exists(cvfFilePath))
            {
                cvfFilePath = Path.Combine(cvfBasePath, CVFFileName);
                if (!File.Exists(cvfFilePath))
                {
                    cvfBasePath = Path.Combine(Path.GetDirectoryName(WagFilePath), "CABVIEW");
                    cvfFilePath = Path.Combine(cvfBasePath, CVFFileName);
                    if (!File.Exists(cvfFilePath))
                        return null;
                }
            }
            var cvfFile = new CabViewFile(cvfFilePath, cvfBasePath);
            if (!(this is MSTSSteamLocomotive))
                InitializeFromORTSSpecific(cvfFilePath, extendedCVF);

            var cabViewAngle = CabViewpoints[0].StartDirection.Y;
            var cabViewType = (cabViewAngle >= 90 && cabViewAngle <= 270) || (cabViewAngle <= -90 && cabViewAngle >= -270) ? CabViewType.Rear : CabViewType.Front;

            // only one cabview, and it looks rear; insert a void one at first place to maintain fast indexing
            if (CabViewpoints.Count == 1 && cabViewType == CabViewType.Rear)
                CabViewpoints.Insert(0, new PassengerViewPoint());

            return new CabView3D(cvfFile, CabViewpoints, extendedCVF, cabViewType, noseAhead, shapeFilePath);
        }

        /// <summary>
        /// Parse the wag file parameters required for the simulator and viewer classes
        /// </summary>
        public override void Parse(string lowercasetoken, STFReader stf)
        {
            switch (lowercasetoken)
            {
                case "engine(sound": CabSoundFileName = stf.ReadStringBlock(null); break;
                case "engine(cabview": CVFFileName = stf.ReadStringBlock(null); break;
                case "engine(maxpower": MaxPowerW = stf.ReadFloatBlock(STFReader.UNITS.Power, null); break;
                case "engine(maxforce": MaxForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
                case "engine(maxcurrent": MaxCurrentA = stf.ReadFloatBlock(STFReader.UNITS.Current, null); break;
                case "engine(maxcontinuousforce": MaxContinuousForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
                case "engine(ortsspeedofmaxcontinuousforce": SpeedOfMaxContinuousForceMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); break;
                case "engine(dieselenginespeedofmaxtractiveeffort": MSTSSpeedOfMaxContinuousForceMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); break;
                case "engine(maxvelocity": MaxSpeedMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); break;
                case "engine(ortsunloadingspeed": UnloadingSpeedMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); break;
                case "engine(ortsslipcontrolsystem":
                    stf.MustMatch("(");
                    string slipControlType = stf.ReadString().ToLowerInvariant();
                    try
                    {
                        SlipControlSystem = (SlipControlType)Enum.Parse(typeof(SlipControlType), slipControlType.First().ToString().ToUpper() + slipControlType.Substring(1));
                    }
                    catch
                    {
                        STFException.TraceWarning(stf, "Skipped unknown slip control system " + slipControlType);
                    }
                    break;
                case "engine(type":
                    stf.MustMatch("(");
                    var engineType = stf.ReadString();
                    try
                    {
                        EngineType = (EngineTypes)Enum.Parse(typeof(EngineTypes), engineType.First().ToString().ToUpper() + engineType.Substring(1));
                    }
                    catch
                    {
                        STFException.TraceWarning(stf, "Skipped unknown engine type " + engineType);
                    }
                    break;
                case "engine(sandingsystemtype":
                    stf.MustMatch("(");
                    var sandingType = stf.ReadString();
                    try
                    {
                        SandingSystemType = (SandingSystemTypes)Enum.Parse(typeof(SandingSystemTypes), sandingType.First().ToString().ToUpper() + sandingType.Substring(1));
                    }
                    catch
                    {
                        STFException.TraceWarning(stf, "Skipped unknown engine type " + sandingType);
                    }
                    break;

                case "engine(ortstractionmotortype":
                    stf.MustMatch("(");
                    string tractionMotorType = stf.ReadString().ToUpper();
                    try
                    {
                        TractionMotorType = (TractionMotorTypes)Enum.Parse(typeof(TractionMotorTypes), tractionMotorType);
                    }
                    catch
                    {
                        STFException.TraceWarning(stf, "Skipped unknown traction motor type " + tractionMotorType);
                    }
                    break;

                case "engine(enginecontrollers(throttle": ThrottleController = new MSTSNotchController(stf); break;
                case "engine(enginecontrollers(regulator": ThrottleController = new MSTSNotchController(stf); break;
                case "engine(enginecontrollers(brake_dynamic": DynamicBrakeController.Parse(stf); break;
                case "engine(ortslocomotivedrivewheelonlybraking":
                    var wheelbraking = stf.ReadIntBlock(null);
                    if (wheelbraking == 1)
                    {
                        DriveWheelOnlyBrakes = true;
                    }
                    break;
                case "engine(trainbrakescontrollermaxsystempressure":
                case "engine(ortstrainbrakescontrollermaxoverchargepressure":
                case "engine(trainbrakescontrollermaxreleaserate":
                case "engine(trainbrakescontrollermaxquickreleaserate":
                case "engine(ortstrainbrakescontrolleroverchargeeliminationrate":
                case "engine(trainbrakescontrollermaxapplicationrate":
                case "engine(trainbrakescontrolleremergencyapplicationrate":
                case "engine(trainbrakescontrollerfullservicepressuredrop":
                case "engine(trainbrakescontrollerminpressurereduction":
                case "engine(ortstrainbrakescontrollerslowapplicationrate":
                case "engine(ortstrainbrakecontroller":
                case "engine(enginecontrollers(brake_train":
                case "engine(ortstraindynamicblendingtable":
                    TrainBrakeController.Parse(lowercasetoken, stf);
                    TrainBrakeFitted = true;
                    break;
                case "engine(enginecontrollers(ortsfastvacuumexhauster": FastVacuumExhausterFitted = true; break;
                case "engine(enginebrakescontrollermaxsystempressure":
                case "engine(enginebrakescontrollermaxreleaserate":
                case "engine(enginebrakescontrollermaxquickreleaserate":
                case "engine(enginebrakescontrollermaxapplicationrate":
                case "engine(enginebrakescontrolleremergencyapplicationrate":
                case "engine(enginebrakescontrollerfullservicepressuredrop":
                case "engine(enginebrakescontrollerminpressurereduction":
                case "engine(ortsenginebrakescontrollerslowapplicationrate":
                case "engine(enginecontrollers(brake_engine":
                case "engine(ortsenginebrakecontroller":
                    EngineBrakeController.Parse(lowercasetoken, stf);
                    EngineBrakeFitted = true;
                    break;
                case "engine(enginecontrollers(brake_brakeman":
                    BrakemanBrakeController.Parse(lowercasetoken, stf);
                    BrakemanBrakeFitted = true;
                    break;
                case "engine(ortstraincontrolsystem":
                case "engine(ortstraincontrolsystemsound":
                case "engine(ortstraincontrolsystemparameters":
                case "engine(vigilancemonitor":
                case "engine(emergencystopmonitor":
                case "engine(awsmonitor":
                case "engine(overspeedmonitor": VigilanceMonitor = true; TrainControlSystem.Parse(lowercasetoken, stf); break;
                case "engine(enginecontrollers(combined_control": ParseCombData(lowercasetoken, stf); break;
                case "engine(ortsairbrakemainresvolume":
                case "engine(airbrakesmainresvolume": MainResVolumeM3 = Me3.FromFt3(stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null)); break;
                case "engine(airbrakesmainmaxairpressure": MainResPressurePSI = MaxMainResPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(airbrakemaxmainrespipepressure": MaximumMainReservoirPipePressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(airbrakescompressorrestartpressure": CompressorRestartPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(airbrakesaircompressorpowerrating": CompressorChargingRateM3pS = Me3.FromFt3(stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null)); break;
                case "engine(airbrakesiscompressorelectricormechanical": var compressorMechanical = stf.ReadIntBlock(null);
                    if (compressorMechanical == 1)
                    {
                        CompressorIsMechanical = true;
                    }
                    break;
                case "engine(ortscompressorismucontrolled": CompressorIsMUControlled = stf.ReadBoolBlock(false); break;
                case "engine(trainpipeleakrate": TrainBrakePipeLeakPSIorInHgpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(vacuumbrakesvacuumpumpresistance": VacuumPumpResistanceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;

                case "engine(ortsvacuumbrakesmainresvolume": VacuumBrakesMainResVolumeM3 = Me3.FromFt3(stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null)); break;
                case "engine(ortsvacuumbrakesmainresmaxvacuum": VacuumBrakesMainResMaxVacuumPSIAorInHg = OneAtmospherePSI - stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break; // convert to PSIA for vacuum brakes
                case "engine(ortsvacuumbrakesexhausterrestartvacuum": VacuumBrakesExhausterRestartVacuumPSIAorInHg = OneAtmospherePSI - stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break; // convert to PSIA for vacuum brakes
                case "engine(ortsvacuumbrakesmainreschargingrate": VacuumBrakesMainResChargingRatePSIAorInHgpS = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;

                case "engine(ortsmainreschargingrate": MainResChargingRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(ortsenginebrakereleaserate": EngineBrakeReleaseRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(ortsenginebrakeapplicationrate": EngineBrakeApplyRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(ortsbrakepipetimefactor": BrakePipeTimeFactorS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(ortsbrakeservicetimefactor": BrakeServiceTimeFactorPSIpS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(ortsbrakeemergencytimefactor": BrakeEmergencyTimeFactorPSIpS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(ortsbrakepipechargingrate": BrakePipeChargingRatePSIorInHgpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(ortsbrakepipequickchargingrate": BrakePipeQuickChargingRatePSIpS = stf.ReadFloatBlock(STFReader.UNITS.PressureRateDefaultPSIpS, null); break;
                case "engine(ortsbrakepipedischargetimemult": BrakePipeDischargeTimeFactor = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
                case "engine(ortsmaxtractiveforcecurves": TractiveForceCurves = new InterpolatorDiesel2D(stf, false); TractiveForceCurves.HasNegativeValue();  break;
                case "engine(ortstractioncharacteristics": TractiveForceCurves = new InterpolatorDiesel2D(stf, true); break;
                case "engine(ortsdynamicbrakeforcecurves": DynamicBrakeForceCurves = new InterpolatorDiesel2D(stf, false); break;
                case "engine(ortscontinuousforcetimefactor": ContinuousForceTimeFactor = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
                case "engine(ortssanderspeedeffectupto":
                case "engine(orts(ortssanderspeedeffectupto": SanderSpeedEffectUpToMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, null); break;
                case "engine(ortsemergencycausespowerdown":
                case "engine(orts(ortsemergencycausespowerdown": EmergencyCausesPowerDown = stf.ReadBoolBlock(false); break;
                case "engine(ortsemergencycausesthrottledown":
                case "engine(orts(ortsemergencycausesthrottledown": EmergencyCausesThrottleDown = stf.ReadBoolBlock(false); break;
                case "engine(ortsemergencyengageshorn":
                case "engine(orts(ortsemergencyengageshorn": EmergencyEngagesHorn = stf.ReadBoolBlock(false); break;
                case "engine(ortswheelslipcausesthrottledown":
                case "engine(orts(ortswheelslipcausesthrottledown": WheelslipCausesThrottleDown = stf.ReadBoolBlock(false); break;
                case "engine(dynamicbrakesminusablespeed": DynamicBrakeSpeed1MpS = stf.ReadFloatBlock(STFReader.UNITS.SpeedDefaultMPH, null); break;
                case "engine(dynamicbrakesfadingspeed": DynamicBrakeSpeed2MpS = stf.ReadFloatBlock(STFReader.UNITS.SpeedDefaultMPH, null); break;
                case "engine(dynamicbrakesmaximumeffectivespeed": DynamicBrakeSpeed3MpS = stf.ReadFloatBlock(STFReader.UNITS.SpeedDefaultMPH, null); break;
                case "engine(dynamicbrakesmaximumspeedforfadeout": DynamicBrakeSpeed4MpS = stf.ReadFloatBlock(STFReader.UNITS.SpeedDefaultMPH, null); break;
                case "engine(dynamicbrakeseffectatmaximumfadeout": DynamicBrakeRatioAtSpeed4 = stf.ReadFloatBlock(STFReader.UNITS.None, null); break;
                case "engine(dynamicbrakesmaximumforce": MaxDynamicBrakeForceN = stf.ReadFloatBlock(STFReader.UNITS.Force, null); break;
                case "engine(dynamicbrakehasautobailoff":
                case "engine(ortsdynamicbrakeshasautobailoff": DynamicBrakeAutoBailOff = stf.ReadBoolBlock(true); break;
                case "engine(ortsdynamicbrakeshaspartialbailoff": DynamicBrakePartialBailOff = stf.ReadBoolBlock(false); break;
                case "engine(dynamicbrakesdelaytimebeforeengaging": DynamicBrakeDelayS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(dynamicbrakesresistorcurrentlimit": DynamicBrakeMaxCurrentA = stf.ReadFloatBlock(STFReader.UNITS.Current, null); break;
                case "engine(numwheels": MSTSLocoNumDrvWheels = stf.ReadFloatBlock(STFReader.UNITS.None, 4.0f); if (MSTSLocoNumDrvWheels < 1) STFException.TraceWarning(stf, "Engine:NumWheels is less than 1, parts of the simulation may not function correctly"); break;
                case "engine(ortsnumberdriveaxles": LocoNumDrvAxles = stf.ReadIntBlock(null); if (LocoNumDrvAxles < 1) STFException.TraceWarning(stf, "Engine:ORTSNumberDriveAxles is less than 1, parts of the simulation may not function correctly"); break;
                case "engine(antislip": AntiSlip = stf.ReadBoolBlock(false); break;
                case "engine(ortsdrivewheelweight": InitialDrvWheelWeightKg = stf.ReadFloatBlock(STFReader.UNITS.Mass, null); break;
                case "engine(engineoperatingprocedures": EngineOperatingProcedures = stf.ReadStringBlock(""); break;
                case "engine(headout":
                    HeadOutViewpoints.Add(new ViewPoint(stf.ReadVector3Block(STFReader.UNITS.Distance, Vector3.Zero)));
                    HeadOutViewpoints.Add(new ViewPoint(HeadOutViewpoints[0], true));
                    break;
                case "engine(sanding": SanderSpeedOfMpS = stf.ReadFloatBlock(STFReader.UNITS.Speed, 30.0f); break;
                case "engine(ortsdoesvacuumbrakecutpower": DoesVacuumBrakeCutPower = stf.ReadBoolBlock(false); break;
                case "engine(doesbrakecutpower": DoesBrakeCutPower = stf.ReadBoolBlock(false); break;
                case "engine(brakecutspoweratbrakecylinderpressure": BrakeCutsPowerAtBrakeCylinderPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(ortsbrakecutspoweratbrakepipepressure": BrakeCutsPowerAtBrakePipePressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(ortsbrakerestorespoweratbrakepipepressure": BrakeRestoresPowerAtBrakePipePressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(doeshorntriggerbell": DoesHornTriggerBell = stf.ReadBoolBlock(false); break;
                case "engine(ortshornlightstimer": HornTimerS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(ortsbelllightstimer": BellTimerS = stf.ReadFloatBlock(STFReader.UNITS.Time, null); break;
                case "engine(brakesenginecontrollers":
                    foreach (var brakesenginecontrollers in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
                    {
                        if (EngineType == EngineTypes.Electric || EngineType == EngineTypes.Diesel)
                        {
                            switch (brakesenginecontrollers)
                            {
                                case "blended":                              
                                    DynamicBrakeBlendingEnabled = true;
                                    break;
                                case "dynamic":
                                    DynamicBrakeAvailable = true;
                                    break;
                                default:
                                    break;
                            }
                        }
                    }
                    break;

                case "engine(brakestrainbraketype":
                    foreach (var brakestrainbraketype in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
                    {
                        switch (brakestrainbraketype)
                            {
                                case "vacuum_single_pipe_eq":
                                    VacuumBrakeEQFitted = true;
                                    break;
                                 default:
                                    break;
                            }
                    }
                    break;

                case "engine(brakesenginebraketype":
                    foreach (var brakesenginebraketype in stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(','))
                    {
                        switch (brakesenginebraketype)
                        {
                            case "steam_brake":
                                SteamEngineBrakeFitted = true;
                                break;
                            default:
                                break;
                        }
                    }
                    break;
                case "engine(ortsdpbrakesynchronization":
                    var dpSyncModes = stf.ReadStringBlock("").ToLower().Replace(" ", "").Split(',');
                    if (dpSyncModes.Contains("apply"))
                        DPSyncTrainApplication = true;
                    if (dpSyncModes.Contains("release"))
                        DPSyncTrainRelease = true;
                    if (dpSyncModes.Contains("emergency"))
                        DPSyncEmergency = true;
                    if (dpSyncModes.Contains("independent"))
                        DPSyncIndependent = true;
                    else // Independent synchronization is assumed to be enabled unless explicitly not enabled
                        DPSyncIndependent = false;
                    break;
                case "engine(ortsdynamicblendingoverride": DynamicBrakeBlendingOverride = stf.ReadBoolBlock(false); break;
                case "engine(ortsdynamicblendingforcematch": DynamicBrakeBlendingForceMatch = stf.ReadBoolBlock(false); break;
                case "engine(vacuumbrakeshasvacuumpump": VacuumPumpFitted = stf.ReadBoolBlock(false); break;
                case "engine(enginecontrollers(ortssteamheat": SteamHeatController.Parse(stf); break;
                case "engine(name": stf.MustMatch("("); LocomotiveName = stf.ReadString(); break;
                case "engine(maxsteamheatingpressure": MaxSteamHeatPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(ortsonlinecabradio": OnLineCabRadio = stf.ReadBoolBlock(false); break;
                case "engine(ortsonlinecabradiourl": OnLineCabRadioURL = stf.ReadString(); break;
                case "engine(vacuumbrakesminboilerpressuremaxvacuum": MaxVaccuumMaxPressurePSI = stf.ReadFloatBlock(STFReader.UNITS.PressureDefaultPSI, null); break;
                case "engine(enginecontrollers(waterscoop": HasWaterScoop = true; break;
                case "engine(ortswaterscoopfillelevation": WaterScoopFillElevationM = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0.0f); break;
                case "engine(ortswaterscoopdepth": WaterScoopDepthM = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0.0f); break;
                case "engine(ortswaterscoopwidth": WaterScoopWidthM = stf.ReadFloatBlock(STFReader.UNITS.Distance, 0.0f); break;
                    // Convert the following default ft^3 to Me^3 units
                case "engine(ortsmaxtracksanderboxcapacity": 
                    MaxTrackSandBoxCapacityM3 = stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null);
                    MaxTrackSandBoxCapacityM3 = Me3.FromFt3(MaxTrackSandBoxCapacityM3);
                    break;
                case "engine(ortsmaxtracksandersandconsumptionforward": 
                    Me3.FromFt3( MaxTrackSanderSandConsumptionForwardM3pS = stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null) );
                    MaxTrackSanderSandConsumptionForwardM3pS = Me3.FromFt3(MaxTrackSanderSandConsumptionForwardM3pS);
                    break;
                case "engine(ortsmaxtracksandersandconsumptionreverse":
                    Me3.FromFt3(MaxTrackSanderSandConsumptionReverseM3pS = stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null));
                    MaxTrackSanderSandConsumptionReverseM3pS = Me3.FromFt3(MaxTrackSanderSandConsumptionReverseM3pS);
                    break;
                case "engine(ortsmaxtracksanderairconsumptionforward": 
                    Me3.FromFt3( MaxTrackSanderAirComsumptionForwardM3pS = stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null) );
                    MaxTrackSanderAirComsumptionForwardM3pS = Me3.FromFt3(MaxTrackSanderAirComsumptionForwardM3pS);
                    break;
                case "engine(ortsmaxtracksanderairconsumptionreverse":
                    Me3.FromFt3(MaxTrackSanderAirComsumptionReverseM3pS = stf.ReadFloatBlock(STFReader.UNITS.VolumeDefaultFT3, null));
                    MaxTrackSanderAirComsumptionReverseM3pS = Me3.FromFt3(MaxTrackSanderAirComsumptionReverseM3pS);
                    break;
                case "engine(ortscruisecontrol": SetUpCruiseControl(stf); break;
                case "engine(ortsmultipositioncontroller": SetUpMPC(stf); break;
                default:
                    base.Parse(lowercasetoken, stf);
                    break;

            }
        }

        /// <summary>
        /// This initializer is called when we are making a new copy of a car already
        /// loaded in memory.  We use this one to speed up loading by eliminating the
        /// need to parse the wag file multiple times.
        /// </summary>
        public override void Copy(MSTSWagon copy)
        {
            base.Copy(copy);  // each derived level initializes its own variables

            MSTSLocomotive locoCopy = (MSTSLocomotive)copy;
            CabSoundFileName = locoCopy.CabSoundFileName;
            CVFFileName = locoCopy.CVFFileName;
            CabViewList = locoCopy.CabViewList;
            CabView3D = locoCopy.CabView3D;
            MaxPowerW = locoCopy.MaxPowerW;
            MaxForceN = locoCopy.MaxForceN;
            MaxCurrentA = locoCopy.MaxCurrentA;
            MaxSpeedMpS = locoCopy.MaxSpeedMpS;
            UnloadingSpeedMpS = locoCopy.UnloadingSpeedMpS;
            SlipControlSystem = locoCopy.SlipControlSystem;
            EngineType = locoCopy.EngineType;
            SandingSystemType = locoCopy.SandingSystemType;
            TractionMotorType = locoCopy.TractionMotorType;
            TractiveForceCurves = locoCopy.TractiveForceCurves;
            MaxContinuousForceN = locoCopy.MaxContinuousForceN;
            SpeedOfMaxContinuousForceMpS = locoCopy.SpeedOfMaxContinuousForceMpS;
            MSTSSpeedOfMaxContinuousForceMpS = locoCopy.MSTSSpeedOfMaxContinuousForceMpS;
            ContinuousForceTimeFactor = locoCopy.ContinuousForceTimeFactor;
            DynamicBrakeForceCurves = locoCopy.DynamicBrakeForceCurves;
            DynamicBrakeAutoBailOff = locoCopy.DynamicBrakeAutoBailOff;
            DynamicBrakePartialBailOff = locoCopy.DynamicBrakePartialBailOff;
            DynamicBrakeMaxCurrentA = locoCopy.DynamicBrakeMaxCurrentA;
            CombinedControlType = locoCopy.CombinedControlType;
            CombinedControlSplitPosition = locoCopy.CombinedControlSplitPosition;
            DynamicBrakeDelayS = locoCopy.DynamicBrakeDelayS;
            MaxDynamicBrakeForceN = locoCopy.MaxDynamicBrakeForceN;
            HasSmoothStruc = locoCopy.HasSmoothStruc;
            LocoNumDrvAxles = locoCopy.LocoNumDrvAxles;
            MSTSLocoNumDrvWheels = locoCopy.MSTSLocoNumDrvWheels;
            AntiSlip = locoCopy.AntiSlip;
            VacuumPumpFitted = locoCopy.VacuumPumpFitted;
            FastVacuumExhausterFitted = locoCopy.FastVacuumExhausterFitted;
            DrvWheelWeightKg = locoCopy.DrvWheelWeightKg;
            InitialDrvWheelWeightKg = locoCopy.InitialDrvWheelWeightKg;
            SanderSpeedEffectUpToMpS = locoCopy.SanderSpeedEffectUpToMpS;
            SanderSpeedOfMpS = locoCopy.SanderSpeedOfMpS;
            MaxTrackSandBoxCapacityM3 = locoCopy.MaxTrackSandBoxCapacityM3;
            MaxTrackSanderSandConsumptionForwardM3pS = locoCopy.MaxTrackSanderSandConsumptionForwardM3pS;
            MaxTrackSanderSandConsumptionReverseM3pS = locoCopy.MaxTrackSanderSandConsumptionReverseM3pS;
            MaxTrackSanderAirComsumptionForwardM3pS = locoCopy.MaxTrackSanderAirComsumptionForwardM3pS;
            MaxTrackSanderAirComsumptionReverseM3pS = locoCopy.MaxTrackSanderAirComsumptionReverseM3pS;
            PowerOnDelayS = locoCopy.PowerOnDelayS;
            DoesHornTriggerBell = locoCopy.DoesHornTriggerBell;
            MaxSteamHeatPressurePSI = locoCopy.MaxSteamHeatPressurePSI;
            VacuumPumpResistanceN = locoCopy.VacuumPumpResistanceN;
            VacuumBrakesMainResVolumeM3 = locoCopy.VacuumBrakesMainResVolumeM3;
            VacuumBrakesMainResMaxVacuumPSIAorInHg = locoCopy.VacuumBrakesMainResMaxVacuumPSIAorInHg;
            VacuumBrakesExhausterRestartVacuumPSIAorInHg = locoCopy.VacuumBrakesExhausterRestartVacuumPSIAorInHg;
            VacuumBrakesMainResChargingRatePSIAorInHgpS = locoCopy.VacuumBrakesMainResChargingRatePSIAorInHgpS;

            EmergencyCausesPowerDown = locoCopy.EmergencyCausesPowerDown;
            EmergencyCausesThrottleDown = locoCopy.EmergencyCausesThrottleDown;
            EmergencyEngagesHorn = locoCopy.EmergencyEngagesHorn;
            HornTimerS = locoCopy.HornTimerS;
            BellTimerS = locoCopy.BellTimerS;

            WheelslipCausesThrottleDown = locoCopy.WheelslipCausesThrottleDown;

            CompressorIsMechanical = locoCopy.CompressorIsMechanical;
            CompressorRestartPressurePSI = locoCopy.CompressorRestartPressurePSI;
            CompressorIsMUControlled = locoCopy.CompressorIsMUControlled;
            TrainBrakePipeLeakPSIorInHgpS = locoCopy.TrainBrakePipeLeakPSIorInHgpS;
            MaxMainResPressurePSI = locoCopy.MaxMainResPressurePSI;
            MainResPressurePSI = locoCopy.MaxMainResPressurePSI;
            MaximumMainReservoirPipePressurePSI = locoCopy.MaximumMainReservoirPipePressurePSI;
            MainResVolumeM3 = locoCopy.MainResVolumeM3;
            MainResChargingRatePSIpS = locoCopy.MainResChargingRatePSIpS;
            BrakePipeDischargeTimeFactor = locoCopy.BrakePipeDischargeTimeFactor;
            DriveWheelOnlyBrakes = locoCopy.DriveWheelOnlyBrakes;
            DynamicBrakeBlendingEnabled = locoCopy.DynamicBrakeBlendingEnabled;
            DynamicBrakeAvailable = locoCopy.DynamicBrakeAvailable;
            airPipeSystem = locoCopy.airPipeSystem;
            DynamicBrakeCommandStartTime = locoCopy.DynamicBrakeCommandStartTime;
            DynamicBrakeBlendingOverride = locoCopy.DynamicBrakeBlendingOverride;
            DynamicBrakeBlendingForceMatch = locoCopy.DynamicBrakeBlendingForceMatch;
            DynamicBrakeControllerSetupLock = locoCopy.DynamicBrakeControllerSetupLock;

            MainPressureUnit = locoCopy.MainPressureUnit;
            BrakeSystemPressureUnits = locoCopy.BrakeSystemPressureUnits;
            IsDriveable = copy.IsDriveable;

            ThrottleController = (MSTSNotchController)locoCopy.ThrottleController.Clone();
            SteamHeatController = (MSTSNotchController)locoCopy.SteamHeatController.Clone();
            TrainBrakeController = locoCopy.TrainBrakeController.Clone(this);
            EngineBrakeController = locoCopy.EngineBrakeController != null ? locoCopy.EngineBrakeController.Clone(this) : null;
            BrakemanBrakeController = locoCopy.BrakemanBrakeController != null ? locoCopy.BrakemanBrakeController.Clone(this) : null;
            DynamicBrakeController = locoCopy.DynamicBrakeController != null ? (MSTSNotchController)locoCopy.DynamicBrakeController.Clone() : null;
            DPThrottleController = (MSTSNotchController)ThrottleController.Clone();
            if (DynamicBrakeController != null)
            {
                if (DynamicBrakeController.NotchCount() > 3)
                    DPDynamicBrakeController = (MSTSNotchController)DynamicBrakeController.Clone();
                else
                    DPDynamicBrakeController = BuildDPDynamicBrakeController();
            }
            else
                DPDynamicBrakeController = null;

            LocomotivePowerSupply.Copy(locoCopy.LocomotivePowerSupply);
            TrainControlSystem.Copy(locoCopy.TrainControlSystem);
            LocomotiveName = locoCopy.LocomotiveName;
            MaxVaccuumMaxPressurePSI = locoCopy.MaxVaccuumMaxPressurePSI;
            VacuumBrakeEQFitted = locoCopy.VacuumBrakeEQFitted;
            TrainBrakeFitted = locoCopy.TrainBrakeFitted;
            EngineBrakeFitted = locoCopy.EngineBrakeFitted;
            BrakemanBrakeFitted = locoCopy.BrakemanBrakeFitted;
            SteamEngineBrakeFitted = locoCopy.SteamEngineBrakeFitted;
            HasWaterScoop = locoCopy.HasWaterScoop;
            WaterScoopFillElevationM = locoCopy.WaterScoopFillElevationM;
            WaterScoopDepthM = locoCopy.WaterScoopDepthM;
            WaterScoopWidthM = locoCopy.WaterScoopWidthM;
            CruiseControl = locoCopy.CruiseControl?.Clone(this);
            MultiPositionControllers = locoCopy.CloneMPC(this);
        }

        /// <summary>
        /// We are saving the game.  Save anything that we'll need to restore the 
        /// status later.
        /// </summary>
        public override void Save(BinaryWriter outf)
        {
            // we won't save the horn state
            outf.Write(Bell);
            outf.Write(Sander);
            outf.Write(VacuumExhausterPressed);
            outf.Write(Wiper);
            outf.Write(OdometerResetPositionM);
            outf.Write(OdometerCountingUp);
            outf.Write(OdometerCountingForwards);
            outf.Write(OdometerVisible);
            outf.Write(MainResPressurePSI);
            outf.Write(CompressorIsOn);
            outf.Write(VacuumMainResVacuumPSIAorInHg);
            outf.Write(VacuumExhausterIsOn);
            outf.Write(TrainBrakePipeLeakPSIorInHgpS);
            outf.Write(AverageForceN);
            outf.Write(CabLightOn);
            outf.Write(UsingRearCab);
            outf.Write(CalculatedCarHeaterSteamUsageLBpS);
            ControllerFactory.Save(ThrottleController, outf);
            ControllerFactory.Save(TrainBrakeController, outf);
            ControllerFactory.Save(EngineBrakeController, outf);
            ControllerFactory.Save(BrakemanBrakeController, outf);
            ControllerFactory.Save(DynamicBrakeController, outf);
            ControllerFactory.Save(SteamHeatController, outf);
            outf.Write(AcceptMUSignals);
            outf.Write(PowerReduction);
            outf.Write(ScoopIsBroken);
            outf.Write(IsWaterScoopDown);
            outf.Write(SaveAdhesionFilter);
            outf.Write(GenericItem1);
            outf.Write(GenericItem2);
            outf.Write(RemoteControlGroup);
            outf.Write(DPUnitID);
            outf.Write(PreviousGearBoxNotch);
            outf.Write(previousChangedGearBoxNotch);
            outf.Write(DynamicBrake);
            outf.Write(DynamicBrakeIntervention);
            outf.Write(CurrentTrackSandBoxCapacityM3);
            outf.Write(CurrentTrackSanderSandConsumptionM3pS);
            outf.Write(CurrentTrackSanderAirConsumptionM3pS);


            base.Save(outf);

            LocomotivePowerSupply?.Save(outf);
            TrainControlSystem.Save(outf);

            CruiseControl?.Save(outf);
        }

        /// <summary>
        /// We are restoring a saved game.  The TrainCar class has already
        /// been initialized.   Restore the game state.
        /// </summary>
        public override void Restore(BinaryReader inf)
        {
            if (inf.ReadBoolean()) SignalEvent(Event.BellOn);
            if (inf.ReadBoolean()) SignalEvent(Event.SanderOn);
            if (inf.ReadBoolean()) SignalEvent(Event.VacuumExhausterOn);
            if (inf.ReadBoolean()) SignalEvent(Event.WiperOn);
            OdometerResetPositionM = inf.ReadSingle();
            OdometerCountingUp = inf.ReadBoolean();
            OdometerCountingForwards = inf.ReadBoolean();
            OdometerVisible = inf.ReadBoolean();
            MainResPressurePSI = inf.ReadSingle();
            CompressorIsOn = inf.ReadBoolean();
            VacuumMainResVacuumPSIAorInHg = inf.ReadSingle();
            VacuumExhausterIsOn = inf.ReadBoolean();
            TrainBrakePipeLeakPSIorInHgpS = inf.ReadSingle();
            AverageForceN = inf.ReadSingle();
            CabLightOn = inf.ReadBoolean();
            UsingRearCab = inf.ReadBoolean();
            CalculatedCarHeaterSteamUsageLBpS = inf.ReadSingle();
            ControllerFactory.Restore(ThrottleController, inf);
            ControllerFactory.Restore(TrainBrakeController, inf);
            ControllerFactory.Restore(EngineBrakeController, inf);
            ControllerFactory.Restore(BrakemanBrakeController, inf);
            ControllerFactory.Restore(DynamicBrakeController, inf);
            ControllerFactory.Restore(SteamHeatController, inf);
            AcceptMUSignals = inf.ReadBoolean();
            PowerReduction = inf.ReadSingle();
            ScoopIsBroken = inf.ReadBoolean();
            IsWaterScoopDown = inf.ReadBoolean();

            SaveAdhesionFilter = inf.ReadSingle();
            
            AdhesionFilter.Reset(SaveAdhesionFilter);

            GenericItem1 = inf.ReadBoolean();
            GenericItem2 = inf.ReadBoolean();
            RemoteControlGroup = inf.ReadInt32();
            DPUnitID = inf.ReadInt32();
            PreviousGearBoxNotch = inf.ReadInt32();
            previousChangedGearBoxNotch = inf.ReadInt32();

            DynamicBrake = inf.ReadBoolean();
            DynamicBrakeIntervention = inf.ReadSingle();
            CurrentTrackSandBoxCapacityM3 = inf.ReadSingle();
            CurrentTrackSanderSandConsumptionM3pS = inf.ReadSingle();
            CurrentTrackSanderAirConsumptionM3pS = inf.ReadSingle();

            base.Restore(inf);

            LocomotivePowerSupply?.Restore(inf);
            TrainControlSystem.Restore(inf);

            CruiseControl?.Restore(inf);
        }

        public bool IsLeadLocomotive()
        {
            return Train.LeadLocomotive == this;
        }

        protected void ParseCombData(string lowercasetoken, STFReader stf)
        {
            var throttle = false;
            var train = false;
            var dynamic = false;
            var independent = false;

            stf.MustMatch("(");
            var minValue = stf.ReadFloat(STFReader.UNITS.None, 0);
            var maxValue = stf.ReadFloat(STFReader.UNITS.None, 1);
            var split = stf.ReadFloat(STFReader.UNITS.None, 0.5f);
            var defaultValue = stf.ReadFloat(STFReader.UNITS.None, 0.5f);

            string s;
            while ((s = stf.ReadItem()) != ")")
            {
                throttle |= s == "throttle";
                train |= s == "train";
                dynamic |= s == "dynamic";
                independent |= s == "independent";
            }

            CombinedControlSplitPosition = (split - minValue) / (maxValue - minValue);

            if (throttle && dynamic && train)
                CombinedControlType = CombinedControl.ThrottleDynamicAir;
            else if (throttle && train)
                CombinedControlType = CombinedControl.ThrottleAir;
            else if (throttle && dynamic)
                CombinedControlType = CombinedControl.ThrottleDynamic;
            else if (dynamic && train)
                CombinedControlType = CombinedControl.DynamicAir;

            if (train && !TrainBrakeController.IsValid())
                TrainBrakeController = new ScriptedBrakeController(this);
            if (dynamic && !DynamicBrakeController.IsValid())
                DynamicBrakeController = new MSTSNotchController(0, 1, .05f);
        }

        /// <summary>
        /// Sets controler settings from other engine for cab switch
        /// </summary>
        /// <param name="other"></param>
        public override void CopyControllerSettings(TrainCar other)
        {
            base.CopyControllerSettings(other);
            if (ThrottleController != null)
                ThrottleController.SetValue(other.ThrottlePercent / 100);
            if (DynamicBrakeController != null)
                DynamicBrakeController.SetValue(other.DynamicBrakePercent / 100);
            if (TrainBrakeController != null)
                TrainBrakeController.SetValue(((MSTSLocomotive)other).TrainBrakeController.CurrentValue);
            if (EngineBrakeController != null)
                EngineBrakeController.SetValue(0);
            if (BrakemanBrakeController != null)
                BrakemanBrakeController.SetValue(0);
        }

        public bool controlUpdated;
        public bool notificationReceived;

        /// <summary>
        /// Called just after the InitializeFromWagFile
        /// </summary>
        public override void Initialize()
        {
            TrainBrakeController.Initialize();
            EngineBrakeController.Initialize();
            BrakemanBrakeController.Initialize();
            LocomotivePowerSupply?.Initialize();
            TrainControlSystem.Initialize();
            CruiseControl?.Initialize();
            foreach (MultiPositionController mpc in MultiPositionControllers)
            {
                mpc.Initialize();
            }

            if (MaxSteamHeatPressurePSI == 0)       // Check to see if steam heating is fitted to locomotive
            {
                IsSteamHeatFitted = false;
            }
            else
            {
                IsSteamHeatFitted = true;
            }

            SteamHeatPressureToTemperaturePSItoF = SteamTable.SteamHeatPressureToTemperatureInterpolatorPSItoF();
            SteamDensityPSItoLBpFT3 = SteamTable.SteamDensityInterpolatorPSItoLBpFT3();
            SteamHeatPSItoBTUpLB = SteamTable.SteamHeatInterpolatorPSItoBTUpLB();

            // Check to see if water scoop elements have been configured
            if (WaterScoopFillElevationM == 0)
            {
                WaterScoopFillElevationM = 2.7432f; // Set to default of 9 ft
            } 

            if (WaterScoopDepthM == 0)
            {
                WaterScoopDepthM = 0.0889f; // Set to default of 3.5 ins
            }

            if (WaterScoopWidthM == 0)
            {
                WaterScoopWidthM = 0.3048f; // Set to default of 1 ft
            }

            // Check if current sander has been set
            if (CurrentTrackSandBoxCapacityM3 == 0 )
            {
                CurrentTrackSandBoxCapacityM3 = MaxTrackSandBoxCapacityM3;
            }
            
            // Ensure Drive Axles is set with a default value if user doesn't supply an OR value in ENG file
            if (LocoNumDrvAxles == 0)
            {
                if (MSTSLocoNumDrvWheels != 0 && MSTSLocoNumDrvWheels < 7)
                {
                    LocoNumDrvAxles = (int) MSTSLocoNumDrvWheels;
                }
                else
                {
                    LocoNumDrvAxles = 4; // Set 4 axles as default
                }

                if (Simulator.Settings.VerboseConfigurationMessages)
                {
                    Trace.TraceInformation("Number of Locomotive Drive Axles set to default value of {0}", LocoNumDrvAxles);
                }
            }
            //Compute axle inertia from parameters if possible
            if (AxleInertiaKgm2 <= 0) // if no axleinertia value supplied in ENG file, calculate axleinertia value.
            {
                if (LocoNumDrvAxles > 0 && DriverWheelRadiusM > 0)
                {
                    float radiusSquared = DriverWheelRadiusM * DriverWheelRadiusM;
                    float wheelMass = 500 * radiusSquared / (0.5f * 0.5f);
                    AxleInertiaKgm2 = Math.Min(LocoNumDrvAxles * wheelMass * radiusSquared + 500, 40000);
                }
                else
                    AxleInertiaKgm2 = 2000.0f;
            }
            if (TractionMotorType == TractionMotorTypes.AC)
            {
                foreach (var axle in LocomotiveAxles)
                {
                    InductionMotor motor = new InductionMotor(axle, this);
                    TractionMotors.Add(motor);
                }
            }

            // Calculate minimum speed to pickup water
            const float Aconst = 2;
            WaterScoopMinSpeedMpS = Me.FromFt((float)Math.Sqrt(Aconst * GravitationalAccelerationFtpSpS * Me.ToFt(WaterScoopFillElevationM)));


            if (MaxMainResPressurePSI == 0)
            {
                MaxMainResPressurePSI = 130;
            }

            MainResPressurePSI = MaxMainResPressurePSI;

            if (MainResVolumeM3 == 0)
            {
                MainResVolumeM3 = 0.3f;
            }

            // Initialise Brake Pipe Charging Rate
            if (BrakePipeChargingRatePSIorInHgpS == 0) // Check to see if BrakePipeChargingRate has been set in the ENG file.
            {
                // Set Default BrakePipe Charging Rate depending upon whether locomotive has Vacuum or air brakes - overwritten by ENG file setting.
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    BrakePipeChargingRatePSIorInHgpS = 0.32f; // Vacuum brakes
                }
                else
                {
                    BrakePipeChargingRatePSIorInHgpS = Simulator.Settings.BrakePipeChargingRate; // Air brakes
                }
            }
            // Initialise Brake Pipe Quick Charging Rate
            if (BrakePipeQuickChargingRatePSIpS == 0) BrakePipeQuickChargingRatePSIpS = BrakePipeChargingRatePSIorInHgpS;

            // Initialise Exhauster Charging rate in diesel, control cars and electric locomotives. The equivalent ejector charging rates are set in the steam locomotive.
            if (this is MSTSDieselLocomotive || this is MSTSElectricLocomotive || this is MSTSControlTrailerCar)
            {
                ExhausterHighSBPChargingRatePSIorInHgpS = BrakePipeChargingRatePSIorInHgpS;
                ExhausterLowSBPChargingRatePSIorInHgpS = BrakePipeChargingRatePSIorInHgpS / 5.0f; // Low speed exhauster setting is 1/5 of high speed
            }
            else
            {
                // Default to zero if not used.
                ExhausterHighSBPChargingRatePSIorInHgpS = 0.0f;
                ExhausterLowSBPChargingRatePSIorInHgpS = 0.0f;
            }

            // Initialise BrakePipeDischargeTimeFactor
            if (BrakePipeDischargeTimeFactor == 0)
            {
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    BrakePipeDischargeTimeFactor = 1.5f; // Vacuum brakes
                }
                else
                {
                    BrakePipeDischargeTimeFactor = 1.5f; // Air brakes
                }
            }
            
            // Initialise the resistance of the vacuum pump
            if (VacuumPumpResistanceN == 0)
            {
                VacuumPumpResistanceN = 120.0f;
            }

            // Initialise Brake Emergency Time Factor
            if (BrakeEmergencyTimeFactorPSIpS == 0) // Check to see if BrakeEmergencyTimeFactorS has been set in the ENG file.
            {
                // Set Default Brake Emergency Time Factor depending upon whether locomotive has Vacuum or air brakes - overwritten by ENG file setting.
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    BrakeEmergencyTimeFactorPSIpS = 1.0f; // Vacuum brakes
                }
                else
                {
                    BrakeEmergencyTimeFactorPSIpS = 0.1f; // Air brakes
                }
            }

            // Initialise Brake Service Time Factor
            if (BrakeServiceTimeFactorPSIpS == 0) // Check to see if BrakeServiceTimeFactorS has been set in the ENG file.
            {
                // Set Default Brake Service Time Factor depending upon whether locomotive has Vacuum or air brakes - overwritten by ENG file setting.
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    BrakeServiceTimeFactorPSIpS = 10.0f; // Vacuum brakes
                }
                else
                {
                    BrakeServiceTimeFactorPSIpS = 1.009f; // Air brakes
                }
            }

            // MaximumMainReservoirPipePressurePSI is only used in twin pipe system, and should have a value
            if ((BrakeSystem is AirTwinPipe))
            {

                // for airtwinpipe system, make sure that a value is set for it
                if (MaximumMainReservoirPipePressurePSI == 0)
                {
                    MaximumMainReservoirPipePressurePSI = MaxMainResPressurePSI;
                    if (Simulator.Settings.VerboseConfigurationMessages)
                    {
                        Trace.TraceInformation("AirBrakeMaxMainResPipePressure not set in ENG file, set to default pressure of {0}.", FormatStrings.FormatPressure(MaximumMainReservoirPipePressurePSI, PressureUnit.PSI, MainPressureUnit, true));
                    }

                }
            }
            else if ((BrakeSystem is AirSinglePipe) && MaximumMainReservoirPipePressurePSI != 0)
            {

                // if value not equal to MaxMainResPressurePSI then reset (could already be at this value due to "copying" of locomotive)
                if (MaximumMainReservoirPipePressurePSI != MaxMainResPressurePSI)
                {
                    // for a airsinglepipe system, AirBrakeMaxMainResPipePressure should be left out of ENG file, and it should be set the same as MaxMainResPressurePSI
                    MaximumMainReservoirPipePressurePSI = MaxMainResPressurePSI;
                    if (Simulator.Settings.VerboseConfigurationMessages)
                    {
                        Trace.TraceInformation("AirBrakeMaxMainResPipePressure is set in ENG file, but should not be normally used for AirSinglePipe system, reset to default pressure of {0}. Consider removing AirBrakeMaxMainResPipePressure parameter from ENG file", FormatStrings.FormatPressure(MaximumMainReservoirPipePressurePSI, PressureUnit.PSI, MainPressureUnit, true));
                    }
                }
            }
            else
            {
                // normal default setting. This should be the normal case for airsinglepipe systems
                MaximumMainReservoirPipePressurePSI = MaxMainResPressurePSI;
            }

            // Check TrainBrakesControllerMaxSystemPressure parameter for "correct" value 
            // This is only done for vacuum brakes as the UoM can be confusing - it defaults to psi due to way parameter is read, and if units are entered then a InHG value can be incorrectly converted.
            if ((BrakeSystem is VacuumSinglePipe))
            {
                if (TrainBrakeController.MaxPressurePSI == 21 || TrainBrakeController.MaxPressurePSI == 25) // If 21 or 25 has been entered assume that it is 21InHg or 25InHg, and convert it to the correct psi equivalent
                {
                    float TempMaxPressure = TrainBrakeController.MaxPressurePSI;

                    // Convert assumed inHg value to psi
                    TrainBrakeController.MaxPressurePSI = Bar.ToPSI(Bar.FromInHg(TrainBrakeController.MaxPressurePSI));

                    if (Simulator.Settings.VerboseConfigurationMessages)
                    {
                        Trace.TraceInformation("TrainBrakeController.MaxPressurePSI is assumed to be {0} Inhg, - confirmed as a value of {1} InHg", TempMaxPressure, Bar.ToInHg(Bar.FromPSI(TrainBrakeController.MaxPressurePSI)));
                    }

                }
                else if (TrainBrakeController.MaxPressurePSI < 7 || TrainBrakeController.MaxPressurePSI > 13) // Outside an acceptable range (Eqiv = 15InHg to 25InHg), then convert to a fixed default
                {
                    if (Simulator.Settings.VerboseConfigurationMessages)
                    {
                        Trace.TraceInformation("TrainBrakeController.MaxPressurePSI being incorrectly read as {0} Inhg, - set to a default value of {1} InHg", TrainBrakeController.MaxPressurePSI, Bar.ToInHg(Bar.FromPSI(Bar.ToPSI(Bar.FromInHg(21.0f)))));
                    }
                    TrainBrakeController.MaxPressurePSI = Bar.ToPSI(Bar.FromInHg(21.0f));
                }

            }

            if (DoesBrakeCutPower && BrakeCutsPowerAtBrakePipePressurePSI > BrakeRestoresPowerAtBrakePipePressurePSI)
            {
                BrakeCutsPowerAtBrakePipePressurePSI = BrakeRestoresPowerAtBrakePipePressurePSI - 1.0f;

                if (Simulator.Settings.VerboseConfigurationMessages)
                {
                    Trace.TraceInformation("BrakeCutsPowerAtBrakePipePressure is greater then BrakeRestoresPowerAtBrakePipePressurePSI, and has been set to value of {0} InHg", Bar.ToInHg(Bar.FromPSI(BrakeCutsPowerAtBrakePipePressurePSI)));
                }
            }

            if (DoesBrakeCutPower && (BrakeSystem is VacuumSinglePipe) && (BrakeRestoresPowerAtBrakePipePressurePSI == 0 || BrakeRestoresPowerAtBrakePipePressurePSI > OneAtmospherePSI))
            {
                BrakeRestoresPowerAtBrakePipePressurePSI = Bar.ToPSI(Bar.FromInHg(15.0f)); // Power can be restored once brake pipe rises above 15 InHg

                if (Simulator.Settings.VerboseConfigurationMessages)
                {
                    Trace.TraceInformation("BrakeRestoresPowerAtBrakePipePressure appears out of limits, and has been set to value of {0} InHg", Bar.ToInHg(Bar.FromPSI(BrakeRestoresPowerAtBrakePipePressurePSI)));
                }
            }

            // Initialise Brake Time Factor
            if (BrakePipeTimeFactorS == 0) // Check to see if BrakePipeTimeFactorS has been set in the ENG file.
            {
                // Set Default Brake Pipe Time Factor depending upon whether locomotive has Vacuum or air brakes - overwritten by ENG file setting.
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    BrakePipeTimeFactorS = 0.02f; // Vacuum brakes
                }
                else
                {
                    BrakePipeTimeFactorS = 0.0015f; // Air brakes
                }
            }

            // Initialise Train Pipe Leak Rate
            if (TrainBrakePipeLeakPSIorInHgpS == 0) // Check to see if TrainBrakePipeLeakPSIorInHgpS has been set in the ENG file.
            {
                // Set Default Train Brake Pipe Leak depending upon whether locomotive has Vacuum or air brakes - overwritten by ENG file setting.
                // Default currently set to zero - means that by default function is off, and a value must be entered into the ENG file to get it to work
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    TrainBrakePipeLeakPSIorInHgpS = 0.0f; // Vacuum brakes
                }
                else
                {
                    TrainBrakePipeLeakPSIorInHgpS = 0.0f; // Air brakes
                }
            }

            // Initialise track sanding parameters
            if (MaxTrackSandBoxCapacityM3 == 0)
            {
                MaxTrackSandBoxCapacityM3 = Me3.FromFt3(40.0f);  // Capacity of sandbox - assume 40.0 cu ft
            }

            if (MaxTrackSanderAirComsumptionForwardM3pS == 0 && SandingSystemType == SandingSystemTypes.Air)
            {
                MaxTrackSanderAirComsumptionForwardM3pS = Me3.FromFt3(56.0f) / 60.0f;  // Default value - cubic feet per min (CFM) 28 ft3/m x 2 sanders @ 140 psi - convert to /sec values
            }

            if (MaxTrackSanderSandConsumptionForwardM3pS == 0)
            {
                MaxTrackSanderSandConsumptionForwardM3pS = Me3.FromFt3(3.4f) / 3600.0f; // Default value - 1.7 ft3/h x 2 sanders @ 140 psi - convert to /sec values
            }

            if (MaxTrackSanderSteamConsumptionForwardLbpS == 0 && SandingSystemType == SandingSystemTypes.Steam)
            {
                MaxTrackSanderSteamConsumptionForwardLbpS = 300f / 3600f; // Default value - 300lbs/hr - this value is un confirmed at this stage.
            }

            base.Initialize();
            if (DynamicBrakeBlendingEnabled) airPipeSystem = BrakeSystem as AirSinglePipe;

        }

        /// <summary>
        /// Make instance of Cruise Control and Initialize it
        /// </summary>
        public void SetUpCruiseControl(STFReader stf)
        {
            CruiseControl = new CruiseControl(this);
            CruiseControl.Parse(stf);
        }

        /// <summary>
        /// Make instance of multi position controller
        /// </summary>
        public void SetUpMPC(STFReader stf)
        {
            var multiPositionController = new MultiPositionController(this);
            multiPositionController.Parse(stf);
            MultiPositionControllers.Add(multiPositionController);
        }

        public List<MultiPositionController> CloneMPC(MSTSLocomotive locomotive)
        {
            var multiPositionControllers = new List<MultiPositionController>();
            foreach (var mPC in MultiPositionControllers)
            {
                multiPositionControllers.Add(new MultiPositionController(mPC, locomotive));
            }
            return multiPositionControllers;
        }

        //================================================================================================//
        /// <summary>
        /// Set starting conditions  when initial speed > 0 
        /// </summary>
        /// 

        public override void InitializeMoving()
        {
            base.InitializeMoving();
            AdhesionFilter.Reset(0.5f);
            AverageForceN = MaxForceN * Train.MUThrottlePercent / 100;
            float maxPowerW = MaxPowerW * Train.MUThrottlePercent * Train.MUThrottlePercent / 10000;
            if (AverageForceN * SpeedMpS > maxPowerW) AverageForceN = maxPowerW / SpeedMpS;
            LocomotivePowerSupply?.InitializeMoving();
            if (Train.IsActualPlayerTrain)
            {
                TrainControlSystem.InitializeMoving();
                TrainBrakeController.InitializeMoving();
                BrakeSystem.LocoInitializeMoving();
                EngineBrakeController?.InitializeMoving();
            }
        }

        //================================================================================================//
        /// <summary>
        /// Correct braking parameters if needed or required 
        /// </summary>
        /// 
        protected void CorrectBrakingParams()
        {
            if (Simulator.Settings.CorrectQuestionableBrakingParams || Simulator.Settings.SimpleControlPhysics)
            {
                if (!(BrakeSystem is EPBrakeSystem) && !(BrakeSystem is VacuumSinglePipe) && !(BrakeSystem is AirTwinPipe))
                {
                    if (CompressorRestartPressurePSI - TrainBrakeController.MaxPressurePSI < DefaultCompressorRestartToMaxSysPressureDiff - 10)
                    {
                        CompressorRestartPressurePSI = Math.Max(CompressorRestartPressurePSI, Math.Min(TrainBrakeController.MaxPressurePSI + DefaultCompressorRestartToMaxSysPressureDiff, DefaultMaxCompressorRestartPressure));
                        MainResPressurePSI = MaxMainResPressurePSI = Math.Max(MaxMainResPressurePSI, Math.Min(CompressorRestartPressurePSI + DefaultMaxMainResToCompressorRestartPressureDiff, DefaultMaxMainResPressure));

                    }
                    if (MainResVolumeM3 < 0.3f && MassKG > 20000) MainResVolumeM3 = DefaultMainResVolume;

                    // correct questionable MaxCylPressurePSI
                    BrakeSystem.CorrectMaxCylPressurePSI(this);
                }
                if (MainResChargingRatePSIpS <= 0)
                {
                    MainResChargingRatePSIpS = Math.Max(0.5f, (CompressorChargingRateM3pS * Bar.ToPSI(1)) / MainResVolumeM3);
                }
            }
            else if (MainResChargingRatePSIpS <= 0) MainResChargingRatePSIpS = 0.4f;

            // Corrections for dynamic braking parameters

            if (this is MSTSElectricLocomotive && DynamicBrakeDelayS > 4) DynamicBrakeDelayS = 2; // Electric locomotives have short engaging delays
            if (DynamicBrakeSpeed2MpS > 0 && DynamicBrakeSpeed3MpS > 0 && DynamicBrakeSpeed2MpS > DynamicBrakeSpeed3MpS)
            {
                // also exchanging DynamicBrakesMaximumEffectiveSpeed with DynamicBrakesFadingSpeed is a frequent error that upsets operation of
                // dynamic brakes
                var temp = DynamicBrakeSpeed2MpS;
                DynamicBrakeSpeed2MpS = DynamicBrakeSpeed3MpS;
                DynamicBrakeSpeed3MpS = temp;
            }
            if (Simulator.Settings.CorrectQuestionableBrakingParams)
            {
                if (MaxDynamicBrakeForceN > 0 && MaxContinuousForceN > 0 &&
                (MaxDynamicBrakeForceN / MaxContinuousForceN < 0.3f && MaxDynamicBrakeForceN == 20000))
                    MaxDynamicBrakeForceN = Math.Min (MaxContinuousForceN * 0.5f, 150000); // 20000 is suggested as standard value in the MSTS documentation, but in general it is a too low value
            }
        }

        /// <summary>
        /// Dynamic brake blending 
        /// </summary>
        public void DynamicBrakeBlending(float elapsedClockSeconds)
        {
            // Local blending
            if (Math.Abs(SpeedMpS) > DynamicBrakeSpeed1MpS && airPipeSystem != null && airPipeSystem.AutoCylPressurePSI > 0.1f
                && ThrottlePercent == 0 && !(DynamicBrakeController != null && DynamicBrakeBlendingOverride && DynamicBrakeController.CurrentValue > 0))
            {
                float maxCylPressurePSI = airPipeSystem.GetMaxCylPressurePSI();
                float target = airPipeSystem.AutoCylPressurePSI * airPipeSystem.RelayValveRatio / maxCylPressurePSI;

                if (DynamicBrakeBlendingForceMatch)
                {
                    float diff = target * FrictionBrakeBlendingMaxForceN - DynamicBrakeForceN;
                    float threshold = 100;
                    if (diff > threshold && DynamicBrakePercent < 100)
                        DynamicBrakeBlendingPercent = Math.Min(DynamicBrakePercent + 100 * elapsedClockSeconds, 100);
                    else if (diff < -threshold && DynamicBrakePercent > 1)
                        DynamicBrakeBlendingPercent = Math.Max(DynamicBrakePercent - 100 * elapsedClockSeconds, 1);
                }
                else
                {
                    DynamicBrakeBlendingPercent = target * 100;
                }
            }
            else
            {
                DynamicBrakeBlendingPercent = -1;
            }
        }

        /// <summary>
        /// This function updates periodically the states and physical variables of the locomotive's subsystems.
        /// </summary>
        public override void Update(float elapsedClockSeconds)
        {
            // A control car typically doesn't have its own compressor and relies on the attached power car. However OR uses the lead locomotive as the reference car for compressor calculations.
            // Hence whilst users are encouraged to leave these parameters out of the ENG file, they need to be setup for OR to work correctly.
            // Some parameters need to be split across the unpowered and powered car for correct timing and volume calculations.
            // This setup loop is only processed the first time that update is run.
            if (EngineType == EngineTypes.Control && !controlTrailerBrakeSystemSet)
            {
                FindControlActiveLocomotive();

                if (ControlActiveLocomotive != null)
                {
                    // Split reservoir volume across the power car and the active locomotive
                    MainResVolumeM3 = ControlActiveLocomotive.MainResVolumeM3 / 2;
                    ControlActiveLocomotive.MainResVolumeM3 = MainResVolumeM3;

                    MaxMainResPressurePSI = ControlActiveLocomotive.MaxMainResPressurePSI;
                    MainResPressurePSI = MaxMainResPressurePSI;
                    ControlActiveLocomotive.MainResPressurePSI = MainResPressurePSI;
                    controlTrailerBrakeSystemSet = true; // Ensure this loop is only processes the first time update routine run
                    MaximumMainReservoirPipePressurePSI = ControlActiveLocomotive.MaximumMainReservoirPipePressurePSI;
                    CompressorRestartPressurePSI = ControlActiveLocomotive.CompressorRestartPressurePSI;
                    MainResChargingRatePSIpS = ControlActiveLocomotive.MainResChargingRatePSIpS;
                    BrakePipeChargingRatePSIorInHgpS = ControlActiveLocomotive.BrakePipeChargingRatePSIorInHgpS;
                    TrainBrakePipeLeakPSIorInHgpS = ControlActiveLocomotive.TrainBrakePipeLeakPSIorInHgpS;
                }
            }

            var gearloco = this as MSTSDieselLocomotive;

            // Pass Gearbox commands




            // Note - at the moment there is only one GearBox Controller created, but a gearbox for each diesel engine is created. 
            // This code keeps all gearboxes in the locomotive aligned with the first engine and gearbox.
            if (gearloco != null && gearloco.DieselTransmissionType == MSTSDieselLocomotive.DieselTransmissionTypes.Mechanic && GearBoxController.CurrentNotch != previousChangedGearBoxNotch)
            {
                // pass gearbox command key to other gearboxes in the same locomotive, only do the current locomotive             

                int ii = 0;
                foreach (var eng in gearloco.DieselEngines.DEList)
                {
                    // don't change the first engine as this is the reference for all the others
                    if (ii != 0)
                    {
                        gearloco.DieselEngines[ii].GearBox.currentGearIndex = gearloco.DieselEngines[0].GearBox.CurrentGearIndex;
                    }
                    
                    ii = ii + 1;
                }

            }

            // The lead locomotive passes gearbox commands position to other locomotives in train, don't treat the player locomotive in this fashion.

            if (gearloco != null && gearloco.DieselTransmissionType == MSTSDieselLocomotive.DieselTransmissionTypes.Mechanic && GearBoxController.CurrentNotch != previousChangedGearBoxNotch && IsLeadLocomotive())
            {
 
                foreach (TrainCar car in Train.Cars)
                {
                    var locog = car as MSTSDieselLocomotive;

                    if (locog != null && gearloco != null && car != this && !locog.IsLeadLocomotive())
                    {

                        locog.DieselEngines[0].GearBox.currentGearIndex = gearloco.DieselEngines[0].GearBox.CurrentGearIndex;

                        locog.GearBoxController.CurrentNotch = gearloco.DieselEngines[0].GearBox.CurrentGearIndex + 1;
                        locog.GearboxGearIndex = gearloco.DieselEngines[0].GearBox.CurrentGearIndex + 1;
                        locog.GearBoxController.SetValue((float)gearloco.GearBoxController.CurrentNotch);

                        locog.Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Increase, locog.GearBoxController.CurrentNotch);
                        locog.AlerterReset(TCSEvent.GearBoxChanged);
                        locog.SignalGearBoxChangeEvents();
                    }
                }

                previousChangedGearBoxNotch = GearBoxController.CurrentNotch; // reset loop until next gear change
            }

            TrainControlSystem.Update(elapsedClockSeconds);

            LocomotivePowerSupply?.Update(elapsedClockSeconds);
            UpdateControllers(elapsedClockSeconds);

            // Train Heading - only check the lead locomotive otherwise flipped locomotives further in consist will overwrite the train direction
            if (IsLeadLocomotive())
            {
                var heading = (float)Math.Atan2(WorldPosition.XNAMatrix.M13, WorldPosition.XNAMatrix.M11);
                Train.PhysicsTrainLocoDirectionDeg = MathHelper.ToDegrees((float)heading);

                if (Flipped)
                {
                    Train.PhysicsTrainLocoDirectionDeg += 180.0f; // Reverse direction of train
                    if (Train.PhysicsTrainLocoDirectionDeg > 360) // If this results in an angle greater then 360, then convert it back to an angle between 0 & 360.
                    {
                        Train.PhysicsTrainLocoDirectionDeg -= 360;
                    }
                }
            }

            if (IsSteamHeatFitted)
            {
                UpdateCarSteamHeat(elapsedClockSeconds);
            }

            if (!AdvancedAdhesionModel)  // Advanced adhesion model turned off.
               AbsWheelSpeedMpS = AbsSpeedMpS;

            // Cruise Control
            CruiseControl?.Update(elapsedClockSeconds);

            if (DynamicBrakePercent >= 0 && ThrottlePercent <= 0)
            {
                if (DynamicBrakeCommandStartTime == null)
                {
                    DynamicBrakeCommandStartTime = Simulator.ClockTime;
                }
                if (!DynamicBrake)
                {
                    if (DynamicBrakeCommandStartTime + DynamicBrakeDelayS < Simulator.ClockTime)
                    {
                        DynamicBrake = true; // Engage
                        if (IsLeadLocomotive() && DynamicBrakeIntervention >= 0)
                            Simulator.Confirmer.ConfirmWithPerCent(CabControl.DynamicBrake, DynamicBrakeController.CurrentValue * 100);
                    }
                    else if (IsLeadLocomotive() && DynamicBrakeIntervention >= 0)
                        Simulator.Confirmer.Confirm(CabControl.DynamicBrake, CabSetting.On); // Keeping status string on screen so user knows what's happening
                }
            }
            else
            {
                DynamicBrake = false;
                DynamicBrakeCommandStartTime = null;
            }

            // TODO  this is a wild simplification for electric and diesel electric
            if (EngineType == EngineTypes.Diesel || EngineType == EngineTypes.Electric)
            {
                UpdateTractiveForce(elapsedClockSeconds, ThrottlePercent / 100f, AbsSpeedMpS, AbsWheelSpeedMpS);
            }

            foreach (MultiPositionController mpc in MultiPositionControllers)
            {
                mpc.Update(elapsedClockSeconds);
            }
                

            UpdateFrictionCoefficient(elapsedClockSeconds); // Find the current coefficient of friction depending upon the weather

            UpdateWaterTroughRefill(elapsedClockSeconds, AbsSpeedMpS); // Update refill from trough

            switch (this.Train.TrainType)
            {
                case Train.TRAINTYPE.AI:
                case Train.TRAINTYPE.AI_PLAYERHOSTING:
                    if (RemoteControlGroup != -1)
                    {
                        if (!LocomotivePowerSupply.MainPowerSupplyOn)
                            Train.SignalEvent(PowerSupplyEvent.RaisePantograph, 1);

                        if (this is MSTSDieselLocomotive dieselLocomotive)
                        {
                            for (var i = 0; i < dieselLocomotive.DieselEngines.Count; i++)
                            {
                                var de = dieselLocomotive.DieselEngines[i];
                                if (!LocomotivePowerSupply.MainPowerSupplyOn)
                                {
                                    if (de.State != DieselEngineState.Running)
                                        de.Initialize();
                                }
                                if (de.GearBox != null)
                                    de.GearBox.GearBoxOperation = GearBoxOperation.Automatic;
                            }
                        }
                    }

                    AntiSlip = true; // Always set AI trains to AntiSlip
                    SimpleAdhesion();   // Simple adhesion model used for AI trains
                    AdvancedAdhesionModel = false;
                    if (Train.IsActualPlayerTrain) FilteredMotiveForceN = CurrentFilter.Filter(MotiveForceN, elapsedClockSeconds);
                    WheelSpeedMpS = Flipped ? -AbsSpeedMpS : AbsSpeedMpS;            //make the wheels go round
                    break;
                case Train.TRAINTYPE.STATIC:
                case Train.TRAINTYPE.INTENDED_PLAYER:
                    break;
                case Train.TRAINTYPE.PLAYER:
                case Train.TRAINTYPE.AI_PLAYERDRIVEN:
                case Train.TRAINTYPE.REMOTE:
                    // For notched throttle controls (e.g. Dash 9 found on Marias Pass) UpdateValue is always 0.0
                    if (ThrottleController.UpdateValue != 0.0)
                    {
                        Simulator.Confirmer.UpdateWithPerCent(
                            this is MSTSSteamLocomotive ? CabControl.Regulator : CabControl.Throttle,
                            ThrottleController.UpdateValue > 0 ? CabSetting.Increase : CabSetting.Decrease,
                            ThrottleController.CurrentValue * 100);
                    }
                    if (DynamicBrakeController != null && DynamicBrakeController.UpdateValue != 0.0 && (DynamicBrake || !DynamicBrakeControllerSetupLock))
                    {
                        Simulator.Confirmer.UpdateWithPerCent(
                            CabControl.DynamicBrake,
                            DynamicBrakeController.UpdateValue > 0 ? CabSetting.Increase : CabSetting.Decrease,
                            DynamicBrakeController.CurrentValue * 100);
                    }

                    // SimpleControlPhysics and if locomotive is a control car advanced adhesion will be "disabled".
                    if (Simulator.UseAdvancedAdhesion && !Simulator.Settings.SimpleControlPhysics && EngineType != EngineTypes.Control) 
                    {
                        AdvancedAdhesion(elapsedClockSeconds); // Use advanced adhesion model
                        AdvancedAdhesionModel = true;  // Set flag to advise advanced adhesion model is in use
                    }
                    else
                    {
                        SimpleAdhesion();  // Use simple adhesion model
                        AdvancedAdhesionModel = false; // Set flag to advise simple adhesion model is in use
                    }

                    UpdateTrackSander(elapsedClockSeconds);

                    if (this is MSTSDieselLocomotive || this is MSTSElectricLocomotive)  // Antislip and throttle down should only work on diesel or electric locomotives.
                    {

                        // If wheel slip waring activated, and antislip is set in ENG file then reduce throttle setting to a value below warning power
                        if (WheelSlipWarning && AntiSlip)
                        {
                            ThrottleController.SetValue(PreviousThrottleSetting);
                        }


                        PreviousThrottleSetting = (ThrottlePercent / 100.0f) - 0.005f;
                        PreviousThrottleSetting = MathHelper.Clamp(PreviousThrottleSetting, 0.0f, 1.0f); // Prevents parameter going outside of bounds 

                        // If wheels slip and WheelslipCausesThrottleDown is set in engine file reduce throttle to 0 setting
                        if (WheelslipCausesThrottleDown && WheelSlip)
                            ThrottleController.SetValue(0.0f);
                    }

                    //Force to display
                    FilteredMotiveForceN = CurrentFilter.Filter(MotiveForceN, elapsedClockSeconds);
                    break;
                default:
                    break;

            }

            // always set AntiSlip for AI trains
              if (Train.TrainType == Train.TRAINTYPE.AI || Train.TrainType == Train.TRAINTYPE.AI_PLAYERHOSTING)
                 {
                    AntiSlip = true;
                 }

            // If the train is vacuumed braked then no need to update the compressor, but udate the ejector instead
            if (BrakeSystem is VacuumSinglePipe)
            {

                if (VacuumBrakeEQFitted) // Only update exhauster/main reservoir on locomotives fitted ith an EQ reservoir
                {
                    UpdateVacuumExhauster(elapsedClockSeconds);
                }
                else
                {
                    UpdateSteamEjector(elapsedClockSeconds);
                }

            }
            else // if (EngineType != EngineTypes.Control) // TODO - Control trailers would not have compressors, but if they do then need to be linked to power supply requirements
            {
                UpdateCompressor(elapsedClockSeconds);
            }

            UpdateHornAndBell(elapsedClockSeconds);

            UpdateSoundVariables(elapsedClockSeconds);
            PrevMotiveForceN = MotiveForceN;
            base.Update(elapsedClockSeconds);

#if DEBUG_ADHESION
            // Timer to determine travel time - resets when locomotive stops
            if (AbsSpeedMpS > 0)
            {
                DebugTimer += elapsedClockSeconds;  // Increment debug timer whilever train is moving
            }
            else
            {
                DebugTimer = 0.0f; // Reset timer if train is stopped
            }

            // Speed detector, set to print out an adhesion snapshot every 5mph increment
            if (AbsSpeedMpS > MpS.FromMpH(DebugSpeed))
            {
                if (!DebugSpeedReached)
                {
                    DebugSpeedReached = true;                    
                }
                else
                {
                    if (DebugSpeedReached)
                    {
                        DebugSpeed += DebugSpeedIncrement;
                    }
                    DebugSpeedReached = false;

                }

            }

            // Only prints out in speed increments of 5mph
            if (DebugSpeedReached)
            {
                
                Trace.TraceInformation("====================================== Debug Adhesion (MSTSLocomotive.cs) ===============================");
                Trace.TraceInformation("AntiSlip - {0} ABSWheelSpeed {1}", AntiSlip, AbsWheelSpeedMpS);
                Trace.TraceInformation("Advanced Adhesion Model - {0}", Simulator.UseAdvancedAdhesion);
                Trace.TraceInformation("Car Id: {0} Engine type: {1} Speed: {2} Gradient: {3} Time: {4}", CarID, EngineType, FormatStrings.FormatSpeedDisplay(AbsSpeedMpS, IsMetric), -CurrentElevationPercent, DebugTimer);
                Trace.TraceInformation("Rail TE: {0} DBTE: {1}", FormatStrings.FormatForce(MotiveForceN, IsMetric), FormatStrings.FormatForce(CouplerForceU, IsMetric));

                Trace.TraceInformation("Axle - Drive Force: {0} Axle Force: {1} Wheelspeed: {2}", FormatStrings.FormatForce(LocomotiveAxle.DriveForceN, IsMetric), FormatStrings.FormatForce(LocomotiveAxle.AxleForceN, IsMetric), FormatStrings.FormatSpeedDisplay(WheelSpeedMpS, IsMetric));
                Trace.TraceInformation("Axle - Axle Inertia: {0} Wheel Radius: {1}", LocomotiveAxle.InertiaKgm2, DriverWheelRadiusM);

                Trace.TraceInformation("Adhesion - Curtius_A: {0} Curtius_B: {1} Curtius_C: {2} Curtius_D: {3}", Curtius_KnifflerA, Curtius_KnifflerB, Curtius_KnifflerC, AdhesionK);
                Trace.TraceInformation("Locomotive Weight: {0} Axle Weight: {1}", MassKG, DrvWheelWeightKg);

                Trace.TraceInformation("Axle Speed: {0} TrainSpeed: {1} Slip Speed: {2}", LocomotiveAxle.AxleSpeedMpS, LocomotiveAxle.TrainSpeedMpS, LocomotiveAxle.SlipSpeedMpS);

                Trace.TraceInformation("Adhesion Conditions: {0}", LocomotiveAxle.AdhesionConditions);

                Trace.TraceInformation("Fog - Min {0} fog {1}", Math.Min((Simulator.Weather.FogDistance * 2.75e-4f + 0.45f), 1.0f), Simulator.Weather.FogDistance);

                Trace.TraceInformation("Rain - Min {0} pric {1}", Math.Min((Simulator.Weather.PricipitationIntensityPPSPM2 * 0.0078f + 0.45f), 0.607f), Simulator.Weather.PricipitationIntensityPPSPM2);

            }
#endif

        } // End Method Update

        /// <summary>
        /// This function updates periodically the steam heating in wagons.
        /// </summary>
        protected virtual void UpdateCarSteamHeat(float elapsedClockSeconds)
        {
        }

        /// <summary>
        /// This function updates periodically the states and physical variables of the locomotive's controllers.
        /// </summary>
        protected virtual void UpdateControllers(float elapsedClockSeconds)
        {

            SteamHeatController.Update(elapsedClockSeconds);
            if (IsPlayerTrain)
            {
                if (SteamHeatController.UpdateValue > 0.0)
                    Simulator.Confirmer.UpdateWithPerCent(CabControl.SteamHeat, CabSetting.Increase, SteamHeatController.CurrentValue * 100);
                if (SteamHeatController.UpdateValue < 0.0)
                    Simulator.Confirmer.UpdateWithPerCent(CabControl.SteamHeat, CabSetting.Decrease, SteamHeatController.CurrentValue * 100);
            }

            TrainBrakeController.Update(elapsedClockSeconds);
            if (TrainBrakeController.UpdateValue > 0.0)
            {
                Simulator.Confirmer.Update(CabControl.TrainBrake, CabSetting.Increase, GetTrainBrakeStatus());
            }

            if (TrainBrakeController.UpdateValue < 0.0)
            {
                Simulator.Confirmer.Update(CabControl.TrainBrake, CabSetting.Decrease, GetTrainBrakeStatus());
            }

            if (EngineBrakeController != null)
            {
                EngineBrakeController.Update(elapsedClockSeconds);
                if (EngineBrakeController.UpdateValue > 0.0)
                {
                    Simulator.Confirmer.Update(CabControl.EngineBrake, CabSetting.Increase, GetEngineBrakeStatus());
                }
                if (EngineBrakeController.UpdateValue < 0.0)
                {
                    Simulator.Confirmer.Update(CabControl.EngineBrake, CabSetting.Decrease, GetEngineBrakeStatus());
                }
            }

            if (BrakemanBrakeController != null)
            {
                BrakemanBrakeController.Update(elapsedClockSeconds);
                if (BrakemanBrakeController.UpdateValue > 0.0)
                {
                    Simulator.Confirmer.Update(CabControl.BrakemanBrake, CabSetting.Increase, GetBrakemanBrakeStatus());
                }
                if (BrakemanBrakeController.UpdateValue < 0.0)
                {
                    Simulator.Confirmer.Update(CabControl.BrakemanBrake, CabSetting.Decrease, GetBrakemanBrakeStatus());
                }
            }

            DynamicBrakeBlending(elapsedClockSeconds);

            LocalDynamicBrakePercent = -1;
            if (IsLeadLocomotive() && TrainBrakeController != null && TrainBrakeController.TrainDynamicBrakeIntervention > 0)
            {
                LocalDynamicBrakePercent = TrainBrakeController.TrainDynamicBrakeIntervention * 100;
            }
            if (DynamicBrakeController != null && DynamicBrakeIntervention >= 0)
            {
                if (DynamicBrake || !DynamicBrakeControllerSetupLock)
                {
                    DynamicBrakeController.Update(elapsedClockSeconds);
                    DynamicBrakeIntervention = DynamicBrakeController.CurrentValue;
                }
                else
                {
                    DynamicBrakeIntervention = 0;
                }
                LocalDynamicBrakePercent = Math.Max(DynamicBrakeIntervention * 100, LocalDynamicBrakePercent);
            }
            if (IsLeadLocomotive()) DynamicBrakePercent = LocalDynamicBrakePercent;

            //Currently the ThrottlePercent is global to the entire train
            //So only the lead locomotive updates it, the others only updates the controller (actually useless)
            if (this.IsLeadLocomotive())
//            if (this.IsLeadLocomotive() || RemoteControlGroup == -1)
            {
                var throttleCurrentNotch = ThrottleController.CurrentNotch;
                ThrottleController.Update(elapsedClockSeconds);
                if (ThrottleController.CurrentNotch < throttleCurrentNotch && ThrottleController.ToZero)
                    SignalEvent(Event.ThrottleChange);
                ThrottlePercent = (ThrottleIntervention < 0 ? ThrottleController.CurrentValue : ThrottleIntervention) * 100.0f;
                ConfirmWheelslip(elapsedClockSeconds);
                LocalThrottlePercent = (ThrottleIntervention < 0 ? ThrottleController.CurrentValue : ThrottleIntervention) * 100.0f;
                DPThrottleController.Update(elapsedClockSeconds);
                if (DPDynamicBrakeController != null) DPDynamicBrakeController.Update(elapsedClockSeconds);
            }
            else
            {
                ThrottleController.Update(elapsedClockSeconds);
            }

#if INDIVIDUAL_CONTROL
			//this train is remote controlled, with mine as a helper, so I need to send the controlling information, but not the force.
			if (MultiPlayer.MPManager.IsMultiPlayer() && this.Train.TrainType == Train.TRAINTYPE.REMOTE && this == Program.Simulator.PlayerLocomotive)
			{
				//cannot control train brake as it is the remote's job to do so
				if ((EngineBrakeController != null && EngineBrakeController.UpdateValue != 0.0) || (DynamicBrakeController != null && DynamicBrakeController.UpdateValue != 0.0) || ThrottleController.UpdateValue != 0.0)
				{
					controlUpdated = true;
				}
				ThrottlePercent = ThrottleController.Update(elapsedClockSeconds) * 100.0f;
				if ((DynamicBrakeController != null) && (DynamicBrakePercent >= 0)) DynamicBrakePercent = DynamicBrakeController.Update(elapsedClockSeconds) * 100.0f;
				return; //done, will go back and send the message to the remote train controller
			}

			if (MultiPlayer.MPManager.IsMultiPlayer() && this.notificationReceived == true)
			{
				ThrottlePercent = ThrottleController.CurrentValue * 100.0f;
				this.notificationReceived = false;
			}
#endif
        }

        /// <summary>
        /// This function updates periodically the locomotive's motive force.
        /// </summary>
        protected virtual void UpdateTractiveForce(float elapsedClockSeconds, float t, float AbsSpeedMpS, float AbsWheelSpeedMpS)
        {
            // Method to set force and power info
            // An alternative method in the steam locomotive will override this and input force and power info for it.

            if (t > 1)
                t = 1;
            if (LocomotivePowerSupply.MainPowerSupplyOn && Direction != Direction.N)
            {
                // For the advanced adhesion model, a rudimentary form of slip control is incorporated by using the wheel speed to calculate tractive effort.
                // As wheel speed is increased tractive effort is decreased. Hence wheel slip is "controlled" to a certain extent.
                // This doesn't cover all types of locomotives, for example if DC traction motors and no slip control, then the tractive effort shouldn't be reduced.
                // This won't eliminate slip, but limits its impact. 
                // More modern locomotive have a more sophisticated system that eliminates slip in the majority (if not all circumstances).
                // Simple adhesion control does not have any slip control feature built into it.
                // TODO - a full review of slip/no slip control.
                if (TractionMotorType == TractionMotorTypes.AC)
                {
                    AbsTractionSpeedMpS = AbsSpeedMpS;
                }
                else
                {
                    if (WheelSlip && AdvancedAdhesionModel)
                    {
                        AbsTractionSpeedMpS = AbsWheelSpeedMpS;
                    }
                    else
                    {
                        AbsTractionSpeedMpS = AbsSpeedMpS;
                    }
                }

                if (TractiveForceCurves == null)
                {
                    float maxForceN = MaxForceN * t * (1 - PowerReduction);
                    float maxPowerW = MaxPowerW * t * t * (1 - PowerReduction);

                    if (maxForceN * AbsTractionSpeedMpS > maxPowerW)
                        maxForceN = maxPowerW / AbsTractionSpeedMpS;
                    //if (AbsSpeedMpS > MaxSpeedMpS)
                    //    maxForceN = 0;
                    if (AbsTractionSpeedMpS > MaxSpeedMpS - 0.05f)
                        maxForceN = 20 * (MaxSpeedMpS - AbsTractionSpeedMpS) * maxForceN;
                    if (AbsSpeedMpS > (MaxSpeedMpS))
                        maxForceN = 0;
                    TractiveForceN = maxForceN;
                }
                else
                {
                    TractiveForceN = TractiveForceCurves.Get(t, AbsTractionSpeedMpS) * (1 - PowerReduction);
                    if (TractiveForceN < 0 && !TractiveForceCurves.AcceptsNegativeValues())
                        TractiveForceN = 0;
                }
            }
            else
                TractiveForceN = 0f;

            if (MaxForceN > 0 && MaxContinuousForceN > 0 && PowerReduction < 1)
            {
                TractiveForceN *= 1 - (MaxForceN - MaxContinuousForceN) / (MaxForceN * MaxContinuousForceN) * AverageForceN * (1 - PowerReduction);
                float w = (ContinuousForceTimeFactor - elapsedClockSeconds) / ContinuousForceTimeFactor;
                if (w < 0)
                    w = 0;
                AverageForceN = w * AverageForceN + (1 - w) * TractiveForceN;
            }

            ApplyDirectionToTractiveForce(ref TractiveForceN, 0);

            // Calculate the total tractive force for the locomotive - ie Traction + Dynamic Braking force.
            // Note typically only one of the above will only ever be non-zero at the one time.
            // For flipped locomotives the force is "flipped" elsewhere, whereas dynamic brake force is "flipped" below by the direction of the speed.

            if (DynamicBrakePercent > 0 && DynamicBrake && DynamicBrakeForceCurves != null && AbsSpeedMpS > 0)
            {
                float f = DynamicBrakeForceCurves.Get(.01f * DynamicBrakePercent, AbsTractionSpeedMpS);
                if (f > 0 && LocomotivePowerSupply.DynamicBrakeAvailable)
                {
                    DynamicBrakeForceN = f * (1 - PowerReduction);
                    TractiveForceN -= (SpeedMpS > 0 ? 1 : SpeedMpS < 0 ? -1 : Direction == Direction.Reverse ? -1 : 1) * DynamicBrakeForceN;                 
                }
                else
                {
                    DynamicBrakeForceN = 0f;
                }
            }
            else
                DynamicBrakeForceN = 0; // Set dynamic brake force to zero if in Notch 0 position

            foreach (var motor in TractionMotors)
            {
                motor.UpdateTractiveForce(elapsedClockSeconds, t);
            }

            if (Simulator.UseAdvancedAdhesion && !Simulator.Settings.SimpleControlPhysics)
            {
                UpdateAxleDriveForce();
            }
        }

        protected virtual void UpdateAxleDriveForce()
        {
            foreach (var axle in LocomotiveAxles)
            {
                if (axle.DriveType == AxleDriveType.ForceDriven)
                {
                    axle.DriveForceN = TractiveForceN / LocomotiveAxles.Count;
                    if (SlipControlSystem == SlipControlType.Full)
                    {
                        // Simple slip control
                        // Motive force is reduced to the maximum adhesive force
                        // In wheelslip situations, motive force is set to zero
                        axle.DriveForceN = Math.Sign(axle.DriveForceN) * Math.Min(axle.MaximumPolachWheelAdhesion * axle.AxleWeightN, Math.Abs(axle.DriveForceN));
                        if (axle.IsWheelSlip) axle.DriveForceN = 0;
                    }
                }
            }
        }

        /// <summary>
        /// This function applies a sign to the motive force as a function of the direction of the train.
        /// </summary>
        protected virtual void ApplyDirectionToTractiveForce(ref float tractiveForceN, int numberofengine = 0 )
        {
            if (Train.IsPlayerDriven)
            {
                switch (Direction)
                {
                    case Direction.Forward:
                        //tractiveForceN *= 1;     //Not necessary
                        break;
                    case Direction.Reverse:
                        tractiveForceN *= -1;
                        break;
                    case Direction.N:
                    default:
                        tractiveForceN *= 0;
                        break;
                }
            }
            else // for AI locomotives
            {
                switch (Direction)
                {
                    case Direction.Reverse:
                        tractiveForceN *= -1;
                        break;
                    default:
                        break;
                }
            }// end AI locomotive            
        }

        protected enum Wheelslip
        {
            None,
            Warning,
            Occurring
        };

        protected Wheelslip WheelslipState = Wheelslip.None;

        public void ConfirmWheelslip(float elapsedClockSeconds)
        {
            if (elapsedClockSeconds > 0 && Simulator.GameTime - LocomotiveAxles.ResetTime > 5)
            {
                if (AdvancedAdhesionModel)
                {
                    // Wheelslip
                    if (HuDIsWheelSlip)
                    {
                        if (WheelslipState != Wheelslip.Occurring)
                        {
                            WheelslipState = Wheelslip.Occurring;
                            Simulator.Confirmer.Warning(CabControl.Wheelslip, CabSetting.On);
                            Trace.TraceInformation("Display Wheelslip#1 - CarID {0} WheelSlip {1}", CarID, HuDIsWheelSlip);
                        }
                    }
                    else
                    {
                        if (HuDIsWheelSlipWarninq)
                        {
                            if (WheelslipState != Wheelslip.Warning)
                            {
                                WheelslipState = Wheelslip.Warning;
                                Simulator.Confirmer.Confirm(CabControl.Wheelslip, CabSetting.Warn1);
                            }
                        }
                        else
                        {
                            if (WheelslipState != Wheelslip.None)
                            {
                                WheelslipState = Wheelslip.None;
                                Simulator.Confirmer.Confirm(CabControl.Wheelslip, CabSetting.Off);
                            }
                        }
                    }
                }
                else
                {
                    if (WheelSlip && (WheelslipState != Wheelslip.Occurring))
                    {
                        WheelslipState = Wheelslip.Occurring;
                        Simulator.Confirmer.Warning(CabControl.Wheelslip, CabSetting.On);
                        Trace.TraceInformation("Display Wheelslip#2");
                    }
                    if ((!WheelSlip) && (WheelslipState != Wheelslip.None))
                    {
                        WheelslipState = Wheelslip.None;
                        Simulator.Confirmer.Confirm(CabControl.Wheelslip, CabSetting.Off);
                    }
                }
            }
        }

        /// <summary>
        /// This function updates periodically the state of the steam ejector or vacuum pump on a vacuum braked system.
        /// </summary>
        protected virtual void UpdateSteamEjector(float elapsedClockSeconds)
        {
                 // Ejectors are controlled independently for the "straight_vacuum_single_pipe" brake type 
                 // Ejectors are controlled by brake control valves in Simple Physics Control
                if (Simulator.Settings.SimpleControlPhysics && CarBrakeSystemType != "straight_vacuum_single_pipe")
                // Simple braking - control Ejector automatically based upon the brake control position
                // Stop ejector operation if full vacuum pressure reached
                {
                if ((TrainBrakeController.TrainBrakeControllerState == ControllerState.Release || TrainBrakeController.TrainBrakeControllerState == ControllerState.FullQuickRelease || (TrainBrakeController.TrainBrakeControllerState == ControllerState.VacContServ)) && (this.BrakeSystem.BrakeLine1PressurePSI > Vac.ToPress(this.TrainBrakeController.MaxPressurePSI)))
                {
                    LargeSteamEjectorIsOn = true;  // If brake is set to a release controller, then turn ejector on
                    LargeEjectorSoundOn = true;
                }
                else
                {
                    LargeSteamEjectorIsOn = false; // If brake is not set to a release controller, or full vacuum reached, then turn ejector off
                    LargeEjectorSoundOn = false;
                }
                }
                else if (!LargeEjectorControllerFitted && CarBrakeSystemType != "straight_vacuum_single_pipe") // Use an "automatic" large ejector when using a dreadnought style brake controller - large ejector stays on until moved back to released position
                {
                    if (TrainBrakeController.TrainBrakeControllerState == ControllerState.Release)
                    {
                        LargeSteamEjectorIsOn = true;  // If brake is set to a release controller, then turn ejector on
                        LargeEjectorSoundOn = true;
                    }
                    else
                    {
                        LargeSteamEjectorIsOn = false; // If brake is not set to a release controller, then turn ejector off
                        if (LargeEjectorSoundOn)
                        {
                            SignalEvent(Event.LargeEjectorOff);
                            LargeEjectorSoundOn = false;
                        }
                    }

                }
                else  if (LargeEjectorControllerFitted)// Advanced braking - control ejector based upon using a "manual" large ejector control setting
                {
                    if (LargeEjectorFeedFraction > 0.05)
                    {
                        LargeSteamEjectorIsOn = true;  // turn ejector on
                        LargeEjectorSoundOn = true;
                    }
                    else
                    {
                        LargeSteamEjectorIsOn = false; // turn ejector off
                        LargeEjectorSoundOn = false;
                    }
                }


                if (SmallEjectorControllerFitted && CarBrakeSystemType != "straight_vacuum_single_pipe")
                // Turn small ejector on if controlled from drivers controller
                if (SmallEjectorFeedFraction > 0.05)
                {
                    SmallSteamEjectorIsOn = true;  // turn ejector on
                    SmallEjectorSoundOn = true;
                }
                else if (SmallEjectorControllerFitted)
                {
                    SmallSteamEjectorIsOn = false; // turn ejector off
                    SmallEjectorSoundOn = false;
                }

            
            // If diesel or electric locomotive, assume vacuum pump (exhauster) is continually running.
            if (!(this is MSTSSteamLocomotive))
            {
                VacuumPumpOperating = true;
            }
        }

        /// <summary>
        /// This function updates periodically the state of the vacuum exhauster on a vacuum braked system with a EQ reservoir.
        /// Resevoir vacuum is maintained in "atmospheric pressure" and converted to vacuum
        /// Vacuum reservoir should normally be maintained at approx 26InHg (4.185 psi)
        /// </summary>
        protected virtual void UpdateVacuumExhauster(float elapsedClockSeconds)
        {
            if (VacuumMainResVacuumPSIAorInHg > VacuumBrakesExhausterRestartVacuumPSIAorInHg && LocomotivePowerSupply.AuxiliaryPowerSupplyState == PowerSupplyState.PowerOn && !VacuumExhausterIsOn)
                SignalEvent(Event.VacuumExhausterOn);
            else if ((VacuumMainResVacuumPSIAorInHg < VacuumBrakesMainResMaxVacuumPSIAorInHg || LocomotivePowerSupply.AuxiliaryPowerSupplyState != PowerSupplyState.PowerOn) && VacuumExhausterIsOn)
                SignalEvent(Event.VacuumExhausterOff);

        }

        /// <summary>
        /// This function updates periodically the state of the compressor and charges the main reservoir if the compressor is active.
        /// </summary>
        protected virtual void UpdateCompressor(float elapsedClockSeconds)
        {

            var reservoirChargingRate = MainResChargingRatePSIpS;

            // For a mechanical compressor (typically fitted to a diesel locomotive) the charging rate will be related to the RpM of the diesel engine, and therefore 
            // derated by an amount equivalent to the diesel RpM.
            // All other locomotive types it will be the full charging rate for the reservoir

            // TO DO - For v1.4 this code uses the "electric" compressor code to control the compressor. The only additional feature is the addition of a variable 
            // charging rate based upon the diesel engine rpm. Note that the diesel compressor code operates regardless of whether the engine is running or not. 
            // This needs to be corrected in a future implementation.

            // If mechanical compressor then calculate charging rate based upon engine rpm
            if (CompressorIsMechanical && (EngineType == EngineTypes.Control || EngineType == EngineTypes.Diesel))
            {

                // Control car uses the attached active locomotive to set the charging rate
                if (EngineType == EngineTypes.Control)
                {
                    FindControlActiveLocomotive();

                    if (ControlActiveLocomotive != null)
                    {
                        var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;

                        // Set charging rate depending upon compressor rpm
                        reservoirChargingRate = (activeloco.DieselEngines[0].RealRPM / activeloco.DieselEngines[0].MaxRPM) * MainResChargingRatePSIpS;
                    }
                }
                else
                {
                    // Powered locomotive use themselves
                    var mstsDieselLocomotive = this as MSTSDieselLocomotive;

                    // Set charging rate depending upon compressor rpm
                    reservoirChargingRate = (mstsDieselLocomotive.DieselEngines[0].RealRPM / mstsDieselLocomotive.DieselEngines[0].MaxRPM) * MainResChargingRatePSIpS;
                }
            }

            // Turn compressor on and off
            if (MainResPressurePSI < CompressorRestartPressurePSI && LocomotivePowerSupply.AuxiliaryPowerSupplyState == PowerSupplyState.PowerOn && !CompressorIsOn)
            {
                SignalEvent(Event.CompressorOn);
                foreach (List<TrainCar> locoGroup in Train.LocoGroups)
                {
                    // Synchronize compressor between coupled locomotives
                    if (locoGroup.Contains(this as TrainCar))
                    {
                        foreach (TrainCar locoCar in locoGroup)
                            if (locoCar is MSTSLocomotive loco && loco.LocomotivePowerSupply.AuxiliaryPowerSupplyOn && !loco.CompressorIsOn)
                        loco.SignalEvent(Event.CompressorOn);
                    }
                    else if (CompressorIsMUControlled) // Synchronize compressor between remote groups if configured to do so
                    {
                        foreach (TrainCar remoteLocoCar in locoGroup)
                            if (remoteLocoCar is MSTSLocomotive remoteLoco && remoteLoco.LocomotivePowerSupply.AuxiliaryPowerSupplyOn && !remoteLoco.CompressorIsOn && remoteLoco.CompressorIsMUControlled)
                                remoteLoco.SignalEvent(Event.CompressorOn);
                    }
                }
            }
            else if ((MainResPressurePSI >= MaxMainResPressurePSI || LocomotivePowerSupply.AuxiliaryPowerSupplyState != PowerSupplyState.PowerOn) && CompressorIsOn)
            {
                SignalEvent(Event.CompressorOff);
            }

            if (CompressorIsOn)
                MainResPressurePSI += elapsedClockSeconds * reservoirChargingRate;
        }

        /// <summary>
        /// This function updates periodically the states of the horn/whistle and the bell of the locomotive.
        /// </summary>
        protected virtual void UpdateHornAndBell(float elapsedClockSeconds)
        {
            Horn = ManualHorn || TCSHorn;
            if (Horn && !PreviousHorn)
            {
                HornRecent = true;
                SignalEvent(Event.HornOn);
                if (MPManager.IsMultiPlayer()) MPManager.Notify((new MSGEvent(MPManager.GetUserName(), "HORN", 1)).ToString());
            }
            else if (!Horn && PreviousHorn)
            {
                // Research indicates ditch light horn timer starts when horn button is released
                HornStartTime = (float)Simulator.GameTime;
                SignalEvent(Event.HornOff);
                if (MPManager.IsMultiPlayer()) MPManager.Notify((new MSGEvent(MPManager.GetUserName(), "HORN", 0)).ToString());
            }

            if (HornStartTime != null && !Horn && Simulator.GameTime - HornStartTime > HornTimerS)
            {
                HornRecent = false;
                HornStartTime = null;
            }

            if (ManualBell)
            {
                BellState = SoundState.Sound;
            }
            else if (DoesHornTriggerBell && Horn)
            {
                BellState = SoundState.ContinuousSound;
            }
            else if (!ManualBell && BellState == SoundState.Sound)
            {
                BellState = SoundState.Stopped;
            }

            Bell = BellState != SoundState.Stopped;
            if (Bell && !PreviousBell)
            {
                BellRecent = true;
                BellStartTime = (float)Simulator.GameTime;
                SignalEvent(Event.BellOn);
                if (Train.TrainType != Train.TRAINTYPE.REMOTE && MPManager.IsMultiPlayer()) MPManager.Notify((new MSGEvent(MPManager.GetUserName(), "BELL", 1)).ToString());
            }
            else if (!Bell && PreviousBell)
            {
                SignalEvent(Event.BellOff);
                if (Train.TrainType != Train.TRAINTYPE.REMOTE && MPManager.IsMultiPlayer()) MPManager.Notify((new MSGEvent(MPManager.GetUserName(), "BELL", 0)).ToString());
            }

            if (BellStartTime != null && !Bell && Simulator.GameTime - BellStartTime > BellTimerS)
            {
                BellRecent = false;
                BellStartTime = null;
            }

            PreviousHorn = Horn;
            PreviousBell = Bell;
        }

        /// <summary>
        /// This function updates periodically the locomotive's sound variables.
        /// </summary>
        protected virtual void UpdateSoundVariables(float elapsedClockSeconds)
        {
        }

        /// <summary>
        /// Calls the Update method in the parent class MSTSWagon.
        /// </summary>
        /// <param name="elapsedClockSeconds"></param>
        protected void UpdateParent(float elapsedClockSeconds)
        {
            base.Update(elapsedClockSeconds);
        }

        /// <summary>
        /// Adjusts the MotiveForce to account for adhesion limits
        /// If UseAdvancedAdhesion is true, dynamic adhesion model is computed
        /// If UseAdvancedAdhesion is false, the basic force limits are calculated the same way MSTS calculates them, but
        /// the weather handling is different and Curtius-Kniffler curves are considered as a static limit
        /// </summary>
        public virtual void AdvancedAdhesion(float elapsedClockSeconds)
        {

            if (LocoNumDrvAxles <= 0)
            {
                WheelSpeedMpS = AbsSpeedMpS;
                return;
            }

            foreach (var axle in LocomotiveAxles)
            {
                axle.BrakeRetardForceN = BrakeRetardForceN / LocomotiveAxles.Count;
                axle.TrainSpeedMpS = SpeedMpS;                //Set the train speed of the axle mod
                axle.WheelRadiusM = DriverWheelRadiusM;
                axle.WheelDistanceGaugeM = TrackGaugeM;
                axle.CurrentCurveRadiusM = CurrentCurveRadiusM;
                axle.BogieRigidWheelBaseM = RigidWheelBaseM;
                axle.CurtiusKnifflerZeroSpeed = ZeroSpeedAdhesionBase;
            }

            LocomotiveAxles.Update(elapsedClockSeconds);

            MotiveForceN = LocomotiveAxles.CompensatedForceN;

            if (elapsedClockSeconds > 0)
            {
                WheelSlip = LocomotiveAxles.IsWheelSlip;
                WheelSlipWarning = LocomotiveAxles.IsWheelSlipWarning;
                HuDIsWheelSlip = LocomotiveAxles.HuDIsWheelSlip;
                HuDIsWheelSlipWarninq = LocomotiveAxles.HuDIsWheelSlipWarning;
            }

            WheelSpeedMpS = (float)LocomotiveAxles[0].AxleSpeedMpS;
        }

        public void SimpleAdhesion()
        {
            MotiveForceN = TractiveForceN;
            // Check if the following few lines are required???
            if (LocoNumDrvAxles <= 0)
            {
                WheelSpeedMpS = AbsSpeedMpS;
                return;
            }
            
            if (LocoNumDrvAxles <= 0)
                return;

            //Curtius-Kniffler computation
            // Set to a high level of adhesion to ensure that locomotive rarely slips in dry mode
            float uMax = 1.3f * (7.5f / (AbsSpeedMpS + 44.0f) + 0.161f); // Curtius - Kniffler equation
 
            float max0 = DrvWheelWeightKg * 9.81f * uMax;  //Ahesion limit in [N]
            float max1;
            float SandingFrictionFactor = 1;

            if (Simulator.WeatherType == WeatherType.Rain || Simulator.WeatherType == WeatherType.Snow)
            {
                if (Train.SlipperySpotDistanceM < 0)
                {
                    Train.SlipperySpotLengthM = 10 + 40 * (float)Simulator.Random.NextDouble();
                    Train.SlipperySpotDistanceM = Train.SlipperySpotLengthM + 2000 * (float)Simulator.Random.NextDouble();
                }
                if (Train.SlipperySpotDistanceM < Train.SlipperySpotLengthM)
                    max0 *= 0.8f;
                if (Simulator.WeatherType == WeatherType.Rain)
                    max0 *= 0.8f;
                else
                    max0 *= 0.7f;
            }
            //float max1 = (Sander ? .95f : Adhesion2) * max0;  //Not used this way
            max1 = MaxForceN;
            //add sander
            if (Sander && AbsSpeedMpS < SanderSpeedOfMpS && CurrentTrackSandBoxCapacityM3 > 0.0 && MainResPressurePSI > 80.0)
            {
                switch (Simulator.WeatherType)
                {
                    case WeatherType.Clear: SandingFrictionFactor = 1.2f; break;
                    case WeatherType.Rain: SandingFrictionFactor = 1.8f; break;
                    case WeatherType.Snow: SandingFrictionFactor = 2.5f; break;
                }
                if (SanderSpeedEffectUpToMpS > 0.0f) // Reduce sander effectiveness if max effective speed is defined
                {
                    SandingFrictionFactor *= (1.0f - 0.5f / SanderSpeedEffectUpToMpS * AbsSpeedMpS);
                }
                max0 *= Math.Max(SandingFrictionFactor, 1.0f); // Prevent sand from harming adhesion above max effective speed
            }

            max1 = max0;

            WheelSlip = false;

            if (MotiveForceN > max1)
            {
                WheelSlip = true;
                if (AntiSlip)
                    MotiveForceN = max1;
                else
                    MotiveForceN = Adhesion1 * max0;        //Lowers the adhesion limit to 20% of its full
            }
            else if (MotiveForceN < -max1)
            {
                WheelSlip = true;
                if (AntiSlip)
                    MotiveForceN = -max1;
                else
                    MotiveForceN = -Adhesion1 * max0;       //Lowers the adhesion limit to 20% of its full
            }
        }

        /// <summary>
        /// Refills the locomotive from a water trough
        /// </summary>
        public virtual void UpdateWaterTroughRefill(float elapsedClockSeconds, float absSpeedMpS)
        {
            // Check to see whether locomotive is to be refilled over water trough
            if (Simulator.PlayerLocomotive == this && IsWaterScoopDown)
            {


                var fraction = GetFilledFraction((uint)MSTSWagon.PickupType.FuelWater);

                if (!HasWaterScoop)
                {
                    if (!WaterScoopNotFittedFlag)
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("No water scoop on this loco"));
                        WaterScoopNotFittedFlag = true;
                    }
                    RefillingFromTrough = false;
                }
                else if (ScoopIsBroken)
                {
                    Simulator.Confirmer.Message(ConfirmLevel.Error, Simulator.Catalog.GetString("Scoop is broken, can't refill"));
                    RefillingFromTrough = false;       
                }
                else if (IsOverJunction())
                {
                    if (!ScoopIsBroken) // Only display message first time scoop is broken
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.Error, Simulator.Catalog.GetString("Scoop is broken by junction track"));
                    }
                    ScoopIsBroken = true;
                    RefillingFromTrough = false;
                    SignalEvent(Event.WaterScoopBroken);       
                }
                else if (!IsOverTrough())
                {
                    if (!WaterScoopOverTroughFlag)
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("Scoop is not over trough, can't refill"));
                        WaterScoopOverTroughFlag = true;
                        MSTSWagon.RefillProcess.OkToRefill = false;
                        MSTSWagon.RefillProcess.ActivePickupObjectUID = 0;
                    }
                    RefillingFromTrough = false;
                }
                else if (IsTenderRequired == 1 && Direction == Direction.Reverse) // Locomotives with tenders cannot go in reverse
                {
                    if (!WaterScoopDirectionFlag)
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.None, Simulator.Catalog.GetStringFmt("Refill: Loco must be moving forward."));
                        WaterScoopDirectionFlag = true;
                    }
                    RefillingFromTrough = false;
                }
                else if (absSpeedMpS < WaterScoopMinSpeedMpS)
                {
                    if (!WaterScoopSlowSpeedFlag)
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.None, Simulator.Catalog.GetStringFmt("Refill: Loco speed must exceed {0} for water to enter tender.",
                                FormatStrings.FormatSpeedLimit(WaterScoopMinSpeedMpS, MilepostUnitsMetric)));
                        WaterScoopSlowSpeedFlag = true;
                        MSTSWagon.RefillProcess.OkToRefill = false;
                        MSTSWagon.RefillProcess.ActivePickupObjectUID = 0;
                    }
                    RefillingFromTrough = false;
                }
                else if (fraction > 1.0)
                {
                    Simulator.Confirmer.Message(ConfirmLevel.None, Simulator.Catalog.GetStringFmt("Refill: Water supply now replenished."));
                }
                else
                {
                    MSTSWagon.RefillProcess.OkToRefill = true;
                    MSTSWagon.RefillProcess.ActivePickupObjectUID = -1;
                    RefillingFromTrough = true;
                    WaterScoopOverTroughFlag = false; // Reset flag so that message will come up again
                }

            }
            else if (HasWaterScoop && MSTSWagon.RefillProcess.OkToRefill == true && IsOverTrough())// water scoop has been raised, stop water filling
            {
                MSTSWagon.RefillProcess.OkToRefill = false;
                MSTSWagon.RefillProcess.ActivePickupObjectUID = 0;
                RefillingFromTrough = false;
            }


            // update water scoop
            // Water scoop fill charateristics can be found in - 
            // Calculate water velocity entering pipe: v = SQRT ( loco speed^2 - 2 * gravity * h)
            // Calculate the drag of the water scoop in the water: Drag Force = 0.5 * Drag Coeff * Fluid Density * Reference Area * Velocity

            if (RefillingFromTrough)
            {
                // Calculate water velocity
                const float Aconst = 2;
                const float Bconst = 2.15f;
                float Avalue = ((float)Math.Pow(MpS.ToMpH(absSpeedMpS), 2) * Bconst);
                float Bvalue = Aconst * GravitationalAccelerationFtpSpS * Me.ToFt(WaterScoopFillElevationM);

                if (Avalue > Bvalue)
                {
                    WaterScoopVelocityMpS = Me.FromFt((float)Math.Sqrt(Avalue - Bvalue));
                }
                else
                {
                    WaterScoopVelocityMpS = 0;
                }

                // calculate volume of water scooped per period
                const float CuFttoGalUK = 6.22884f; // imperial gallons of water in a cubic foot of water
                WaterScoopedQuantityLpS = L.FromGUK(Me2.ToFt2((WaterScoopDepthM * WaterScoopWidthM)) * Me.ToFt(WaterScoopVelocityMpS) * CuFttoGalUK);
                WaterScoopInputAmountL = WaterScoopedQuantityLpS * elapsedClockSeconds; // Calculate current input quantity

                // Max sure that water level can't exceed maximum tender water level. Assume that water will be vented out of tender if maximum value exceeded. 
                // If filling from water trough this will be done with force
                // The water controller can only be used by one stock item at a time.
                if (EngineType == EngineTypes.Steam)
                {
                    const float NominalExtraWaterVolumeFactor = 1.0001f;
                    CombinedTenderWaterVolumeUKG += L.ToGUK(WaterScoopInputAmountL); // add the amount of water added by scoop
                    WaterScoopTotalWaterL += WaterScoopInputAmountL;
                    CombinedTenderWaterVolumeUKG = MathHelper.Clamp(CombinedTenderWaterVolumeUKG, 0.0f, MaxTotalCombinedWaterVolumeUKG * NominalExtraWaterVolumeFactor);
                }
                else
                {
                    CurrentLocomotiveSteamHeatBoilerWaterCapacityL += WaterScoopInputAmountL; // add water if it is a steam heat boiler
                    CurrentLocomotiveSteamHeatBoilerWaterCapacityL = MathHelper.Clamp(CurrentLocomotiveSteamHeatBoilerWaterCapacityL, 0.0f, MaximumSteamHeatBoilerWaterTankCapacityL);
                }

                // Calculate drag force
                float ScoopDragCoeff = 1.05f;
                float ScoopDragAreaM = WaterScoopDepthM * WaterScoopWidthM;
                float ScoopFluidDensityKgpM3 = 998.2f; // Fuild density of water @ 20c
                WaterScoopDragForceN = 0.5f * ScoopDragCoeff * ScoopFluidDensityKgpM3 * ScoopDragAreaM * absSpeedMpS * absSpeedMpS;

                // Turn water scoop sound on
                if (!WaterScoopSoundOn)
                {
                    WaterScoopSoundOn = true;
                    SignalEvent(Event.WaterScoopDown);
                }
            }
            else // Ensure water scoop values are zero if not taking water.
            {
                WaterScoopDragForceN = 0f;
                WaterScoopedQuantityLpS = 0;
                WaterScoopInputAmountL = 0;
                WaterScoopVelocityMpS = 0;

                if (!IsOverTrough()) // Only reset once train moves off the trough
                {
                    WaterScoopTotalWaterL = 0.0f; // Reset amount of water picked up by water sccop.
                }

                // Turn water scoop sound off
                if (WaterScoopSoundOn)
                {
                    WaterScoopSoundOn = false;
                    SignalEvent(Event.WaterScoopUp);
                }
            }
        }

        #region Calculate Friction Coefficient
        /// <summary>
        /// Calculates the current coefficient of friction based upon the current weather 
        /// The calculation of Coefficient of Friction appears to provide a wide range of 
        /// variations depending upon a number of factors including the wheel and track 
        /// composition, and whether the track is dry, wet (or lubricated), icy, covered 
        /// in leaf litter, etc.
        /// For the purposes of simulating frcition the following values have been used. 
        /// Some reference documents have suggested that friction can vary between 0.07 
        /// for lubricated or icy track to 0.78 for dry track.
        /// The standard Cutius-Kniffler formula for dry rail is used as a base.
        /// Dry track = 0.33 
        /// 
        /// The following values are indicatitive values only (sourced from Principles and Applications of Tribology).
        /// https://books.google.com.au/books?id=LtYgBQAAQBAJ&pg=PA312&lpg=PA312&dq=Principles+and+Applications+of+Tribology+table+14.1&source=bl&ots=2hfz1WpEsM&sig=ACfU3U3U9y9Lwov9GORLaKCO10SCFHvjhA&hl=en&sa=X&ved=2ahUKEwi82NCF_Yr0AhWNTX0KHcGfB3QQ6AF6BAgMEAM#v=onepage&q=Principles%20and%20Applications%20of%20Tribology%20table%2014.1&f=false
        /// Dry (clean) - 0.25 to 0.3
        /// Dry (sand) - 0.35 to 0.4
        /// Wet track (clean) = 0.18 <=> 0.2
        /// Wet track (sand) = 0.22 <=> 0.25
        /// Dew or fog = 0.09 <=> 0.15
        /// Sleet = 0.15
        /// Sleet (sand) = 0.2
        /// Snow track = 0.1 
        /// Snow track (sand) = 0.15
        /// 
        /// Note Heavy rain will actually wash track clean, and will give a higher value of adhesion then light drizzling rain
        /// </summary>
        public virtual void UpdateFrictionCoefficient(float elapsedClockSeconds)
        {
            float BaseuMax = (Curtius_KnifflerA / (MpS.ToKpH(AbsSpeedMpS) + Curtius_KnifflerB) + Curtius_KnifflerC); // Base Curtius - Kniffler equation - u = 0.33, all other values are scaled off this formula
            float SandingFrictionCoefficientFactor = 1.0f;

            //Set the friction coeff due to weather - uses the vlaues set in the precipitation module to determine whether clear, rain or snow.

            // Adjust clear weather for precipitation presence, ie base value between 60% and 80% 
            // note lowest friction will be for drizzle (light) rain; friction will increase for precipitation higher than drizzle rail
            if (!Simulator.Paused)
            {
                var fogBaseFrictionCoefficientFactor = 1.0f;
                var pricBaseFrictionCoefficientFactor = 1.0f;
                float pric = Simulator.Weather.PricipitationIntensityPPSPM2 * 1000;
                // precipitation will calculate a base coefficient value between 60% (light rain) and 90% (heavy rain) - this will be a factor that is used to adjust the base value 
                // assume linear value between upper and lower precipitation values. Limits are set in the weather module, ie Rain = 0.01ppm (10) and Snow = 0.005ppm (5)
                float precGrad = (0.2f - 0) / (10f - 5f);

                if (pric <= 1.0f)
                {
                    pricBaseFrictionCoefficientFactor = 1.0f;
                }
                else if (pric > 0)
                {
                    pricBaseFrictionCoefficientFactor = Math.Min((pric - 5f) * precGrad + 0.6f, 0.9f); 
                    // should give a value between 0.6 and 0.9
                }

                // Adjust adhesion for impact of fog - default = 20000m = 20km
                float fog = Simulator.Weather.FogDistance;
                if (fog < 20000) // as fog thickens then decrease adhesion
                {
                    fogBaseFrictionCoefficientFactor = Math.Min((fog * 2.75e-4f + 0.6f), 1.0f); // If fog is less then 2km then it will impact friction, decrease adhesion to 60% (same as light rain transition)
                }

                BaseFrictionCoefficientFactor = Math.Min(fogBaseFrictionCoefficientFactor, pricBaseFrictionCoefficientFactor);
            }

            // Random slippery track
            if (Train.SlipperySpotDistanceM < 0)
            {
                Train.SlipperySpotLengthM = 10 + 40 * (float)Simulator.Random.NextDouble();
                Train.SlipperySpotDistanceM = Train.SlipperySpotLengthM + 2000 * (float)Simulator.Random.NextDouble();
            }
            if (Train.SlipperySpotDistanceM < Train.SlipperySpotLengthM && Simulator.Settings.AdhesionFactorChange > 0)
            {
                if (BaseFrictionCoefficientFactor > 0.6 && BaseFrictionCoefficientFactor < 0.8)
                {
                    BaseFrictionCoefficientFactor = 0.6f;
                }
                else
                {
                    BaseFrictionCoefficientFactor = 0.8f;
                }
            }

            BaseFrictionCoefficientFactor = MathHelper.Clamp(BaseFrictionCoefficientFactor, 0.5f, 1.0f);

            // Increase friction coefficient when sanding
            if (Sander && AbsSpeedMpS < SanderSpeedOfMpS && CurrentTrackSandBoxCapacityM3 > 0.0 && MainResPressurePSI > 80.0)
            {
                switch (Simulator.WeatherType)
                {
                    case WeatherType.Clear: SandingFrictionCoefficientFactor = 1.40f; break;
                    case WeatherType.Rain: SandingFrictionCoefficientFactor = 1.25f; break;
                    case WeatherType.Snow: SandingFrictionCoefficientFactor = 1.50f; break;
                }
                if (SanderSpeedEffectUpToMpS > 0.0f) // Reduce sander effectiveness if max effective speed is defined
                {
                    SandingFrictionCoefficientFactor *= (1.0f - 0.5f / SanderSpeedEffectUpToMpS * AbsSpeedMpS);
                }
                BaseFrictionCoefficientFactor *= Math.Max(SandingFrictionCoefficientFactor, 1.0f); // Prevent sand from harming adhesion above max effective speed
            }

            // For wagons use base Curtius-Kniffler adhesion factor - u = 0.33
            float WagonCurtius_KnifflerA = 7.5f;
            float WagonCurtius_KnifflerB = 44.0f;
            float WagonCurtius_KnifflerC = 0.161f;
            
            float WagonBaseuMax = (WagonCurtius_KnifflerA / (MpS.ToKpH(AbsSpeedMpS) + WagonCurtius_KnifflerB) + WagonCurtius_KnifflerC);
            Train.WagonCoefficientFriction = WagonBaseuMax * BaseFrictionCoefficientFactor;  // Find friction coefficient factor for wagons based upon environmental conditions
            WagonCoefficientFrictionHUD = Train.WagonCoefficientFriction; // Save value for HUD display

            if (EngineType == EngineTypes.Steam && SteamDrvWheelWeightLbs < 10000 && Simulator.WeatherType == WeatherType.Clear)
            {
                BaseFrictionCoefficientFactor *= 0.75f;  // Dry track - static friction for vehicles with wheel weights less then 10,000lbs - u = 0.25

            }

            var AdhesionMultiplier = Simulator.Settings.AdhesionFactor / 100.0f; // Convert to a factor where 100% = no change to adhesion
            var AdhesionRandom = (float)((float)(Simulator.Settings.AdhesionFactorChange) * 0.01f * 2f * (Simulator.Random.NextDouble() - 0.5f));

            Train.LocomotiveCoefficientFriction = BaseuMax * BaseFrictionCoefficientFactor * AdhesionMultiplier;  // Find friction coefficient factor for locomotive
            Train.LocomotiveCoefficientFriction = MathHelper.Clamp(Train.LocomotiveCoefficientFriction, 0.05f, 0.8f); // Ensure friction coefficient never exceeds a "reasonable" value

            float ZeroBaseuMax = (Curtius_KnifflerA / (Curtius_KnifflerB) + Curtius_KnifflerC); // Base Curtius - Kniffler equation - u = 0.33, all other values are scaled off this formula
            ZeroSpeedAdhesionBase = ZeroBaseuMax * BaseFrictionCoefficientFactor * AdhesionMultiplier;

            // Set adhesion conditions for diesel, electric or steam geared locomotives
            if (elapsedClockSeconds > 0)
            {
                SaveAdhesionFilter = AdhesionFilter.Filter(BaseFrictionCoefficientFactor + AdhesionRandom, elapsedClockSeconds);
                AdhesionConditions = MathHelper.Clamp(AdhesionMultiplier * SaveAdhesionFilter, 0.05f, 2.5f);
                foreach (var axle in LocomotiveAxles)
                {
                    axle.AdhesionLimit = AdhesionConditions * BaseuMax;
                    axle.CurtiusKnifflerZeroSpeed = ZeroBaseuMax;
                }
            }

           // Set adhesion conditions for other steam locomotives
            if (EngineType == EngineTypes.Steam && SteamEngineType != MSTSSteamLocomotive.SteamEngineTypes.Geared)  // ToDo explore adhesion factors
            {
                LocomotiveCoefficientFrictionHUD = Train.LocomotiveCoefficientFriction; // Set display value for HUD - steam
            }
            else
            {
                LocomotiveCoefficientFrictionHUD = LocomotiveAxles[0].AdhesionLimit; // Set display value for HUD - diesel
            }
        }

        #endregion

        public void UpdateTrackSander(float elapsedClockSeconds)
        {
        // updates track sander in terms of sand usage and impact on air compressor
        // The following assumptions have been made:
        //

            if (Sander && AbsSpeedMpS < SanderSpeedOfMpS)  // If sander switch is on, and not blocked by speed, adjust parameters
            {

                // Calculate steam, air or gravity consumption for different sander modes
                if (SandingSystemType == SandingSystemTypes.Steam)
                {
                    float sandingSteamConsumptionLbpS = 0.0f;
                    float sandingSandConsumptionM3pS = 0.0f;

                    if (Direction == Direction.Reverse)
                    {
                        sandingSteamConsumptionLbpS = MaxTrackSanderSteamConsumptionReverseLbpS;
                        sandingSandConsumptionM3pS = MaxTrackSanderSandConsumptionReverseM3pS;
                    }
                    else
                    {
                        sandingSteamConsumptionLbpS = MaxTrackSanderSteamConsumptionForwardLbpS;
                        sandingSandConsumptionM3pS = MaxTrackSanderSandConsumptionForwardM3pS;
                    }

                    // Calculate steam consumption
                    SandingSteamUsageLBpS = (BoilerPressurePSI / MaxBoilerPressurePSI) * sandingSteamConsumptionLbpS * elapsedClockSeconds;

                    // Calculate sand consumption for sander
                if (CurrentTrackSandBoxCapacityM3 > 0.0) // if sand still in sandbox then sanding is available
                {
                    // Calculate consumption of sand, and drop in sand box level
                        CurrentTrackSanderSandConsumptionM3pS = (BoilerPressurePSI / MaxBoilerPressurePSI) * sandingSandConsumptionM3pS * elapsedClockSeconds;
                        CurrentTrackSandBoxCapacityM3 -= CurrentTrackSanderSandConsumptionM3pS;
                    CurrentTrackSandBoxCapacityM3 = MathHelper.Clamp(CurrentTrackSandBoxCapacityM3, 0.0f, MaxTrackSandBoxCapacityM3);
                        if (CurrentTrackSandBoxCapacityM3 <= 0.0)
                    {
                        Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("Sand supply has been exhausted"));
                    }
                }
                }
                else // air consumption
                {
                    float sandingAirConsumptionM3pS = 0.0f;
                    float sandingSandConsumptionM3pS = 0.0f;

                    if (Direction == Direction.Reverse)
                    {
                        sandingAirConsumptionM3pS = MaxTrackSanderAirComsumptionReverseM3pS;
                        sandingSandConsumptionM3pS = MaxTrackSanderSandConsumptionReverseM3pS;
                    }
                    else
                    {
                        sandingAirConsumptionM3pS = MaxTrackSanderAirComsumptionForwardM3pS;
                        sandingSandConsumptionM3pS = MaxTrackSanderSandConsumptionForwardM3pS;
            }

                    // Calculate air consumption and change in main air reservoir pressure
                    CurrentTrackSanderAirConsumptionM3pS = (MainResPressurePSI / MaxMainResPressurePSI) * sandingAirConsumptionM3pS * elapsedClockSeconds;
                    float SanderPressureDiffPSI = CurrentTrackSanderAirConsumptionM3pS / Me3.ToFt3(MainResVolumeM3);
                    MainResPressurePSI -= SanderPressureDiffPSI;
                    MainResPressurePSI = MathHelper.Clamp(MainResPressurePSI, 0.001f, MaxMainResPressurePSI);

                    // Calculate sand consumption for sander
                    if (CurrentTrackSandBoxCapacityM3 > 0.0) // if sand still in sandbox then sanding is available
                    {
                        // Calculate consumption of sand, and drop in sand box level
                        CurrentTrackSanderSandConsumptionM3pS = (MainResPressurePSI / MaxMainResPressurePSI) * sandingSandConsumptionM3pS * elapsedClockSeconds;
                        CurrentTrackSandBoxCapacityM3 -= CurrentTrackSanderSandConsumptionM3pS;
                        CurrentTrackSandBoxCapacityM3 = MathHelper.Clamp(CurrentTrackSandBoxCapacityM3, 0.0f, MaxTrackSandBoxCapacityM3);
                        if (CurrentTrackSandBoxCapacityM3 <= 0.0)
                        {
                            Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("Sand supply has been exhausted"));
                        }
                    }
                }
            }
            else // reset to zero if sander is off
            {
                CurrentTrackSanderSandConsumptionM3pS = 0;
                CurrentTrackSanderAirConsumptionM3pS = 0;
                SandingSteamUsageLBpS = 0;
            }
        }

        public override bool GetSanderOn()
        {
            return Sander;
        }
                                 
        #region Reverser
        public void SetDirection(Direction direction)
        {
            if (Direction != direction && ThrottlePercent < 1)
            {
                Direction = direction;
                switch (direction)
                {
                    case Direction.Reverse: SignalEvent(Event.ReverserToForwardBackward); break;
                    case Direction.N: SignalEvent(Event.ReverserToNeutral); break;
                    case Direction.Forward: SignalEvent(Event.ReverserToForwardBackward); break;
                }
                // passes event also to other locomotives
                foreach (TrainCar car in Train.Cars)
                {
                    var loco = car as MSTSLocomotive;
                    //                    if (loco != null && car != this && loco.AcceptMUSignals)
                    if (loco != null && car != this && loco.RemoteControlGroup >= 0)
                        switch (direction)
                        {
                            case Direction.Reverse: loco.SignalEvent(Event.ReverserToForwardBackward); break;
                            case Direction.N: loco.SignalEvent(Event.ReverserToNeutral); break;
                            case Direction.Forward: loco.SignalEvent(Event.ReverserToForwardBackward); break;
                        }

                }
                SignalEvent(Event.ReverserChange);
                if (direction == Direction.Forward)
                    Train.MUReverserPercent = 100;
                else
                    Train.MUReverserPercent = -100;
            }

        }

        public virtual void StartReverseIncrease(float? target)
        {
            AlerterReset(TCSEvent.ReverserChanged);
            if (this.IsLeadLocomotive())
            {
                {
                    switch (Direction)
                    {
                        case Direction.Reverse: SetDirection(Direction.N); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.Neutral); break;
                        case Direction.N: SetDirection(Direction.Forward); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.On); break;
                        case Direction.Forward: SetDirection(Direction.Forward); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.On); break;
                    }
                }
            }
        }

        public virtual void StartReverseDecrease(float? target)
        {
            AlerterReset(TCSEvent.ReverserChanged);
            if (this.IsLeadLocomotive())
            {
                {
                    switch (Direction)
                    {
                        case Direction.Reverse: SetDirection(Direction.Reverse); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.Off); break;
                        case Direction.N: SetDirection(Direction.Reverse); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.Off); break;
                        case Direction.Forward: SetDirection(Direction.N); Simulator.Confirmer.Confirm(CabControl.Reverser, CabSetting.Neutral); break;
                    }
                }
            }
        }
        #endregion

        #region ThrottleController
        public void StartThrottleIncrease(float? target)
        {
            if (CruiseControl != null && target != null)
            {
                if (CruiseControl.DisableCruiseControlOnThrottleAndZeroSpeed && AbsSpeedMpS == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
                if (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce && CruiseControl.SelectedMaxAccelerationPercent == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
                if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.UseThrottleAsSpeedSelector)
                {
                    CruiseControl.SpeedRegulatorSelectedSpeedStartIncrease();
                    return;
                }
                if (CruiseControl.DisableCruiseControlOnThrottleAndZeroForceAndZeroSpeed && CruiseControl.SelectedSpeedMpS == 0 &&
                    CruiseControl.SelectedMaxAccelerationPercent == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
            }
            if (ThrottleController.CurrentValue >= ThrottleController.MaximumValue)
                return;

            if (target != null) ThrottleController.StartIncrease(target);
            else new NotchedThrottleCommand(Simulator.Log, true);

            SignalEvent(Event.ThrottleChange);
            AlerterReset(TCSEvent.ThrottleChanged);
            CommandStartTime = Simulator.ClockTime;
        }

        public void StartThrottleIncrease()
        {
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedMaxAccelerationPercent != 0
                && CruiseControl.HasIndependentThrottleDynamicBrakeLever)
                return;
            if ((CruiseControl?.SelectedMaxAccelerationPercent == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto) &&
                (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce || CruiseControl.DisableCruiseControlOnThrottleAndZeroForceAndZeroSpeed && CruiseControl.SelectedSpeedMpS == 0))
            {
                if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                if (ThrottleController.CurrentValue == 0)
                {
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
                CruiseControl.SkipThrottleDisplay = false;
            }
            var mpc = MultiPositionControllers.Where(x => x.controllerBinding == ControllerBinding.Throttle).FirstOrDefault();
            if (mpc != null)
            {
                if (!mpc.StateChanged)
                {
                    mpc.StateChanged = true;
                    mpc.DoMovement(MultiPositionController.Movement.Forward);
                }
                return;
            }
            if (CruiseControl != null && (CombinedControlType == CombinedControl.None || CruiseControl.UseThrottleInCombinedControl))
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && !CruiseControl.DynamicBrakePriority)
                {
                    CruiseControl.SpeedRegulatorMaxForceStartIncrease();
                    return;
                }
                else
                {
                    if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && !CruiseControl.DynamicBrakePriority)
                    {
                        if (!CruiseControl.UseThrottleAsSpeedSelector)
                            return;
                    }
                }
            }
            bool checkBraking = true;
            if (CruiseControl != null)
            {
                if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.UseThrottleAsSpeedSelector)
                {
                    checkBraking = false;
                }
            }
            if (DynamicBrakeController != null && DynamicBrakeIntervention >= 0 && checkBraking)
            {
                if (!(CombinedControlType == CombinedControl.ThrottleDynamic
                    || CombinedControlType == CombinedControl.ThrottleAir && TrainBrakeController.CurrentValue > 0))
                {
                    Simulator.Confirmer.Warning(CabControl.Throttle, CabSetting.Warn1);
                    return;
                }
            }

            if (CombinedControlType == CombinedControl.ThrottleDynamic && DynamicBrakeIntervention >= 0)
                StartDynamicBrakeDecrease(null);
            else if (CombinedControlType == CombinedControl.ThrottleAir && TrainBrakeController.CurrentValue > 0)
                StartTrainBrakeDecrease(null);
            else
                StartThrottleIncrease(ThrottleController.SmoothMax());
        }

        public void StopThrottleIncrease()
        {
            var mpc = MultiPositionControllers.Where(x => x.controllerBinding == ControllerBinding.Throttle).FirstOrDefault();
            if (mpc != null)
            {
                if (mpc.StateChanged)
                {
                    mpc.StateChanged = false;
                    mpc.DoMovement(MultiPositionController.Movement.Neutral);
                }
                return;
            }
            if (CruiseControl != null)
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto &&
                    !(CruiseControl.UseThrottleInCombinedControl && CruiseControl.DynamicBrakePriority))
                {
                    CruiseControl.SpeedRegulatorMaxForceStopIncrease();
                    return;
                }
                else
                {
                    if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SelectedSpeedMpS > 0)
                    {
                        CruiseControl.SpeedRegulatorSelectedSpeedStopIncrease();
                        return;
                    }
                }
            }
            AlerterReset(TCSEvent.ThrottleChanged);
            ThrottleController.StopIncrease();

            if (CombinedControlType == CombinedControl.ThrottleDynamic)
                StopDynamicBrakeDecrease();
            else if (CombinedControlType == CombinedControl.ThrottleAir)
                StopTrainBrakeDecrease();
            else if (ThrottleController.SmoothMax() != null)
                new ContinuousThrottleCommand(Simulator.Log, true, ThrottleController.CurrentValue, CommandStartTime);
        }

        public void StartThrottleDecrease(float? target)
        {
            if (CruiseControl != null)
            {
                if (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedSpeedMpS > 0)
                {
                    CruiseControl.SpeedRegulatorSelectedSpeedStartDecrease();
                    return;
                }
            }

            if (ThrottleController.CurrentValue <= ThrottleController.MinimumValue)
                return;

            if (target != null) ThrottleController.StartDecrease(target);
            else new NotchedThrottleCommand(Simulator.Log, false);

            SignalEvent(Event.ThrottleChange);
            AlerterReset(TCSEvent.ThrottleChanged);
            CommandStartTime = Simulator.ClockTime;
        }

        protected bool speedSelectorModeDecreasing = false;
        public void StartThrottleDecrease()
        {
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedMaxAccelerationPercent != 0
                && CruiseControl.HasIndependentThrottleDynamicBrakeLever)
                return;
            if ((CruiseControl?.SelectedMaxAccelerationPercent == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto) &&
                (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce || CruiseControl.DisableCruiseControlOnThrottleAndZeroForceAndZeroSpeed && CruiseControl.SelectedSpeedMpS == 0))
            {
                if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                if (ThrottleController.CurrentValue == 0)
                {
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
                CruiseControl.SkipThrottleDisplay = false;
            }
            var mpc = MultiPositionControllers.Where(x => x.controllerBinding == ControllerBinding.Throttle).FirstOrDefault();
            if (mpc != null)
            {
                if (!mpc.StateChanged)
                {
                    mpc.StateChanged = true;
                     mpc.DoMovement(MultiPositionController.Movement.Aft);
                }
                return;
            }
            if (CruiseControl != null && (CombinedControlType == CombinedControl.None || CruiseControl.UseThrottleInCombinedControl))
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && 
                    !(CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl && (CruiseControl.DynamicBrakePriority ||
                    CruiseControl.SelectedMaxAccelerationPercent == 0)))
                {
                    CruiseControl.SpeedRegulatorMaxForceStartDecrease();
                    return;
                }
                else
                {
                    if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && !CruiseControl.UseThrottleAsSpeedSelector &&
                    !(CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl && ThrottleController.CurrentValue <= 0))
                    {
                        return;
                    }
                }
            }
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedSpeedMpS > 0 && CruiseControl.UseThrottleAsSpeedSelector)
            {
                ThrottleController.CurrentValue = 1;
            }
            if (CombinedControlType == CombinedControl.ThrottleDynamic && ThrottleController.CurrentValue <= 0)
                StartDynamicBrakeIncrease(null);
            else if (CombinedControlType == CombinedControl.ThrottleAir && ThrottleController.CurrentValue <= 0)
                StartTrainBrakeIncrease(null);
            else
                StartThrottleDecrease(ThrottleController.SmoothMin());
        }

        public void StopThrottleDecrease()
        {
            var mpc = MultiPositionControllers.Where(x => x.controllerBinding == ControllerBinding.Throttle).FirstOrDefault();
            if (mpc != null)
            {
                if (mpc.StateChanged)
                {
                    mpc.StateChanged = false;
                    mpc.DoMovement(MultiPositionController.Movement.Neutral);
                }
                return;
            }
            if (CruiseControl != null)
            {
                if (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedSpeedMpS > 0)
                {
                    CruiseControl.SpeedRegulatorSelectedSpeedStopDecrease();
                    return;
                }
                else
                {
                    if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedSpeedMpS > 0)
                    {
                        speedSelectorModeDecreasing = false;
                    }
                }
                if (CombinedControlType == CombinedControl.None || CruiseControl.UseThrottleInCombinedControl)
                {
                    if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto
                        && CruiseControl.SelectedMaxAccelerationPercent > 0)
                    {
                        CruiseControl.SpeedRegulatorMaxForceStopDecrease();
                        return;
                    }
                }
            }
            AlerterReset(TCSEvent.ThrottleChanged);
            ThrottleController.StopDecrease();

            if (CombinedControlType == CombinedControl.ThrottleDynamic)
                StopDynamicBrakeIncrease();
            else if (CombinedControlType == CombinedControl.ThrottleAir)
                StopTrainBrakeIncrease();
            if (ThrottleController.SmoothMin() != null)
                new ContinuousThrottleCommand(Simulator.Log, false, ThrottleController.CurrentValue, CommandStartTime);
        }

        //Steam Heat Controller

        #region Steam heating controller

        public void StartSteamHeatIncrease(float? target)
        {
            SteamHeatController.CommandStartTime = Simulator.ClockTime;
            if (IsPlayerTrain)
                Simulator.Confirmer.ConfirmWithPerCent(CabControl.SteamHeat, CabSetting.Increase, SteamHeatController.CurrentValue * 100);
            SteamHeatController.StartIncrease(target);
            SignalEvent(Event.SteamHeatChange);
        }

        public void StopSteamHeatIncrease()
        {
            SteamHeatController.StopIncrease();
            new ContinuousSteamHeatCommand(Simulator.Log, 1, true, SteamHeatController.CurrentValue, SteamHeatController.CommandStartTime);
        }

        public void StartSteamHeatDecrease(float? target)
        {
            if (IsPlayerTrain)
                Simulator.Confirmer.ConfirmWithPerCent(CabControl.SteamHeat, CabSetting.Decrease, SteamHeatController.CurrentValue * 100);
            SteamHeatController.StartDecrease(target);
            SignalEvent(Event.SteamHeatChange);
        }

        public void StopSteamHeatDecrease()
        {
            SteamHeatController.StopDecrease();
            if (IsPlayerTrain)
                new ContinuousSteamHeatCommand(Simulator.Log, 1, false, SteamHeatController.CurrentValue, SteamHeatController.CommandStartTime);
        }

        public void SteamHeatChangeTo(bool increase, float? target)
        {
            if (increase)
            {
                if (target > SteamHeatController.CurrentValue)
                {
                    StartSteamHeatIncrease(target);
                }
            }
            else
            {
                if (target < SteamHeatController.CurrentValue)
                {
                    StartSteamHeatDecrease(target);
                }
            }
        }

        public void SetSteamHeatValue(float value)
        {
            var controller = SteamHeatController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new ContinuousSteamHeatCommand(Simulator.Log, 1, change > 0, controller.CurrentValue, Simulator.GameTime);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.UpdateWithPerCent(CabControl.SteamHeat, oldValue < controller.IntermediateValue ? CabSetting.Increase : CabSetting.Decrease, controller.CurrentValue * 100);
        }

        public void ToggleWaterScoop()
        {
            if (Simulator.PlayerLocomotive == this)
            {
                WaterScoopDown = !WaterScoopDown;
                SignalEvent(Event.WaterScoopRaiseLower);
                if (WaterScoopDown)
                {
                    IsWaterScoopDown = true; // Set flag to potentially fill from water trough
                }
                else
                {
                    IsWaterScoopDown = false;
                    WaterScoopOverTroughFlag = false; // Reset flags so that message will come up again
                    WaterScoopNotFittedFlag = false;
                    WaterScoopSlowSpeedFlag = false;
                    WaterScoopDirectionFlag = false;
                }
                    Simulator.Confirmer.Confirm(CabControl.WaterScoop, WaterScoopDown? CabSetting.On : CabSetting.Off);
            }
        }

        #endregion

        /// <summary>
        /// Used by commands to start a continuous adjustment.
        /// </summary>
        public void ThrottleChangeTo(bool increase, float? target)
        {
            if ((CruiseControl != null && target != 0 && CruiseControl.SelectedMaxAccelerationPercent <= 0
                && ThrottleController.CurrentValue == 0 && DynamicBrakeController.CurrentValue == 0) && 
                (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce || CruiseControl.DisableCruiseControlOnThrottleAndZeroForceAndZeroSpeed && CruiseControl.SelectedSpeedMpS == 0))
            {
                if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
            }

            if (increase)
            {
                if (target > ThrottleController.CurrentValue)
                {
                    StartThrottleIncrease(target);
                }
            }
            else
            {
                if (target < ThrottleController.CurrentValue)
                {
                    StartThrottleDecrease(target);
                }
            }
        }

        /// <summary>
        /// Used by commands to make a single adjustment.
        /// </summary>
        public void AdjustNotchedThrottle(bool increase)
        {
            if (increase)
            {
                ThrottleController.StartIncrease();
                ThrottleController.StopIncrease();
            }
            else
            {
                ThrottleController.StartDecrease();
                ThrottleController.StopDecrease();
            }
            Simulator.Confirmer.ConfirmWithPerCent(CabControl.Throttle, ThrottleController.CurrentValue * 100);
        }

        public void SetThrottleValue(float value)
        {
            if (CruiseControl != null)
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    CruiseControl.SetMaxForcePercent((float)Math.Round(value * 100, 0));
                    if (!CruiseControl.UseThrottleInCombinedControl) ThrottleController.SetValue(value);
                    return;
                }
                if (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    CruiseControl.SetSpeed((float)Math.Round((MpS.ToKpH(MaxSpeedMpS) / 100) * value * 100, 0));
                    return;
                }
            }
            var controller = ThrottleController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new ContinuousThrottleCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
                SignalEvent(Event.ThrottleChange);
                AlerterReset(TCSEvent.ThrottleChanged);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.UpdateWithPerCent(
                    this is MSTSSteamLocomotive ? CabControl.Regulator : CabControl.Throttle,
                    oldValue < controller.IntermediateValue ? CabSetting.Increase : CabSetting.Decrease,
                    controller.CurrentValue * 100);
        }

        public void SetThrottlePercent(float percent)
        {
            if (CruiseControl != null)
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                {
                    CruiseControl.SetMaxForcePercent(percent);
                    if (!CruiseControl.UseThrottleInCombinedControl) ThrottleController.SetPercent(percent);
                    return;
                }
                else if (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
                    CruiseControl.SetSpeed(MpS.FromMpS(percent * MaxSpeedMpS / 100, !CruiseControl.SpeedIsMph));
                else
                    ThrottleController.SetPercent(percent);
            }
            else
                ThrottleController.SetPercent(percent);
        }

        public void SetThrottlePercentWithSound(float percent)
        {
            var oldThrottlePercent = ThrottleController.CurrentValue * 100;
            SetThrottlePercent(percent);
            if (Math.Abs(oldThrottlePercent - ThrottleController.CurrentValue * 100) > 2)
                SignalEvent(Event.ThrottleChange);
        }

        public void ThrottleToZero()
        {
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedMaxAccelerationPercent != 0
                && CruiseControl.HasIndependentThrottleDynamicBrakeLever)
                return;
            if ((CruiseControl?.SelectedMaxAccelerationPercent == 0 && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto) &&
                (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce || CruiseControl.DisableCruiseControlOnThrottleAndZeroForceAndZeroSpeed && CruiseControl.SelectedSpeedMpS == 0))
            {
                if (CruiseControl.ZeroSelectedSpeedWhenPassingToThrottleMode) CruiseControl.SetSpeed(0);
                if (ThrottleController.CurrentValue == 0)
                {
                    CruiseControl.SpeedRegMode = CruiseControl.SpeedRegulatorMode.Manual;
                }
                CruiseControl.SkipThrottleDisplay = false;
            }
            if (CruiseControl != null && (CombinedControlType == CombinedControl.None || CruiseControl.UseThrottleInCombinedControl))
            {
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto &&
                    !(CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl && CruiseControl.DynamicBrakePriority))
                {
                    CruiseControl.SpeedRegulatorMaxForceStartDecrease();
                    return;
                }
                else
                {
                    if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && !CruiseControl.UseThrottleAsSpeedSelector &&
                    !(CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl && ThrottleController.CurrentValue <= 0))
                    {
                        return;
                    }
                }
            }
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedSpeedMpS > 0 && CruiseControl.UseThrottleAsSpeedSelector)
            {
                ThrottleController.CurrentValue = 1;
            }
            if (CombinedControlType == CombinedControl.ThrottleDynamic && ThrottleController.CurrentValue <= 0)
                StartDynamicBrakeIncrease(null);
            else if (CombinedControlType == CombinedControl.ThrottleAir && ThrottleController.CurrentValue <= 0)
                StartTrainBrakeIncrease(null);
            else
                StartThrottleToZero(0.0f);
        }

        public void StartThrottleToZero(float? target)
        {
            if (ThrottleController.CurrentValue <= ThrottleController.MinimumValue)
                return;

            ThrottleController.StartDecrease(target, true);
            if (ThrottleController.NotchCount() <= 0) SignalEvent(Event.ThrottleChange);
            AlerterReset(TCSEvent.ThrottleChanged);
            CommandStartTime = Simulator.ClockTime;
        }

        /// <summary>
        /// Returns the position of the throttle handle considering 
        /// whether it is used for cruise control or not
        /// </summary>
        /// <param name="intermediateValue">Whather asking for intermediate (for mouse operation) or notched (for displaying) value.</param>
        /// <returns>Combined position into 0-1 range</returns>
        public float GetThrottleHandleValue(float data)
        {
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.SelectedMaxAccelerationPercent != 0
                && CruiseControl.HasIndependentThrottleDynamicBrakeLever)
                return ThrottleController.CurrentValue;
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.UseThrottleAsForceSelector)
                return CruiseControl.SelectedMaxAccelerationPercent / 100;
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.UseThrottleAsSpeedSelector)
                return CruiseControl.SelectedSpeedMpS / MaxSpeedMpS;


            if (CruiseControl == null || CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Manual)
                return data;
            else
                return ThrottleController.CurrentValue;

        }

        #endregion

        #region CombinedHandle
        /// <summary>
        /// Determines which sub-control of combined handle is to be set when receiving a combined value.
        /// Combined value is in 0-1 range, where arrangement is [[1--throttle--0]split[0--dynamic|airbrake--1]].
        /// </summary>
        public void SetCombinedHandleValue(float value)
        {
            bool ccUseCombinedControl = CruiseControl != null && (CruiseControl.UseThrottleAsForceSelector || CruiseControl.UseThrottleAsSpeedSelector ) && CruiseControl.UseThrottleInCombinedControl; 
            if (CombinedControlType == CombinedControl.ThrottleDynamic && DynamicBrakeIntervention >= 0 &&
                !(ccUseCombinedControl && !CruiseControl.DynamicBrakePriority && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto))
            {
                if (DynamicBrakeController.CurrentValue == 0 && value < CombinedControlSplitPosition)
                    DynamicBrakeChangeActiveState(false);
                else if (DynamicBrakeIntervention > -1)
                    SetDynamicBrakeValue((MathHelper.Clamp(value, CombinedControlSplitPosition, 1) - CombinedControlSplitPosition) / (1 - CombinedControlSplitPosition));
            }
            else if (CombinedControlType == CombinedControl.ThrottleAir && TrainBrakeController.CurrentValue > 0)
            {
                SetTrainBrakeValue((MathHelper.Clamp(value, CombinedControlSplitPosition, 1) - CombinedControlSplitPosition) / (1 - CombinedControlSplitPosition));
            }
            else
            {
                bool canBrake = ThrottleController.CurrentValue == 0;
                if (ccUseCombinedControl && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto) canBrake = (CruiseControl.UseThrottleAsForceSelector && CruiseControl.SelectedMaxAccelerationPercent == 0) || (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.SelectedSpeedMpS == 0);
                if (CombinedControlType == CombinedControl.ThrottleDynamic && canBrake && value > CombinedControlSplitPosition)
                {
                    DynamicBrakeChangeActiveState(true);
                    if (CruiseControl != null && CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl) CruiseControl.DynamicBrakePriority = true;
                }
                else if (CombinedControlType == CombinedControl.ThrottleAir && canBrake && value > CombinedControlSplitPosition)
                    SetTrainBrakeValue((MathHelper.Clamp(value, CombinedControlSplitPosition, 1) - CombinedControlSplitPosition) / (1 - CombinedControlSplitPosition));
                else if (DynamicBrakeIntervention < 0 ||
                    (CruiseControl != null && !CruiseControl.DynamicBrakePriority && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto))
                    SetThrottleValue(1 - MathHelper.Clamp(value, 0, CombinedControlSplitPosition) / CombinedControlSplitPosition);
            }
        }

        /// <summary>
        /// Determines which sub-control of combined handle is active (based on its type), 
        /// and returns the overall position considering the split position. 
        /// </summary>
        /// <param name="intermediateValue">Whather asking for intermediate (for mouse operation) or notched (for displaying) value.</param>
        /// <returns>Combined position into 0-1 range, where arrangement is [[1--throttle--0]split[0--dynamic|airbrake--1]]</returns>
        public float GetCombinedHandleValue(bool intermediateValue)
        {
            if (CruiseControl?.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto)
            {
                if (CruiseControl.SelectedMaxAccelerationPercent != 0 && CruiseControl.HasIndependentThrottleDynamicBrakeLever)
                    return CombinedControlSplitPosition;
                if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.UseThrottleInCombinedControl && !CruiseControl.DynamicBrakePriority
                    && CombinedControlType == CombinedControl.ThrottleDynamic)
                    return CombinedControlSplitPosition * (1 - (CruiseControl.SelectedMaxAccelerationPercent / 100));
                if (CruiseControl.UseThrottleAsSpeedSelector && CruiseControl.UseThrottleInCombinedControl)
                {
                    if (!CruiseControl.DynamicBrakePriority && CombinedControlType == CombinedControl.ThrottleDynamic
                        || !CruiseControl.TrainBrakePriority && CombinedControlType == CombinedControl.ThrottleAir)
                    return CombinedControlSplitPosition * (1 - (CruiseControl.SelectedSpeedMpS / MaxSpeedMpS));
                }
            }

            if (CombinedControlType == CombinedControl.ThrottleDynamic && DynamicBrakeIntervention >= 0)
            {
                if (CruiseControl != null)
                {
                    if (CruiseControl.SkipThrottleDisplay && !CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl)
                    {
                        return CombinedControlSplitPosition;
                    }
                    else
                    {
                        return CombinedControlSplitPosition + (1 - CombinedControlSplitPosition) * (intermediateValue ? DynamicBrakeController.IntermediateValue : DynamicBrakeController.CurrentValue);
                    }
                }
                else
                {
                    return CombinedControlSplitPosition + (1 - CombinedControlSplitPosition) * (intermediateValue ? DynamicBrakeController.IntermediateValue : DynamicBrakeController.CurrentValue);
                }
            }
            else if (CombinedControlType == CombinedControl.ThrottleAir && TrainBrakeController.CurrentValue > 0)
                return CombinedControlSplitPosition + (1 - CombinedControlSplitPosition) * (intermediateValue ? TrainBrakeController.IntermediateValue : TrainBrakeController.CurrentValue);
            else if (CruiseControl == null)
                return CombinedControlSplitPosition * (1 - (intermediateValue ? ThrottleController.IntermediateValue : ThrottleController.CurrentValue));
            else if (CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Manual)
                return CombinedControlSplitPosition * (1 - (intermediateValue ? ThrottleController.IntermediateValue : ThrottleController.CurrentValue));
            else if (CruiseControl.UseThrottleAsSpeedSelector)
                return CombinedControlSplitPosition * (1 - (CruiseControl.SelectedSpeedMpS / MaxSpeedMpS));
            else if (CruiseControl.UseThrottleAsForceSelector && CruiseControl.UseThrottleInCombinedControl)
                return CombinedControlSplitPosition * (1 - (CruiseControl.SelectedMaxAccelerationPercent / 100));
            else
                return CombinedControlSplitPosition;

        }
        #endregion

        #region GearBoxController
        public virtual void ChangeGearUp()
        {

        }

        public virtual void StartGearBoxIncrease()
        {
            if (GearBoxController != null)
            {

                if (this is MSTSDieselLocomotive)
                {
                    var dieselloco = this as MSTSDieselLocomotive;

                    if (dieselloco.DieselTransmissionType == MSTSDieselLocomotive.DieselTransmissionTypes.Mechanic)
                    {

                        if (dieselloco.DieselEngines[0].GearBox.GearBoxType != TypesGearBox.C)
                        {
                            GearBoxController.StartIncrease();
                            Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Increase, dieselloco.DieselEngines[0].GearBox.GearIndication);
                            AlerterReset(TCSEvent.GearBoxChanged);
                            SignalGearBoxChangeEvents();
                            dieselloco.DieselEngines[0].GearBox.clutchOn = false;
                            dieselloco.DieselEngines[0].GearBox.ManualGearChange = true;

                        }
                        else if (dieselloco.DieselEngines[0].GearBox.GearBoxType == TypesGearBox.C)
                        {

                            if (ThrottlePercent == 0)
                            {
                                GearBoxController.StartIncrease();
                                Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Increase, dieselloco.DieselEngines[0].GearBox.GearIndication );
                                AlerterReset(TCSEvent.GearBoxChanged);
                                SignalGearBoxChangeEvents();
                                dieselloco.DieselEngines[0].GearBox.clutchOn = false;
                            }
                            else
                            {
                                Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("Throttle must be reduced to Idle before gear change can happen."));
                            }
                        }
                    }
                    else  // Legacy operation
                    {
                        GearBoxController.StartIncrease();
                        Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Increase, GearBoxController.CurrentNotch);
                        AlerterReset(TCSEvent.GearBoxChanged);
                        SignalGearBoxChangeEvents();
                    }
                }
            }

            ChangeGearUp();
        }

        public virtual void StopGearBoxIncrease()
        {
            if (GearBoxController != null)
            {
                GearBoxController.StopIncrease();
            }
        }

        public virtual void ChangeGearDown()
        {
            
        }

        public virtual void StartGearBoxDecrease()
        {
            if (GearBoxController != null)
            {
                if (this is MSTSDieselLocomotive)
                {
                    var dieselloco = this as MSTSDieselLocomotive;

                    if (dieselloco.DieselTransmissionType == MSTSDieselLocomotive.DieselTransmissionTypes.Mechanic)
                    {

                        if (dieselloco.DieselEngines[0].GearBox.GearBoxType != TypesGearBox.C)
                        {
                            GearBoxController.StartDecrease();
                            Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Decrease, dieselloco.DieselEngines[0].GearBox.GearIndication);
                            AlerterReset(TCSEvent.GearBoxChanged);
                            SignalGearBoxChangeEvents();
                            dieselloco.DieselEngines[0].GearBox.clutchOn = false;
                            dieselloco.DieselEngines[0].GearBox.ManualGearChange = true;
                        }
                        else if (dieselloco.DieselEngines[0].GearBox.GearBoxType == TypesGearBox.C)
                        {
                            if (ThrottlePercent == 0)
                            {
                                GearBoxController.StartDecrease();
                                Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Decrease, dieselloco.DieselEngines[0].GearBox.GearIndication);
                                AlerterReset(TCSEvent.GearBoxChanged);
                                SignalGearBoxChangeEvents();
                                dieselloco.DieselEngines[0].GearBox.clutchOn = false;
                            }
                            else
                            {
                                Simulator.Confirmer.Message(ConfirmLevel.Warning, Simulator.Catalog.GetString("Throttle must be reduced to Idle before gear change can happen."));
                            }
                        }
                    }
                    else // Legacy operation
                    {
                        GearBoxController.StartDecrease();
                        Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Decrease, GearBoxController.CurrentNotch);
                        AlerterReset(TCSEvent.GearBoxChanged);
                        SignalGearBoxChangeEvents();

                    }
                }
            }
            ChangeGearDown();
        }

        public virtual void StopGearBoxDecrease()
        {
            if (GearBoxController != null)
            {
                GearBoxController.StopDecrease();
            }
        }

        /// <summary>
        /// Trigger sound events when the gearbox increases or decreases.
        /// </summary>
        private void SignalGearBoxChangeEvents()
        {
            // Only activate sound event if notch has actually changed
            if (GearBoxController.CurrentNotch != PreviousGearBoxNotch)
            {
                switch (GearBoxController.CurrentNotch)
                {
                    case 0:
                        SignalEvent(Event.GearPosition0);
                        break;
                    case 1:
                        SignalEvent(Event.GearPosition1);
                        break;
                    case 2:
                        SignalEvent(Event.GearPosition2);
                        break;
                    case 3:
                        SignalEvent(Event.GearPosition3);
                        break;
                    case 4:
                        SignalEvent(Event.GearPosition4);
                        break;
                    case 5:
                        SignalEvent(Event.GearPosition5);
                        break;
                    case 6:
                        SignalEvent(Event.GearPosition6);
                        break;
                    case 7:
                        SignalEvent(Event.GearPosition7);
                        break;
                    default:
                        SignalEvent(Event.GearPosition8);
                        break;
                }
                PreviousGearBoxNotch = GearBoxController.CurrentNotch; // Update previous value for next time around
            }
        }

        public void SetGearBoxValue(float value) // control for cabview
        {
            var controller = GearBoxController;
            var oldValue = controller.CurrentValue;
            var change = controller.SetValue(value);
            var dieselloco = this as MSTSDieselLocomotive;
            if (change != 0)
            {
                //new GearBoxCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
                SignalEvent(change > 0 ? Event.GearUp : Event.GearDown);
                AlerterReset(TCSEvent.GearBoxChanged);
            }

            if (controller.CurrentValue > oldValue)
            {
                Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Increase, GearBoxController.CurrentNotch);
                if (dieselloco != null)
                    dieselloco.DieselEngines[0].GearBox.ManualGearUp = true;

            }
            else if (controller.CurrentValue < oldValue)
            {
                Simulator.Confirmer.ConfirmWithPerCent(CabControl.GearBox, CabSetting.Decrease, GearBoxController.CurrentNotch);
                if (dieselloco != null)
                    dieselloco.DieselEngines[0].GearBox.ManualGearDown = true;
            }
        }
        #endregion

        #region TrainBrakeController
        public void StartTrainBrakeIncrease(float? target)
        {
            if (CombinedControlType == CombinedControl.ThrottleAir)
                ThrottleController.SetValue(0);

            AlerterReset(TCSEvent.TrainBrakeChanged);
            TrainBrakeController.StartIncrease(target);
            TrainBrakeController.CommandStartTime = Simulator.ClockTime;
            if (CruiseControl != null && (CruiseControl.TrainBrakeCommandHasPriorityOverCruiseControl || CruiseControl.TrainBrakeCommandHasPriorityOverAcceleratingCruiseControl))
            {
                CruiseControl.TrainBrakePriority = true;
            }
            Simulator.Confirmer.Confirm(CabControl.TrainBrake, CabSetting.Increase, GetTrainBrakeStatus());
            SignalEvent(Event.TrainBrakeChange);
        }

        public void StopTrainBrakeIncrease()
        {
            AlerterReset(TCSEvent.TrainBrakeChanged);
            TrainBrakeController.StopIncrease();
            new TrainBrakeCommand(Simulator.Log, true, TrainBrakeController.CurrentValue, TrainBrakeController.CommandStartTime);
        }

        public void StartTrainBrakeDecrease(float? target, bool toZero = false)
        {
            AlerterReset(TCSEvent.TrainBrakeChanged);
            TrainBrakeController.StartDecrease(target, toZero);
            TrainBrakeController.CommandStartTime = Simulator.ClockTime;
            Simulator.Confirmer.Confirm(CabControl.TrainBrake, CabSetting.Decrease, GetTrainBrakeStatus());
            SignalEvent(Event.TrainBrakeChange);
        }

        public void StopTrainBrakeDecrease()
        {
            AlerterReset(TCSEvent.TrainBrakeChanged);
            TrainBrakeController.StopDecrease();
            new TrainBrakeCommand(Simulator.Log, false, TrainBrakeController.CurrentValue, TrainBrakeController.CommandStartTime);
        }

        /// <summary>
        /// Used by commands to start a continuous adjustment.
        /// </summary>
        /// <param name="increase"></param>
        /// <param name="target"></param>
        public void TrainBrakeChangeTo(bool increase, float? target)
        {  // Need a better way to express brake as a single number?
            if (increase)
            {
                if (target > TrainBrakeController.CurrentValue)
                {
                    StartTrainBrakeIncrease(target);
                }
            }
            else
            {
                if (target < TrainBrakeController.CurrentValue)
                {
                    StartTrainBrakeDecrease(target);
                }
            }
        }

        //Debrief Eval
        public static int DbfEvalFullTrainBrakeUnder8kmh = 0;
        public bool ldbfevalfulltrainbrakeunder8kmh = false;

        public override string GetTrainBrakeStatus()
        {
            var train = Simulator.PlayerLocomotive.Train;//Debrief Eval
            string s = TrainBrakeController.GetStatus();
 

            if (s == "Emergency" && train.LeadLocomotive != null && !ldbfevalfulltrainbrakeunder8kmh && train.LeadLocomotive.IsPlayerTrain && Math.Abs(train.SpeedMpS) < 2.22222)
            {
                
                DbfEvalFullTrainBrakeUnder8kmh++;
                ldbfevalfulltrainbrakeunder8kmh = true;
                train.DbfEvalValueChanged = true;//Debrief eval
            }
            if (s != "Emergency" && ldbfevalfulltrainbrakeunder8kmh)
                ldbfevalfulltrainbrakeunder8kmh = false;

            TrainCar lastCar = Train.Cars[Train.Cars.Count - 1];
            if (lastCar == this)
                lastCar = Train.Cars[0];
            s += BrakeSystem.GetFullStatus(lastCar.BrakeSystem, BrakeSystemPressureUnits);
            return s;
        }

        public void SetTrainBrakeValue(float value)
        {
            var controller = TrainBrakeController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new TrainBrakeCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
                if (change > 0 && CruiseControl != null && ( CruiseControl.TrainBrakeCommandHasPriorityOverCruiseControl || CruiseControl.TrainBrakeCommandHasPriorityOverAcceleratingCruiseControl)) 
                    CruiseControl.TrainBrakePriority = true;
                SignalEvent(Event.TrainBrakeChange);
                AlerterReset(TCSEvent.TrainBrakeChanged);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.Update(CabControl.TrainBrake, oldValue < controller.IntermediateValue ? CabSetting.Increase : CabSetting.Decrease, GetTrainBrakeStatus());
        }

        public void SetTrainBrakePercent(float percent)
        {
            // Insure we have TrainBrakeController ; some vehicles do not
            // such as Hy-rail truck
            // if (HasTrainBrake)
            if (TrainBrakeController.IsValid())
                TrainBrakeController.SetPercent(percent);
        }
        #endregion

        #region EngineBrakeController
        public void StartEngineBrakeIncrease(float? target)
        {
            AlerterReset(TCSEvent.EngineBrakeChanged);
            if (EngineBrakeController == null)
                return;

            if (CruiseControl != null) CruiseControl.EngineBrakePriority = true;
            EngineBrakeController.StartIncrease(target);
            Simulator.Confirmer.Confirm(CabControl.EngineBrake, CabSetting.Increase, GetEngineBrakeStatus());
            SignalEvent(Event.EngineBrakeChange);
        }

        /// <summary>
        /// Ends change of brake value.
        /// </summary>
        public void StopEngineBrakeIncrease()
        {
            if (EngineBrakeController == null)
                return;

            AlerterReset(TCSEvent.EngineBrakeChanged);
            EngineBrakeController.StopIncrease();
            new EngineBrakeCommand(Simulator.Log, true, EngineBrakeController.CurrentValue, EngineBrakeController.CommandStartTime);
        }

        public void StartEngineBrakeDecrease(float? target)
        {
            if (EngineBrakeController == null)
                return;

            AlerterReset(TCSEvent.EngineBrakeChanged);
            EngineBrakeController.StartDecrease(target);
            EngineBrakeController.CommandStartTime = Simulator.ClockTime; // Remember when the command was issued
            Simulator.Confirmer.Confirm(CabControl.EngineBrake, CabSetting.Increase, GetEngineBrakeStatus());
            SignalEvent(Event.EngineBrakeChange);
        }

        /// <summary>
        /// Ends change of brake value.
        /// </summary>
        public void StopEngineBrakeDecrease()
        {
            if (EngineBrakeController == null)
                return;

            AlerterReset(TCSEvent.EngineBrakeChanged);
            EngineBrakeController.StopDecrease();
            new EngineBrakeCommand(Simulator.Log, false, EngineBrakeController.CurrentValue, EngineBrakeController.CommandStartTime);
        }

        public void EngineBrakeChangeTo(bool increase, float? target)
        {  // Need a better way to express brake as a single number.
            if (increase)
            {
                if (target > EngineBrakeController.CurrentValue)
                {
                    StartEngineBrakeIncrease(target);
                }
            }
            else
            {
                if (target < EngineBrakeController.CurrentValue)
                {
                    StartEngineBrakeDecrease(target);
                }
            }
        }

        public void SetEngineBrakeValue(float value)
        {
            var controller = EngineBrakeController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new EngineBrakeCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
                SignalEvent(Event.EngineBrakeChange);
                AlerterReset(TCSEvent.EngineBrakeChanged);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.Update(CabControl.EngineBrake, oldValue < controller.IntermediateValue ? CabSetting.Increase : CabSetting.Decrease, GetEngineBrakeStatus());
        }

        public void SetEngineBrakePercent(float percent)
        {
            if (EngineBrakeController == null)
                return;
            EngineBrakeController.SetPercent(percent);
        }

        public override string GetEngineBrakeStatus()
        {
            if (EngineBrakeController == null)
                return null;
            // If brake type is only a state, and no numerical fraction application is displayed in the HUD, then display Brake Cylinder (BC) pressure
            if (String.IsNullOrEmpty(EngineBrakeController.GetStateFractionScripted())) // Test to see if a brake state only is present without a fraction of application, if no fraction display BC pressure
            {
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    if (SteamEngineBrakeFitted)
                    {
                        const float percentageConversion = 100;
                        return string.Format("{0} {1}%", EngineBrakeController.GetStatus(), percentageConversion * EngineBrakeController.CurrentValue);  // Display for steam brake
                    }
                    else
                    {
                        return string.Format("{0} BC {1}", EngineBrakeController.GetStatus(), FormatStrings.FormatPressure(Vac.FromPress(Train.HUDLocomotiveBrakeCylinderPSI), PressureUnit.InHg, PressureUnit.InHg, true)); // display for vacuum brakes
                    }
                }
                else
                {
                    return string.Format("{0} BC {1} {2}", EngineBrakeController.GetStatus(), FormatStrings.FormatPressure(Train.HUDLocomotiveBrakeCylinderPSI, PressureUnit.PSI, MainPressureUnit, true), BailOff ? " BailOff" : "");
                }

                // Fraction not found so display BC                
            }
            else
            {
                if ((BrakeSystem is VacuumSinglePipe))
                {
                    return string.Format("{0}", EngineBrakeController.GetStatus());  // Fraction found so don't display BC
                }
                else
                {
                    return string.Format("{0}{1}", EngineBrakeController.GetStatus(), BailOff ? " BailOff" : "");  // Fraction found so don't display BC
                }
            }
        }
        #endregion

        #region BrakemanBrakeController

        public void StartBrakemanBrakeIncrease(float? target)
        {
            AlerterReset(TCSEvent.BrakemanBrakeChanged);
            if (BrakemanBrakeController == null)
                return;

            BrakemanBrakeController.StartIncrease(target);
            Simulator.Confirmer.Confirm(CabControl.BrakemanBrake, CabSetting.Increase, GetBrakemanBrakeStatus());
//            SignalEvent(Event.EngineBrakeChange);
        }

        /// <summary>
        /// Ends change of brake value.
        /// </summary>
        public void StopBrakemanBrakeIncrease()
        {
            if (BrakemanBrakeController == null)
                return;

         //   AlerterReset(TCSEvent.BrakemanBrakeChanged);
            BrakemanBrakeController.StopIncrease();
            new BrakemanBrakeCommand(Simulator.Log, true, BrakemanBrakeController.CurrentValue, BrakemanBrakeController.CommandStartTime);
        }

        public void StartBrakemanBrakeDecrease(float? target)
        {
            if (BrakemanBrakeController == null)
                return;

            AlerterReset(TCSEvent.BrakemanBrakeChanged);
            BrakemanBrakeController.StartDecrease(target);
            BrakemanBrakeController.CommandStartTime = Simulator.ClockTime; // Remember when the command was issued
            Simulator.Confirmer.Confirm(CabControl.BrakemanBrake, CabSetting.Increase, GetBrakemanBrakeStatus());
         //   SignalEvent(Event.BrakemanBrakeChange);
        }

        /// <summary>
        /// Ends change of brake value.
        /// </summary>
        public void StopBrakemanBrakeDecrease()
        {
            if (BrakemanBrakeController == null)
                return;

            AlerterReset(TCSEvent.BrakemanBrakeChanged);
            BrakemanBrakeController.StopDecrease();
            new BrakemanBrakeCommand(Simulator.Log, false, BrakemanBrakeController.CurrentValue, BrakemanBrakeController.CommandStartTime);
        }

        public void BrakemanBrakeChangeTo(bool increase, float? target)
        {  // Need a better way to express brake as a single number.
            if (increase)
            {
                if (target > BrakemanBrakeController.CurrentValue)
                {
                    StartBrakemanBrakeIncrease(target);
                }
            }
            else
            {
                if (target<BrakemanBrakeController.CurrentValue)
                {
                    StartBrakemanBrakeDecrease(target);
                }
            }
        }

        public void SetBrakemanBrakeValue(float value)
        {
            var controller = BrakemanBrakeController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new BrakemanBrakeCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
             //   SignalEvent(Event.BrakemanBrakeChange);
                AlerterReset(TCSEvent.BrakemanBrakeChanged);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.Update(CabControl.BrakemanBrake, oldValue<controller.IntermediateValue? CabSetting.Increase : CabSetting.Decrease, GetBrakemanBrakeStatus());
        }

        public void SetBrakemanBrakePercent(float percent)
        {
            if (BrakemanBrakeController == null)
                return;
            BrakemanBrakeController.SetPercent(percent);
        }

        public override string GetBrakemanBrakeStatus()
        {
            if (BrakemanBrakeController == null)
                return null;
            return string.Format("{0}", BrakemanBrakeController.GetStatus());
        }

    #endregion

    #region DynamicBrakeController
    public void StartDynamicBrakeIncrease(float? target)
        {
            if (Direction == Direction.N)
            {
                Simulator.Confirmer.Warning(CabControl.DynamicBrake, CabSetting.Warn1);
                return;
            }
            AlerterReset(TCSEvent.DynamicBrakeChanged);
            if (CruiseControl != null && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && (CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl ||
                (CruiseControl.DisableCruiseControlOnThrottleAndZeroForce && CruiseControl.SelectedMaxAccelerationPercent == 0)))
            {
                ThrottlePercent = 0;
                CruiseControl.DynamicBrakePriority = true;
            }
            if (!CanUseDynamicBrake())
                return;

            if (DynamicBrakeIntervention < 0)
            {
                DynamicBrakeChangeActiveState(true);
            }
            else if (DynamicBrake || !DynamicBrakeControllerSetupLock)
            {
                SignalEvent(Event.DynamicBrakeChange);
                DynamicBrakeController.StartIncrease(target);
                if (!HasSmoothStruc)
                {
                    StopDynamicBrakeIncrease();
                    Simulator.Confirmer.ConfirmWithPerCent(CabControl.DynamicBrake, DynamicBrakeController.CurrentValue * 100);
                }
            }
        }

        public void StopDynamicBrakeIncrease()
        {
            AlerterReset(TCSEvent.DynamicBrakeChanged);
            if (CanUseDynamicBrake())
            {
                DynamicBrakeController.StopIncrease();
                new DynamicBrakeCommand(Simulator.Log, true, DynamicBrakeController.CurrentValue, DynamicBrakeController.CommandStartTime);
            }
        }

        public void StartDynamicBrakeDecrease(float? target)
        {
            if (Direction == Direction.N)
            {
                Simulator.Confirmer.Warning(CabControl.DynamicBrake, CabSetting.Warn1);
                return;
            }
            AlerterReset(TCSEvent.DynamicBrakeChanged);
            if (!CanUseDynamicBrake())
                return;

            if (DynamicBrakeIntervention <= 0)
            {
                DynamicBrakeChangeActiveState(false);
            }
            else if (DynamicBrake || !DynamicBrakeControllerSetupLock)
            {
                SignalEvent(Event.DynamicBrakeChange);
                DynamicBrakeController.StartDecrease(target);
                if (!HasSmoothStruc)
                {
                    StopDynamicBrakeDecrease();
                    Simulator.Confirmer.ConfirmWithPerCent(CabControl.DynamicBrake, DynamicBrakeController.CurrentValue * 100);
                }
            }
        }

        public void StopDynamicBrakeDecrease()
        {
            AlerterReset(TCSEvent.DynamicBrakeChanged);
            if (CanUseDynamicBrake())
            {
                DynamicBrakeController.StopDecrease();
                new DynamicBrakeCommand(Simulator.Log, false, DynamicBrakeController.CurrentValue, DynamicBrakeController.CommandStartTime);
            }
        }

        public void DynamicBrakeChangeTo(bool increase, float? target)
        {  // Need a better way to express brake as a single number.
            if (increase)
            {
                if (target > DynamicBrakeController.CurrentValue)
                {
                    StartDynamicBrakeIncrease(target);
                }
            }
            else
            {
                if (target < DynamicBrakeController.CurrentValue)
                {
                    StartDynamicBrakeDecrease(target);
                }
            }
        }

        public void SetDynamicBrakeValue(float value)
        {
            if (DynamicBrakeIntervention < 0 && ThrottleController.CurrentValue == 0 && value > 0.05f)
            {
                DynamicBrakeChangeActiveState(true);
                if (CruiseControl != null && CruiseControl.SpeedRegMode == CruiseControl.SpeedRegulatorMode.Auto && CruiseControl.DynamicBrakeCommandHasPriorityOverCruiseControl)
                {
                    CruiseControl.DynamicBrakePriority = true;
                }
            }
            if (DynamicBrakeIntervention >= 0 && DynamicBrakeController.CurrentValue == 0 && value < -0.05f)
            {
                DynamicBrakeChangeActiveState(false);
                return;
            }
            if ((!DynamicBrake && DynamicBrakeControllerSetupLock) || CruiseControl != null && CruiseControl.UseThrottleAsForceSelector && !CruiseControl.DynamicBrakePriority && !CruiseControl.UseThrottleInCombinedControl)
                return;

            var controller = DynamicBrakeController;
            var oldValue = controller.IntermediateValue;
            var change = controller.SetValue(value);
            if (change != 0)
            {
                new DynamicBrakeCommand(Simulator.Log, change > 0, controller.CurrentValue, Simulator.ClockTime);
                SignalEvent(Event.DynamicBrakeChange);
                AlerterReset(TCSEvent.DynamicBrakeChanged);
            }
            if (oldValue != controller.IntermediateValue)
                Simulator.Confirmer.UpdateWithPerCent(CabControl.DynamicBrake, oldValue < controller.IntermediateValue ? CabSetting.Increase : CabSetting.Decrease, DynamicBrakeController.CurrentValue * 100);
        }

        public void SetDynamicBrakePercent(float percent)
        {
            if (Direction == Direction.N)
            {
                Simulator.Confirmer.Warning(CabControl.DynamicBrake, CabSetting.Warn1);
                return;
            }
            if (!CanUseDynamicBrake())
                return;
            DynamicBrakeController.SetPercent(percent);
            DynamicBrakeChangeActiveState(percent >= 0);
        }

        public void SetDynamicBrakePercentWithSound(float percent)
        {
            if (Direction == Direction.N)
            {
                Simulator.Confirmer.Warning(CabControl.DynamicBrake, CabSetting.Warn1);
                return;
            }
            if (!CanUseDynamicBrake())
                return;
            var oldDynamicBrakePercent = DynamicBrakeController.CurrentValue * 100;
            SetDynamicBrakePercent(percent);
            if (Math.Abs(oldDynamicBrakePercent - DynamicBrakeController.CurrentValue * 100) > 2)
                SignalEvent(Event.DynamicBrakeChange);
        }

        public void DynamicBrakeChangeActiveState(bool toState)
        {
            if (toState && DynamicBrakeIntervention < 0)
            {
                DynamicBrakeIntervention = 0;
                DynamicBrakeController.CommandStartTime = Simulator.ClockTime;
                StopDynamicBrakeIncrease();
            }
            else if (!toState && DynamicBrakeIntervention > -1)
            {
                DynamicBrakeIntervention = -1;
                DynamicBrakeController.CommandStartTime = Simulator.ClockTime;
                StopDynamicBrakeIncrease();
                Simulator.Confirmer.Confirm(CabControl.DynamicBrake, CabSetting.Off);
                SignalEvent(Event.DynamicBrakeOff);
            }
        }

        protected bool CanUseDynamicBrake()
        {
            return (DynamicBrakeController != null
                && ThrottlePercent == 0);
        }

        public override string GetDynamicBrakeStatus()
        {
            if (DynamicBrakeController == null)
                return null;
            if (DynamicBrakePercent < 0)
                return string.Empty;
            return string.Format("{0:F0}%", DynamicBrakePercent);
        }

        public override string GetDPDynamicBrakeStatus()
        {
            if (DynamicBrakeController == null)
                return null;
            var dpStatus = this is MSTSDieselLocomotive && Train.DPMode == -1 ? string.Format("({0:F0}%)", Train.DPDynamicBrakePercent) : string.Empty;
            if (DynamicBrakePercent < 0)
                return dpStatus;
            if (TrainControlSystem.FullDynamicBrakingOrder)
                return string.Format("{0:F0}% {1}", DynamicBrakePercent, dpStatus);
            return string.Format("{0} {1}", DynamicBrakeController.GetStatus(), dpStatus);
        }
        #endregion

        public override void SignalEvent(TCSEvent evt)
        {
            TrainControlSystem.HandleEvent(evt);

            base.SignalEvent(evt);
        }

        public override void SignalEvent(PowerSupplyEvent evt)
        {
            LocomotivePowerSupply.HandleEvent(evt);

            base.SignalEvent(evt);
        }

        public override void SignalEvent(PowerSupplyEvent evt, int id)
        {
            LocomotivePowerSupply.HandleEvent(evt, id);

            base.SignalEvent(evt, id);
        }

        public virtual void SetPower(bool toState)
        {
            LocomotivePowerSupply.HandleEvent(toState ? PowerSupplyEvent.QuickPowerOn : PowerSupplyEvent.QuickPowerOff);
        }

        internal void ToggleMUCommand(bool ToState)
        {
            RemoteControlGroup = ToState ? 0 : -1;
        }

        public void SetTrainHandbrake(bool apply)
        {
            if (apply)
            {
                Train.SetHandbrakePercent(100);
                Simulator.Confirmer.Confirm(CabControl.Handbrake, CabSetting.On);
            }
            else
            {
                Train.SetHandbrakePercent(0);
                Simulator.Confirmer.Confirm(CabControl.Handbrake, CabSetting.Off);
            }
        }

        public void SetTrainRetainers(bool apply)
        {
            Train.SetRetainers(apply);
            Simulator.Confirmer.ConfirmWithPerCent(CabControl.Retainers, CabSetting.Increase, Train.RetainerPercent, (int)CabSetting.Range1 + (int)Train.RetainerSetting);
        }

        public void BrakeHoseConnect(bool apply)
        {
            if (apply)
            {
                Train.ConnectBrakeHoses();
                Simulator.Confirmer.Confirm(CabControl.BrakeHose, CabSetting.On);
            }
            else
            {
                Train.DisconnectBrakes();
                Simulator.Confirmer.Confirm(CabControl.BrakeHose, CabSetting.Off);
            }
        }

        public void ToggleCabLight()
        {
            if (this is MSTSSteamLocomotive)
                return;

            CabLightOn = !CabLightOn;
            SignalEvent(Event.CabLightSwitchToggle);
            Simulator.Confirmer.Confirm(CabControl.CabLight, CabLightOn ? CabSetting.On : CabSetting.Off);
        }

        public void ToggleCabRadio( bool newState)
        {
            CabRadioOn = newState;
            if (!OnLineCabRadio)
            {
                if (CabRadioOn) SignalEvent(Event.CabRadioOn); // hook for sound trigger
                else SignalEvent(Event.CabRadioOff);
            }
            else if (OnLineCabRadioURL != "")
            { }
            if (Simulator.PlayerLocomotive == this) Simulator.Confirmer.Confirm(CabControl.CabRadio, CabRadioOn ? CabSetting.On : CabSetting.Off);
        }

        public void ToggleWipers(bool newState)
        {
            SignalEvent(newState ? Event.WiperOn : Event.WiperOff);
            if (ConsistGenerator.GltfVisualTestRun) Train.SignalEvent(newState ? Event.WiperOn : Event.WiperOff);
        }

        public void SetBailOff(bool bailOff)
        {
            BailOff = bailOff;
            Simulator.Confirmer.Confirm(CabControl.BailOff, bailOff ? CabSetting.On : CabSetting.Off);
        }

        public virtual void Refuel()
        {
            // Electric locos do nothing. Diesel and steam override this.
        }

        public void OdometerToggle()
        {
            OdometerVisible = !OdometerVisible;
        }

        /// <summary>
        /// Set odometer reference distance to actual travelled distance,
        /// and set measuring direction to the actual direction
        /// </summary>
        public void OdometerReset(bool toState)
        {
            if (Train == null)
                return;
            if (toState)
            {
                if (OdometerCountingForwards != OdometerCountingUp ^ (Direction == Direction.Reverse))
                {
                    OdometerCountingForwards = !OdometerCountingForwards;
                }

                if (Direction == Direction.Reverse)
                {
                    if (OdometerCountingForwards)
                        OdometerResetPositionM = Train.DistanceTravelledM - Train.Length;
                    else
                        OdometerResetPositionM = Train.DistanceTravelledM;
                }
                else
                {
                    if (OdometerCountingForwards)
                        OdometerResetPositionM = Train.DistanceTravelledM;
                    else
                        OdometerResetPositionM = Train.DistanceTravelledM + Train.Length;
                }

                Simulator.Confirmer.Confirm(CabControl.Odometer, CabSetting.On);
            }
            OdometerResetButtonPressed = toState;
        }

        public void OdometerToggleDirection()
        {
            if (Train == null)
                return;

            OdometerCountingUp = !OdometerCountingUp;

            Simulator.Confirmer.Confirm(CabControl.Odometer, OdometerCountingUp ? CabSetting.Increase : CabSetting.Decrease);
        }

        public void GenericItem1Toggle()
        {
            GenericItem1 = !GenericItem1;
            SignalEvent(GenericItem1? Event.GenericItem1On : Event.GenericItem1Off); // hook for sound trigger
            if (ConsistGenerator.GltfVisualTestRun) Train.SignalEvent(GenericItem1 ? Event.GenericItem1On : Event.GenericItem1Off);
        }

        public void GenericItem2Toggle()
        {
            GenericItem2 = !GenericItem2;
            SignalEvent(GenericItem2 ? Event.GenericItem2On : Event.GenericItem2Off); // hook for sound trigger
            if (ConsistGenerator.GltfVisualTestRun) Train.SignalEvent(GenericItem2 ? Event.GenericItem2On : Event.GenericItem2Off);
        }

        public override bool GetCabFlipped()
        {
            return UsingRearCab;
        }

        public void AlerterReset()
        {
            TrainControlSystem.HandleEvent(TCSEvent.AlerterReset);
        }

        public void AlerterReset(TCSEvent evt)
        {
            AlerterReset();
            TrainControlSystem.HandleEvent(evt);
        }

        public void AlerterPressed(bool pressed)
        {
            TrainControlSystem.AlerterPressed(pressed);
        }

        public enum TrainType { Pax, Cargo };
        public TrainType SelectedTrainType = TrainType.Pax;
        public void ChangeTrainTypePaxCargo()
        {
            SelectedTrainType = SelectedTrainType == TrainType.Pax ? TrainType.Cargo : TrainType.Pax;
        }

        public override void SignalEvent(Event evt)
        {
            switch (evt)
            {
                case Event.VigilanceAlarmOn: { AlerterSnd = true; if (Simulator.Settings.Alerter) Simulator.Confirmer.Confirm(CabControl.Alerter, CabSetting.On); break; }
                case Event.VigilanceAlarmOff: { AlerterSnd = false; if (Simulator.Settings.Alerter) Simulator.Confirmer.Confirm(CabControl.Alerter, CabSetting.Off); break; }
                case Event.BellOn:
                case Event.BellOff:
                    if (this == Simulator.PlayerLocomotive && Simulator.Confirmer != null)
                        Simulator.Confirmer.Confirm(CabControl.Bell, Bell ? CabSetting.On : CabSetting.Off);
                    break;
                case Event.HornOn:
                case Event.HornOff:
                    if (this == Simulator.PlayerLocomotive && Simulator.Confirmer != null)
                        Simulator.Confirmer.Confirm(this is MSTSSteamLocomotive ? CabControl.Whistle : CabControl.Horn, Horn ? CabSetting.On : CabSetting.Off);
                    break;
                case Event.SanderOn: { Sander = true; if (this.IsLeadLocomotive() && this == Simulator.PlayerLocomotive && Simulator.Confirmer != null) Simulator.Confirmer.Confirm(CabControl.Sander, CabSetting.On); break; }
                case Event.SanderOff: { Sander = false; if (this.IsLeadLocomotive() && this == Simulator.PlayerLocomotive && Simulator.Confirmer != null) Simulator.Confirmer.Confirm(CabControl.Sander, CabSetting.Off); break; }
                case Event.WiperOn: { Wiper = true; if (this == Simulator.PlayerLocomotive && Simulator.Confirmer != null) Simulator.Confirmer.Confirm(CabControl.Wipers, CabSetting.On); break; }
                case Event.WiperOff: { Wiper = false; if (this == Simulator.PlayerLocomotive) Simulator.Confirmer.Confirm(CabControl.Wipers, CabSetting.Off); break; }

                // <CJComment> The "H" key doesn't call these SignalEvents yet. </CJComment>
                case Event._HeadlightOff: { Headlight = 0; break; }
                case Event._HeadlightDim: { Headlight = 1; break; }
                case Event._HeadlightOn: { Headlight = 2; break; }

                case Event.CompressorOn: { CompressorIsOn = true; break; }
                case Event.CompressorOff: { CompressorIsOn = false; break; }

                    //Vacuum exhauster event only triggered if vacuum exhauster engine control fitted.
                case Event.VacuumExhausterOn: { if(FastVacuumExhausterFitted) VacuumExhausterPressed = true; if (this.IsLeadLocomotive() && this == Simulator.PlayerLocomotive && Simulator.Confirmer != null) Simulator.Confirmer.Confirm(CabControl.VacuumExhauster, CabSetting.On); break; }
                case Event.VacuumExhausterOff: { if (FastVacuumExhausterFitted) VacuumExhausterPressed = false; if (this.IsLeadLocomotive() && this == Simulator.PlayerLocomotive && Simulator.Confirmer != null) Simulator.Confirmer.Confirm(CabControl.VacuumExhauster, CabSetting.Off); break; }

                case Event._ResetWheelSlip:
                    {
                        LocomotiveAxles.InitializeMoving();
                        ThrottleController.SetValue(0.0f);
                        break;
                    }
                case Event.TrainBrakePressureDecrease:
                case Event.TrainBrakePressureIncrease:
                    {
                        if (Train.TrainType == Train.TRAINTYPE.AI || Train.TrainType == Train.TRAINTYPE.AI_PLAYERHOSTING)
                        {
                            if (Train.Simulator.GameTime - LastBrakeSoundTime < 15) // don't repeat sound too often for AI trains (which frequently set brakes on and off)
                            {
                                return;
                            }
                            LastBrakeSoundTime = Train.Simulator.GameTime;
                        }
                        break;
                    }
                case Event.GenericItem1On: if (ConsistGenerator.GltfVisualTestRun) GenericItem1 = true; break;
                case Event.GenericItem1Off: if (ConsistGenerator.GltfVisualTestRun) GenericItem1 = false; break;
                case Event.GenericItem2On: if (ConsistGenerator.GltfVisualTestRun) GenericItem2 = true; break;
                case Event.GenericItem2Off: if (ConsistGenerator.GltfVisualTestRun) GenericItem2 = false; break;
            }

            base.SignalEvent(evt);
        }

        public virtual float GetDataOf(CabViewControl cvc)
        {
            float data = 0;
            switch (cvc.ControlType.Type)
            {
                case CABViewControlTypes.SPEEDOMETER:
                    {
                        //data = SpeedMpS;
                        if (AdvancedAdhesionModel)
                            data = WheelSpeedMpS;
                        else
                            data = SpeedMpS;

                        if (cvc.Units == CABViewControlUnits.KM_PER_HOUR)
                            data *= 3.6f;
                        else // MPH
                            data *= 2.2369f;
                        data = Math.Abs(data);
                        break;
                    }
                case CABViewControlTypes.SPEED_PROJECTED:
                    {
                        if (Train != null)
                            data = Train.ProjectedSpeedMpS;
                        else data = 0;
                        if (cvc.Units == CABViewControlUnits.KM_PER_HOUR)
                            data *= 3.6f;
                        else // MPH
                            data *= 2.2369f;
                        data = Math.Abs(data);
                        break;
                    }
                case CABViewControlTypes.ACCELEROMETER:
                    {
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.METRES_SEC_SEC:
                                data = this.AccelerationMpSS;
                                break;

                            case CABViewControlUnits.METRES_SEC_HOUR:
                                data = this.AccelerationMpSS * 3600.0f;
                                break;

                            case CABViewControlUnits.KM_HOUR_SEC:
                                data = this.AccelerationMpSS * 3.6f;
                                break;

                            case CABViewControlUnits.KM_HOUR_HOUR:
                                data = this.AccelerationMpSS * 3.6f * 3600.0f;
                                break;

                            case CABViewControlUnits.MILES_HOUR_MIN:
                                data = this.AccelerationMpSS * 2.236936f * 60.0f;
                                break;

                            case CABViewControlUnits.MILES_HOUR_HOUR:
                                // 
                                data = this.AccelerationMpSS * 2.236936f * 3600.0f;
                                break;

                            default:
                                data = this.AccelerationMpSS;
                                break;

                        }
                        break;
                    }

                 case CABViewControlTypes.ORTS_WATER_SCOOP:
                    data = WaterScoopDown ? 1 : 0;
                    break;

                case CABViewControlTypes.STEAM_HEAT:
                    data = SteamHeatController.CurrentValue;
                    break;
                
                case CABViewControlTypes.AMMETER: // Current not modelled yet to ammeter shows tractive effort until then.
                case CABViewControlTypes.AMMETER_ABS:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        if (MaxCurrentA == 0)
                            MaxCurrentA = (float)cvc.MaxValue;
                        if (LocomotiveAxles.Count > 0)
                        {
                            data = 0.0f;
                            if (ThrottlePercent > 0)
                            {
                                //float rangeFactor = direction == 0 ? (float)cvc.MaxValue : (float)cvc.MinValue;
                                float rangeFactor = direction == 0 ? MaxCurrentA : (float)cvc.MinValue;
                                if (FilteredMotiveForceN != 0)
                                    data = this.FilteredMotiveForceN / MaxForceN * rangeFactor;
                                else
                                    data = this.LocomotiveAxles[cvc.ControlId].DriveForceN / MaxForceN * rangeFactor;
                                data = Math.Abs(data);
                            }
                            if (DynamicBrakePercent > 0 && MaxDynamicBrakeForceN > 0)
                            {
                                float rangeFactor;
                                if (cvc.ControlType.Type == CABViewControlTypes.AMMETER_ABS)
                                {
                                    if (DynamicBrakeMaxCurrentA == 0)
                                        rangeFactor = direction == 0 ? (float)cvc.MaxValue : (float)cvc.MinValue;
                                    else
                                        rangeFactor = direction == 0 ? DynamicBrakeMaxCurrentA : (float)cvc.MinValue;
                                }
                                else
                                {
                                    if (DynamicBrakeMaxCurrentA == 0)
                                        rangeFactor = direction == 0 ? (float)cvc.MinValue : (float)cvc.MaxValue;
                                    else
                                        rangeFactor = direction == 0 ? -DynamicBrakeMaxCurrentA : (float)cvc.MaxValue;
                                }
                                data = DynamicBrakeForceN / MaxDynamicBrakeForceN * rangeFactor;
                            }
                            if (direction == 1)
                                data = -data;
                            if (cvc.ControlType.Type == CABViewControlTypes.AMMETER_ABS) data = Math.Abs(data);
                            break;
                        }
                        data = this.MotiveForceN / MaxForceN * MaxCurrentA;
                        if (cvc.ControlType.Type == CABViewControlTypes.AMMETER_ABS) data = Math.Abs(data);
                        break;
                    }
                case CABViewControlTypes.LOAD_METER:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        if (MaxCurrentA == 0)
                            MaxCurrentA = (float)cvc.MaxValue;
                        if (DynamicBrakeMaxCurrentA == 0)
                            DynamicBrakeMaxCurrentA = (float)cvc.MinValue;
                        data = 0.0f;
                        if (ThrottlePercent > 0)
                        {
                            if (FilteredMotiveForceN != 0)
                                data = this.FilteredMotiveForceN / MaxForceN * MaxCurrentA;
                            else
                                data = this.LocomotiveAxles[cvc.ControlId].DriveForceN / MaxForceN * MaxCurrentA;
                            data = Math.Abs(data);
                        }
                        if (DynamicBrake && DynamicBrakePercent > 0 && MaxDynamicBrakeForceN > 0)
                        {
                            data = DynamicBrakeForceN / MaxDynamicBrakeForceN * DynamicBrakeMaxCurrentA;
                            data = -Math.Abs(data); // Ensure that dynamic force is seen as a "-ve force", changes colour on the load meter
                        }
                        if (direction == 1)
                            data = -data;
                        break;
                    }
                case CABViewControlTypes.TRACTION_BRAKING:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        data = 0.0f;
                        if (FilteredMotiveForceN != 0)
                            data = this.FilteredMotiveForceN;
                        else
                            data = this.LocomotiveAxles[cvc.ControlId].DriveForceN;
                        if (DynamicBrake && DynamicBrakePercent > 0)
                        {
                            data = DynamicBrakeForceN;
                        }
                        data = Math.Abs(data);
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.AMPS:
                                if (MaxCurrentA == 0)
                                    MaxCurrentA = (float)cvc.MaxValue;
                                if (DynamicBrakeMaxCurrentA == 0)
                                    DynamicBrakeMaxCurrentA = (float)cvc.MinValue;
                                if (ThrottlePercent > 0)
                                {
                                    data = (data / MaxForceN) * MaxCurrentA;
                                 }
                                if (DynamicBrakePercent > 0)
                                {
                                    data = (DynamicBrakeForceN / MaxDynamicBrakeForceN) * DynamicBrakeMaxCurrentA;
                                }
                                data = Math.Abs(data);
                                break;
                    
                            case CABViewControlUnits.NEWTONS:
                                break;
                    
                            case CABViewControlUnits.KILO_NEWTONS:
                                data = data / 1000.0f;
                                break;
                    
                            case CABViewControlUnits.KILO_LBS:
                                data = N.ToLbf(data) * 0.001f;
                                break;
                        }                   
                        if (direction == 1 && !(cvc is CVCGauge))
                            data = -data;
                        break;
                    }
                case CABViewControlTypes.ORTS_SIGNED_TRACTION_BRAKING:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        data = 0.0f;
                        if (FilteredMotiveForceN != 0)
                            data = Math.Abs(this.FilteredMotiveForceN);
                        else
                            data = Math.Abs(this.LocomotiveAxles[cvc.ControlId].DriveForceN);
                        if (DynamicBrake && DynamicBrakePercent > 0)
                        {
                            data = -Math.Abs(DynamicBrakeForceN);
                        }
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.AMPS:
                                if (MaxCurrentA == 0)
                                    MaxCurrentA = (float)cvc.MaxValue;
                                if (DynamicBrakeMaxCurrentA == 0)
                                    DynamicBrakeMaxCurrentA = (float)cvc.MinValue;
                                if (ThrottlePercent >= 0 && DynamicBrakePercent == -1)
                                {
                                    data = (data / MaxForceN) * MaxCurrentA;
                                }
                                if (ThrottlePercent == 0 && DynamicBrakePercent >= 0)
                                {
                                    data = (data / MaxDynamicBrakeForceN) * DynamicBrakeMaxCurrentA;
                                }
                                break;

                            case CABViewControlUnits.NEWTONS:
                                break;

                            case CABViewControlUnits.KILO_NEWTONS:
                                data = data / 1000.0f;
                                break;

                            case CABViewControlUnits.KILO_LBS:
                                data = N.ToLbf(data) * 0.001f;
                                break;
                        }
 //                       if (direction == 1 && !(cvc is CVCGauge))
 //                           data = -data;
                        break;
                    }
                    // this considers both the dynamic as well as the train braking
                case CABViewControlTypes.ORTS_SIGNED_TRACTION_TOTAL_BRAKING:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        data = 0.0f;
                        if (Math.Abs(SpeedMpS) == 0.0f)
                            data = 0.0f;
                        else if (Math.Abs(FilteredMotiveForceN) - Math.Abs(BrakeForceN + DynamicBrakeForceN) > 0)
                            data = Math.Abs(this.FilteredMotiveForceN);
                        else if (Math.Abs(FilteredMotiveForceN) - Math.Abs(BrakeForceN + DynamicBrakeForceN) < 0)
                            data = -Math.Abs(BrakeForceN + DynamicBrakeForceN);
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.NEWTONS:
                                break;

                            case CABViewControlUnits.KILO_NEWTONS:
                                data = data / 1000.0f;
                                break;

                            case CABViewControlUnits.KILO_LBS:
                                data = N.ToLbf(data) * 0.001f;
                                break;
                        }
                        break;
                    }
                case CABViewControlTypes.DYNAMIC_BRAKE_FORCE:
                    {
                        var direction = 0; // Forwards
                        if (cvc is CVCGauge && ((CVCGauge)cvc).Orientation == 0)
                            direction = ((CVCGauge)cvc).Direction;
                        data = 0.0f;
                        data = DynamicBrakeForceN;
                        if (data > 0 && SpeedMpS > 0 || data < 0 && SpeedMpS < 0)
                        {
                            data = 0;
                            break;
                        }
                        data = Math.Abs(data);
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.AMPS:
                                if (MaxCurrentA == 0)
                                    MaxCurrentA = (float)cvc.MaxValue;
                                if (DynamicBrakeMaxCurrentA == 0)
                                    DynamicBrakeMaxCurrentA = (float)cvc.MinValue;
                                if (ThrottlePercent > 0)
                                {
                                    data = 0;
                                }
                                if (DynamicBrakePercent > 0)
                                {
                                    data = (DynamicBrakeForceN / MaxDynamicBrakeForceN) * DynamicBrakeMaxCurrentA;
                                }
                                data = Math.Abs(data);
                                break;

                            case CABViewControlUnits.NEWTONS:
                                break;

                            case CABViewControlUnits.KILO_NEWTONS:
                                data = data / 1000.0f;
                                break;

                            case CABViewControlUnits.KILO_LBS:
                                data = N.ToLbf(data) * 0.001f;
                                break;
                        }
                        if (direction == 1 && !(cvc is CVCGauge))
                            data = -data;
                        break;
                    }
                case CABViewControlTypes.MAIN_RES:
                    {
                        data = ConvertFromPSI(cvc, MainResPressurePSI);
                        break;
                    }
                case CABViewControlTypes.MAIN_RES_PIPE:
                    {
                        data = ConvertFromPSI(cvc, this.BrakeSystem.BrakeLine2PressurePSI);
                        break;
                    }
                case CABViewControlTypes.BRAKE_PIPE:
                    {
                        data = ConvertFromPSI(cvc, this.BrakeSystem.BrakeLine1PressurePSI);
                        break;
                    }
                case CABViewControlTypes.EQ_RES:
                    {
                        data = ConvertFromPSI(cvc, this.Train.EqualReservoirPressurePSIorInHg);
                        break;
                    }
                case CABViewControlTypes.BRAKE_CYL:
                    {
                        data = ConvertFromPSI(cvc, BrakeSystem.GetCylPressurePSI());
                        break;
                    }
                case CABViewControlTypes.VACUUM_RESERVOIR_PRESSURE:
                    {
                        data = ConvertFromPSI(cvc, BrakeSystem.GetVacResPressurePSI());
                        break;
                    }
                case CABViewControlTypes.ORTS_EOT_BRAKE_PIPE:
                    {
                        data = ConvertFromPSI(cvc, this.Train.Cars.Last().BrakeSystem.BrakeLine1PressurePSI);
                        break;
                    }

                case CABViewControlTypes.RPM:
                    {

                        if (EngineType == EngineTypes.Control)
                        {
                            FindControlActiveLocomotive();

                            if (ControlActiveLocomotive != null)
                            {
                                var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;
                                if (activeloco.DieselEngines[0] != null)
                                    data = activeloco.DieselEngines[0].RealRPM;
                            }

                        }
                        else
                        {
                            var mstsDieselLocomotive = this as MSTSDieselLocomotive;
                            if (mstsDieselLocomotive.DieselEngines[0] != null)
                                data = mstsDieselLocomotive.DieselEngines[0].RealRPM;
                        }
                        break;
                    }

                case CABViewControlTypes.RPM_2:
                    {

                        FindControlActiveLocomotive();

                        if (ControlActiveLocomotive != null)
                        {
                            var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;
                            var mstsDieselLocomotive = this as MSTSDieselLocomotive;

                            if (EngineType == EngineTypes.Control && activeloco.DieselEngines.NumOfActiveEngines > 1)
                            {
                             
                                if (activeloco.DieselEngines[1] != null)
                                    data = activeloco.DieselEngines[1].RealRPM;
                            }
                            else if (EngineType == EngineTypes.Diesel && mstsDieselLocomotive.DieselEngines.NumOfActiveEngines > 1)
                            {                      
                                if (mstsDieselLocomotive.DieselEngines[1] != null)
                                    data = mstsDieselLocomotive.DieselEngines[1].RealRPM;
                            }
                        }
                        break;
                    }

                case CABViewControlTypes.ORTS_DIESEL_TEMPERATURE:
                    {

                        if (EngineType == EngineTypes.Control)
                        {
                            FindControlActiveLocomotive();

                            if (ControlActiveLocomotive != null)
                            {
                                var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;
                                if (activeloco.DieselEngines[0] != null)
                                    data = activeloco.DieselEngines[0].DieselTemperatureDeg;
                            }

                        }
                        else
                        {
                            var mstsDieselLocomotive = this as MSTSDieselLocomotive;
                            if (mstsDieselLocomotive.DieselEngines[0] != null)
                                data = mstsDieselLocomotive.DieselEngines[0].DieselTemperatureDeg;
                        }
                        break;
                    }

                case CABViewControlTypes.ORTS_OIL_PRESSURE:
                    {
                        if (EngineType == EngineTypes.Control)
                        {
                            FindControlActiveLocomotive();

                            if (ControlActiveLocomotive != null)
                            {
                                var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;
                                if (activeloco.DieselEngines[0] != null)
                                    data = activeloco.DieselEngines[0].DieselOilPressurePSI;
                            }

                        }
                        else
                        {
                            var mstsDieselLocomotive = this as MSTSDieselLocomotive;
                            if (mstsDieselLocomotive.DieselEngines[0] != null)
                                data = mstsDieselLocomotive.DieselEngines[0].DieselOilPressurePSI;
                        }
                        break;
                    }

                case CABViewControlTypes.THROTTLE:
                    {
                        if (CruiseControl != null && CruiseControl.SkipThrottleDisplay) break;
                        data = GetThrottleHandleValue(Train.TrainType == Train.TRAINTYPE.AI_PLAYERHOSTING ? ThrottlePercent / 100f : LocalThrottlePercent / 100f);
                        break;
                    }
                case CABViewControlTypes.THROTTLE_DISPLAY:
                case CABViewControlTypes.CPH_DISPLAY:
                    {
                        if (CruiseControl != null && CruiseControl.SkipThrottleDisplay) break;
                        data = Train.TrainType == Train.TRAINTYPE.AI_PLAYERHOSTING? ThrottlePercent / 100f : LocalThrottlePercent / 100f;
                        break;
                    }
                case CABViewControlTypes.ENGINE_BRAKE:
                    {
                        data = (EngineBrakeController == null) ? 0.0f : EngineBrakeController.CurrentValue;
                        break;
                    }
                case CABViewControlTypes.TRAIN_BRAKE:
                    {
                        if (CruiseControl != null)
                            if (CruiseControl.CCIsUsingTrainBrake) break;
                        data = (TrainBrakeController == null) ? 0.0f : TrainBrakeController.CurrentValue;
                        break;
                    }
                case CABViewControlTypes.ORTS_BAILOFF:
                    {
                        data = BailOff ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.ORTS_QUICKRELEASE:
                    {
                        data = (TrainBrakeController == null || !TrainBrakeController.QuickReleaseButtonPressed) ? 0 : 1;
                        break;
                    }
                case CABViewControlTypes.ORTS_OVERCHARGE:
                    {
                        data = (TrainBrakeController == null || !TrainBrakeController.OverchargeButtonPressed) ? 0 : 1;
                        break;
                    }
                case CABViewControlTypes.ORTS_AIR_FLOW_METER:
                    {
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.CUBIC_FT_MIN:
                                data = this.FilteredBrakePipeFlowM3pS * 35.3147f * 60.0f;
                                break;

                            case CABViewControlUnits.LITRES_S:
                            case CABViewControlUnits.LITERS_S:
                                data = this.FilteredBrakePipeFlowM3pS * 1000.0f;
                                break;

                            case CABViewControlUnits.LITRES_MIN:
                            case CABViewControlUnits.LITERS_MIN:
                                data = this.FilteredBrakePipeFlowM3pS * 1000.0f * 60.0f;
                                break;

                            case CABViewControlUnits.CUBIC_M_S:
                            default:
                                data = this.FilteredBrakePipeFlowM3pS;
                                break;

                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_TRAIN_AIR_FLOW_METER:
                    {
                        switch (cvc.Units)
                        {
                            case CABViewControlUnits.CUBIC_FT_MIN:
                                data = this.Train.TotalBrakePipeFlowM3pS * 35.3147f * 60.0f;
                                break;

                            case CABViewControlUnits.LITRES_S:
                            case CABViewControlUnits.LITERS_S:
                                data = this.Train.TotalBrakePipeFlowM3pS * 1000.0f;
                                break;

                            case CABViewControlUnits.LITRES_MIN:
                            case CABViewControlUnits.LITERS_MIN:
                                data = this.Train.TotalBrakePipeFlowM3pS * 1000.0f * 60.0f;
                                break;

                            case CABViewControlUnits.CUBIC_M_S:
                            default:
                                data = this.Train.TotalBrakePipeFlowM3pS;
                                break;

                        }
                        break;
                    }
                case CABViewControlTypes.FRICTION_BRAKING:
                    {
                        data = (BrakeSystem == null) ? 0.0f : BrakeSystem.GetCylPressurePSI();
                        break;
                    }
                case CABViewControlTypes.DYNAMIC_BRAKE:
                case CABViewControlTypes.DYNAMIC_BRAKE_DISPLAY:
                    //case CABViewControlTypes.CP_HANDLE:
                    {
                        data = DynamicBrakePercent / 100f;
                        break;
                    }
                case CABViewControlTypes.WIPERS:
                    {
                        data = Wiper ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.VACUUM_EXHAUSTER:
                    {
                        if (FastVacuumExhausterFitted)
                        {
                            data = VacuumExhausterPressed ? 1 : 0;
                        }
                        else
                        {
                            data = 0;
                        }
                        break;
                    }

                case CABViewControlTypes.HORN:
                    {
                        data = Horn ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.BELL:
                    {
                        data = Bell ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.RESET:
                    {
                        if (TrainControlSystem.AlerterButtonPressed)
                            data = 1;
                        else
                            data = 0;
                        break;
                    }

                case CABViewControlTypes.ALERTER_DISPLAY:
                    {
                        if (Simulator.Settings.Alerter)
                        {
                            if (TrainControlSystem.VigilanceEmergency)
                                data = 2;
                            else if (TrainControlSystem.VigilanceAlarm)
                                data = 1;
                            else
                                data = 0;
                        }
                        break;
                    }
                case CABViewControlTypes.OVERSPEED:
                    {
                        data = TrainControlSystem.OverspeedWarning ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.PENALTY_APP:
                    {
                        data = TrainControlSystem.PenaltyApplication ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.EMERGENCY_BRAKE:
                    {
                        data = EmergencyButtonPressed ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.DOORS_DISPLAY:
                    {
                        data = Train.DoorState(DoorSide.Both) != DoorState.Closed ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.SANDERS:
                    {
                        data = Sander ? 1 : 0;
                        break;
                    }
                // MultStateDisplay entry in CVF file had Type SANDING. W/O the below entry and another entry at line 3625
                // the independant sanding light found in some cabs would not work.
                case CABViewControlTypes.SANDING:
                    {
                        data = Sander ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.CLOCK:
                    {
                        data = 0;
                        break;
                    }

                case CABViewControlTypes.FRONT_HLIGHT:
                    {
                        data = Headlight;
                        break;
                    }
                case CABViewControlTypes.WHEELSLIP:
                    {
                        if (EngineType == EngineTypes.Control)
                        {
                            FindControlActiveLocomotive();

                            if (ControlActiveLocomotive != null)
                            {
                                var activeloco = ControlActiveLocomotive as MSTSDieselLocomotive;
                                if (activeloco.DieselEngines[0] != null)
                                {
                                    if (activeloco.AdvancedAdhesionModel && Train.TrainType != Train.TRAINTYPE.AI_PLAYERHOSTING)
                                        data = activeloco.HuDIsWheelSlipWarninq ? 1 : 0;
                                    else
                                        data = activeloco.HuDIsWheelSlip ? 1 : 0;

                                }
                            }
                        }
                        else
                        {
                            if (AdvancedAdhesionModel && Train.TrainType != Train.TRAINTYPE.AI_PLAYERHOSTING)
                                data = HuDIsWheelSlipWarninq ? 1 : 0;
                            else
                                data = HuDIsWheelSlip ? 1 : 0;
                        }
                        break;
                    }

                case CABViewControlTypes.DIRECTION:
                case CABViewControlTypes.DIRECTION_DISPLAY:
                    {
                        if (Direction == Direction.Forward)
                            data = 2;
                        else if (Direction == Direction.Reverse)
                            data = 0;
                        else
                            data = 1;
                        break;
                    }
                case CABViewControlTypes.ASPECT_DISPLAY:
                    {
                        switch (TrainControlSystem.CabSignalAspect)
                        {
                            case TrackMonitorSignalAspect.Stop:
                                {
                                    data = 0;
                                    break;
                                }
                            case TrackMonitorSignalAspect.StopAndProceed:
                                {
                                    data = 1;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Restricted:
                                {
                                    data = 2;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Approach_1:
                                {
                                    data = 3;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Approach_2:
                                {
                                    data = 4;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Approach_3:
                                {
                                    data = 5;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Clear_1:
                                {
                                    data = 6;
                                    break;
                                }
                            case TrackMonitorSignalAspect.Clear_2:
                                {
                                    data = 7;
                                    break;
                                }
                            default:
                                {
                                    data = 7;
                                    break;
                                }
                        }
                        break;
                    }
                case CABViewControlTypes.SPEEDLIMIT:
                    {
                        // Displays current allowable speed
                        bool metric = cvc.Units == CABViewControlUnits.KM_PER_HOUR;
                        data = MpS.FromMpS(TrainControlSystem.CurrentSpeedLimitMpS, metric);
                        break;
                    }
                case CABViewControlTypes.SPEEDLIM_DISPLAY:
                    {
                        // Displays allowable speed shown on next signal
                        bool metric = cvc.Units == CABViewControlUnits.KM_PER_HOUR;
                        data = MpS.FromMpS(TrainControlSystem.NextSpeedLimitMpS, metric);
                        break;
                    }
                case CABViewControlTypes.GEARS_DISPLAY:
                    {
                        data = 0;
                        if (this is MSTSDieselLocomotive)
                        {
                            var dieselLoco = this as MSTSDieselLocomotive;
                            if (dieselLoco.DieselEngines.HasGearBox)
                                data = dieselLoco.DieselEngines[0].GearBox.GearIndication;
                        }
                        break;
                    }
                case CABViewControlTypes.CAB_RADIO:
                    {
                        data = CabRadioOn ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.ORTS_PLAYER_DIESEL_ENGINE:
                    {
                        data = 0;
                        if (this is MSTSDieselLocomotive)
                        {
                            var dieselLoco = this as MSTSDieselLocomotive;
                            data = (dieselLoco.DieselEngines[0].State == DieselEngineState.Running ||
                                dieselLoco.DieselEngines[0].State == DieselEngineState.Starting) ? 1 : 0;
                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_HELPERS_DIESEL_ENGINES:
                    {
                        foreach (var car in Train.Cars)
                        {
                            var dieselLoco = car as MSTSDieselLocomotive;
                            if (dieselLoco != null && dieselLoco.RemoteControlGroup != -1)
                            {
                                if (car == Simulator.PlayerLocomotive && dieselLoco.DieselEngines.Count > 1)
                                {
                                    data = (dieselLoco.DieselEngines[1].State == DieselEngineState.Running ||
                                        dieselLoco.DieselEngines[1].State == DieselEngineState.Starting) ? 1 : 0;
                                    break;
                                }
                                else if (car != Simulator.PlayerLocomotive)
                                {
                                    data = (dieselLoco.DieselEngines[0].State == DieselEngineState.Running ||
                                        dieselLoco.DieselEngines[0].State == DieselEngineState.Starting) ? 1 : 0;
                                    break;
                                }
                             }
                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_PLAYER_DIESEL_ENGINE_STATE:
                    {
                        data = 0;
                        if (this is MSTSDieselLocomotive)
                        {
                            var dieselLoco = this as MSTSDieselLocomotive;
                            data = (int)dieselLoco.DieselEngines[0].State;
                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_PLAYER_DIESEL_ENGINE_STARTER:
                    {
                        data = 0;
                        if (this is MSTSDieselLocomotive)
                        {
                            var dieselLoco = this as MSTSDieselLocomotive;
                            data = dieselLoco.DieselEngines[0].State == DieselEngineState.Starting ? 1 : 0;
                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_PLAYER_DIESEL_ENGINE_STOPPER:
                    {
                        data = 0;
                        if (this is MSTSDieselLocomotive)
                        {
                            var dieselLoco = this as MSTSDieselLocomotive;
                            data = dieselLoco.DieselEngines[0].State == DieselEngineState.Stopping ? 1 : 0;
                        }
                        break;
                    }
                case CABViewControlTypes.ORTS_CABLIGHT:
                    data = CabLightOn ? 1 : 0;
                    break;
                case CABViewControlTypes.ORTS_LEFTDOOR:
                case CABViewControlTypes.ORTS_RIGHTDOOR:
                    {
                        bool right = (cvc.ControlType.Type == CABViewControlTypes.ORTS_RIGHTDOOR) ^ Flipped ^ GetCabFlipped();
                        var state = Train.DoorState(right ? DoorSide.Right : DoorSide.Left);
                        data = state >= DoorState.Opening ? 1 : 0;
                    }
                    break;
                case CABViewControlTypes.ORTS_LEFTWINDOW:
                case CABViewControlTypes.ORTS_2DEXTERNALLEFTWINDOW:
                    data = UsingRearCab ? (WindowStates[RightWindowRearIndex] == WindowState.Closing || WindowStates[RightWindowRearIndex] == WindowState.Opening ? 1 : 0) :
                        (WindowStates[LeftWindowFrontIndex] == WindowState.Closing || WindowStates[LeftWindowFrontIndex] == WindowState.Opening ? 1 : 0);
                    break;
                case CABViewControlTypes.ORTS_RIGHTWINDOW:
                case CABViewControlTypes.ORTS_2DEXTERNALRIGHTWINDOW:
                    data = UsingRearCab ? (WindowStates[LeftWindowRearIndex] == WindowState.Closing || WindowStates[LeftWindowRearIndex] == WindowState.Opening ? 1 : 0) :
                        (WindowStates[RightWindowFrontIndex] == WindowState.Closing || WindowStates[RightWindowFrontIndex] == WindowState.Opening ? 1 : 0);
                    break;
                case CABViewControlTypes.ORTS_MIRRORS:
                    data = MirrorOpen ? 1 : 0;
                    break;
                case CABViewControlTypes.ORTS_2DEXTERNALWIPERS:
                    data = Wiper ? 1 : 0;
                    break;
                case CABViewControlTypes.ORTS_HOURDIAL:
                    float hour = (float)(Simulator.ClockTime / 3600) % 12;
                    if (hour < 0)
                        hour += 12;
                    data = hour;
                    break;
                case CABViewControlTypes.ORTS_MINUTEDIAL:
                    float minute = (float)(Simulator.ClockTime / 60) % 60;
                    if (minute < 0)
                        minute += 60;
                    data = minute;
                    break;
                case CABViewControlTypes.ORTS_SECONDDIAL:
                    int seconds = (int)Simulator.ClockTime % 60;
                    if (seconds < 0)
                        seconds += 60;
                    data = seconds;
                    break;
                case CABViewControlTypes.ORTS_GENERIC_ITEM1:
                    {
                        data = GenericItem1 ? 1 : 0;
                        break;
                    }
                case CABViewControlTypes.ORTS_GENERIC_ITEM2:
                    {
                        data = GenericItem2 ? 1 : 0;
                        break;
                    }

                case CABViewControlTypes.ORTS_TCS:
                    TrainControlSystem.CabDisplayControls.TryGetValue(cvc.ControlType.Id - 1, out data);
                    break;

                case CABViewControlTypes.ORTS_BATTERY_SWITCH_COMMAND_SWITCH:
                    data = LocomotivePowerSupply.BatterySwitch.CommandSwitch ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_BATTERY_SWITCH_COMMAND_BUTTON_CLOSE:
                    data = LocomotivePowerSupply.BatterySwitch.CommandButtonOn ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_BATTERY_SWITCH_COMMAND_BUTTON_OPEN:
                    data = LocomotivePowerSupply.BatterySwitch.CommandButtonOff ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_BATTERY_SWITCH_ON:
                    data = LocomotivePowerSupply.BatterySwitch.On ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_MASTER_KEY:
                    data = LocomotivePowerSupply.MasterKey.CommandSwitch ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_CURRENT_CAB_IN_USE:
                    data = LocomotivePowerSupply.MasterKey.On ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_OTHER_CAB_IN_USE:
                    data = LocomotivePowerSupply.MasterKey.OtherCabInUse ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_SERVICE_RETENTION_BUTTON:
                    data = LocomotivePowerSupply.ServiceRetentionButton ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_SERVICE_RETENTION_CANCELLATION_BUTTON:
                    data = LocomotivePowerSupply.ServiceRetentionCancellationButton ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_ELECTRIC_TRAIN_SUPPLY_COMMAND_SWITCH:
                    data = LocomotivePowerSupply.ElectricTrainSupplySwitch.CommandSwitch ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_ELECTRIC_TRAIN_SUPPLY_ON:
                    data = LocomotivePowerSupply.ElectricTrainSupplyOn ? 1 : 0;
                    break;

                case CABViewControlTypes.ORTS_ODOMETER:
                    switch (cvc.Units)
                    {
                        case CABViewControlUnits.KILOMETRES:
                            data = (float)Me.ToKiloM(OdometerM);
                            break;
                        case CABViewControlUnits.MILES:
                            data = (float)Me.ToMi(OdometerM);
                            break;
                        case CABViewControlUnits.FEET:
                            data = (float)Me.ToFt(OdometerM);
                            break;
                        case CABViewControlUnits.YARDS:
                            data = (float)Me.ToYd(OdometerM);
                            break;
                        case CABViewControlUnits.METRES:
                        default:
                            data = OdometerM;
                            break;
                    }
                    break;
                case CABViewControlTypes.ORTS_ODOMETER_DIRECTION:
                    data = OdometerCountingUp ? 1 : 0;
                    break;
                case CABViewControlTypes.ORTS_ODOMETER_RESET:
                    data = OdometerResetButtonPressed ? 1 : 0;
                    break;
                case CABViewControlTypes.ORTS_MULTI_POSITION_CONTROLLER:
                    if (MultiPositionControllers != null)
                    {
                        var mpc = MultiPositionControllers.Where(x => x.ControllerId == cvc.ControlId).FirstOrDefault();
                        if (mpc != null) data = mpc.GetDataOf(cvc);
                    }
                    break;

                default:
                    if (CruiseControl != null)
                        data = CruiseControl.GetDataOf(cvc);
                    if (Train?.EOT != null && data == 0)
                        data = Train.EOT.GetDataOf(cvc);
                    break;
            }
            return data;
        }

        protected static float ConvertFromPSI(CabViewControl cvc, float data)
        {
            if (cvc.Units == CABViewControlUnits.BAR)
                data = Bar.FromPSI(data);
            else if (cvc.Units == CABViewControlUnits.KILOPASCALS)
                data = KPa.FromPSI(data);
            else if (cvc.Units == CABViewControlUnits.KGS_PER_SQUARE_CM)
                data *= 70.307e-3f;
            else if (cvc.Units == CABViewControlUnits.INCHES_OF_MERCURY)
                data = Vac.FromPress(data);
            return data;
        }

        /// <summary>
        /// To be overridden by MSTSSteamLocomotive and MSTSDieselLocomotive.
        /// </summary>
        public virtual void RefillImmediately()
        {
        }

        /// <summary>
        /// To be overridden by MSTSSteamLocomotive and MSTSDieselLocomotive.
        /// </summary>
        public virtual MSTSNotchController GetRefillController(uint type)
        {
            return null;
        }

        /// <summary>
        /// To be overridden by MSTSSteamLocomotive and MSTSDieselLocomotive.
        /// </summary>
        public virtual void SetStepSize(PickupObj matchPickup)
        {
        }

        /// <summary>
        /// To be overridden by MSTSSteamLocomotive and MSTSDieselLocomotive.
        /// </summary>
        public override float GetFilledFraction(uint pickupType)
        {
            return 0f;
        }

        public override void SwitchToPlayerControl()
        {
            base.SwitchToPlayerControl();
            return;
        }

        public override void SwitchToAutopilotControl()
        {
            base.SwitchToAutopilotControl();
            return;
        }

    } // End Class MSTSLocomotive

    public class CabView
    {
        public CabViewFile CVFFile;
        public List<ViewPoint> ViewPointList;
        public ExtendedCVF ExtendedCVF;
        public CabViewType CabViewType;
        public bool NoseAhead; // if cabview is not in front of engine; used to define how terrain tilts if there is freightanimation

        public CabView(CabViewFile cvfFile, List<ViewPoint> viewPointList, ExtendedCVF extendedCVF, CabViewType cabViewType, bool noseAhead)
        {
            CVFFile = cvfFile;
            ViewPointList = viewPointList;
            ExtendedCVF = extendedCVF;
            CabViewType = cabViewType;
            NoseAhead = noseAhead;
        }
    }

    public class CabView3D : CabView
    {
        public string ShapeFilePath;

        public CabView3D(CabViewFile cvfFile, List<PassengerViewPoint> cabViewpoints, ExtendedCVF extendedCVF, CabViewType cabViewType, bool noseAhead, string shapeFilePath)
            : base(cvfFile, new List<ViewPoint>(), extendedCVF, cabViewType, noseAhead)
        {
            ShapeFilePath = shapeFilePath;
            if (cabViewpoints != null)
                foreach (var point in cabViewpoints)
                    ViewPointList.Add(point);
        }

    }

    /// <summary>
    /// Extended CVF data, currently used for CAB light
    /// By GeorgeS
    /// </summary>
    [ORTSPhysicsFile("lit", "ORTSExtendedCVF")]
    public class ExtendedCVF
    {
        /// <summary>
        /// Translate to current screen resolution
        /// </summary>
        /// <param name="displaySize">Current screen resolution</param>
        /// <returns>Translated vectors</returns>
        public static Vector4 TranslatedPosition(Vector4 Position, Point displaySize)
        {
            return new Vector4(Position.X / 640 * displaySize.X,
                Position.Y / 480 * displaySize.Y,
                Position.Z / 640 * displaySize.X,
                Position.W);
        }

        /// <summary>
        /// Used by the shader
        /// </summary>
        public static Vector3 TranslatedColor(Color Color)
        {
            return new Vector3((float)Color.R / 255, (float)Color.G / 255, (float)Color.B / 255);
        }

        [ORTSPhysics("First light Position", "Light1Position", "The position and aspect of the first cab light", "320 360 155 2")]
        public Vector4 Light1Position;

        [ORTSPhysics("First light ARGB", "Light1ColorARGB", "The color of the first cab light", "255 216 178 255")]
        public Color Light1Color;

        [ORTSPhysics("Second light Position", "Light2Position", "The position and aspect of the first cab light", "0 0 0 0")]
        public Vector4 Light2Position;

        [ORTSPhysics("Second light ARGB", "Light2ColorARGB", "The color of the second cab light", "0 0 0")]
        public Color Light2Color;

    } // End Class ExtendedCVF 
}