Merge branch 'tmj-dev'

Driver.h

@@ -282,17 +282,18 @@ private:
     int iOverheadZero = 0; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami
     int iOverheadDown = 0; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami
     double fVoltage = 0.0; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas
-  private:
+ private:
     double fMaxProximityDist = 50.0; // stawanie między 30 a 60 m przed przeszkodą // akceptowalna odległość stanięcia przed przeszkodą
     TStopReason eStopReason = stopSleep; // powód zatrzymania przy ustawieniu zerowej prędkości // na początku śpi
     std::string VehicleName;
     double fVelPlus = 0.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
     double fVelMinus = 0.0; // margines obniżenia prędkości, powodujący załączenie napędu
     double fWarningDuration = 0.0; // ile czasu jeszcze trąbić
-    double fStopTime = 0.0; // czas postoju przed dalszą jazdą (np. na przystanku)
     double WaitingTime = 0.0; // zliczany czas oczekiwania do samoistnego ruszenia
     double WaitingExpireTime = 31.0; // tyle ma czekać, zanim się ruszy // maksymlany czas oczekiwania do samoistnego ruszenia
     double IdleTime {}; // keeps track of time spent at a stop
+  public:
+    double fStopTime = 0.0; // czas postoju przed dalszą jazdą (np. na przystanku)
 
   private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---//
     void SetDriverPsyche();

DynObj.cpp

@@ -1010,19 +1010,19 @@ TDynamicObject * TDynamicObject::ABuFindNearestObject(TTrack *Track, TDynamicObj
 
         if( CouplNr == -2 ) {
             // wektor [kamera-obiekt] - poszukiwanie obiektu
-            if( LengthSquared3( Global.pCameraPosition - dynamic->vPosition ) < 100.0 ) {
+            if( Math3D::LengthSquared3( Global.pCameraPosition - dynamic->vPosition ) < 100.0 ) {
                 // 10 metrów
                 return dynamic;
             }
         }
         else {
             // jeśli (CouplNr) inne niz -2, szukamy sprzęgu
-            if( LengthSquared3( Global.pCameraPosition - dynamic->vCoulpler[ 0 ] ) < 25.0 ) {
+            if( Math3D::LengthSquared3( Global.pCameraPosition - dynamic->vCoulpler[ 0 ] ) < 25.0 ) {
                 // 5 metrów
                 CouplNr = 0;
                 return dynamic;
             }
-            if( LengthSquared3( Global.pCameraPosition - dynamic->vCoulpler[ 1 ] ) < 25.0 ) {
+            if( Math3D::LengthSquared3( Global.pCameraPosition - dynamic->vCoulpler[ 1 ] ) < 25.0 ) {
                 // 5 metrów
                 CouplNr = 1;
                 return dynamic;
@@ -3942,7 +3942,7 @@ void TDynamicObject::RenderSounds() {
     }
     // szum w czasie jazdy
     if( ( GetVelocity() > 0.5 )
-     && ( false == rsOuterNoise.empty() )
+     && ( false == m_bogiesounds.empty() )
      && ( // compound test whether the vehicle belongs to user-driven consist (as these don't emit outer noise in cab view)
             FreeFlyModeFlag ? true : // in external view all vehicles emit outer noise
             // Global.pWorld->train() == nullptr ? true : // (can skip this check, with no player train the external view is a given)
@@ -3951,19 +3951,20 @@ void TDynamicObject::RenderSounds() {
             Global.CabWindowOpen ? true : // sticking head out we get to hear outer noise
             false ) ) {
 
-            // frequency calculation
+        auto const &bogiesound { m_bogiesounds.front() };
-        auto const normalizer{ (
+        // frequency calculation
-            true == rsOuterNoise.is_combined() ?
+        auto const normalizer { (
+            true == bogiesound.is_combined() ?
                 MoverParameters->Vmax * 0.01f :
                 1.f ) };
         frequency =
-            rsOuterNoise.m_frequencyoffset
+            bogiesound.m_frequencyoffset
-            + rsOuterNoise.m_frequencyfactor * MoverParameters->Vel * normalizer;
+            + bogiesound.m_frequencyfactor * MoverParameters->Vel * normalizer;
 
         // volume calculation
         volume =
-            rsOuterNoise.m_amplitudeoffset +
+            bogiesound.m_amplitudeoffset +
-            rsOuterNoise.m_amplitudefactor * MoverParameters->Vel;
+            bogiesound.m_amplitudefactor * MoverParameters->Vel;
         if( brakeforceratio > 0.0 ) {
             // hamulce wzmagaja halas
             volume *= 1 + 0.125 * brakeforceratio;
@@ -3980,18 +3981,26 @@ void TDynamicObject::RenderSounds() {
                     0.0, 1.0 ) );
 
         if( volume > 0.05 ) {
-            rsOuterNoise
+            // apply calculated parameters to all motor instances
-                .pitch( frequency ) // arbitrary limits to prevent the pitch going out of whack
+            for( auto &bogiesound : m_bogiesounds ) {
-                .gain( volume )
+                bogiesound
-                .play( sound_flags::exclusive | sound_flags::looping );
+                    .pitch( frequency ) // arbitrary limits to prevent the pitch going out of whack
+                    .gain( volume )
+                    .play( sound_flags::exclusive | sound_flags::looping );
+            }
         }
         else {
-            rsOuterNoise.stop();
+            // stop all noise instances
+            for( auto &bogiesound : m_bogiesounds ) {
+                bogiesound.stop();
+            }
         }
     }
     else {
         // don't play the optional ending sound if the listener switches views
-        rsOuterNoise.stop( false == FreeFlyModeFlag );
+        for( auto &bogiesound : m_bogiesounds ) {
+            bogiesound.stop( false == FreeFlyModeFlag );
+        }
     }
     // flat spot sound
     if( MoverParameters->CategoryFlag == 1 ) {
@@ -4578,8 +4587,7 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
 							asAnimName = token + std::to_string( i + 1 );
 							pants[ i ].smElement[ 4 ] = mdModel->GetFromName( asAnimName );
 							pants[ i ].smElement[ 4 ]->WillBeAnimated();
-/*							pants[ i ].yUpdate = UpdatePant;
+							pants[ i ].yUpdate = std::bind( &TDynamicObject::UpdatePant, this, std::placeholders::_1 );
-*/							pants[ i ].yUpdate = std::bind( &TDynamicObject::UpdatePant, this, std::placeholders::_1 );
 							pants[ i ].fMaxDist = 300 * 300; // nie podnosić w większej odległości
 							pants[ i ].iNumber = i;
 						}
@@ -4777,8 +4785,6 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
                             pAnimations[i + j].fSpeed = (pAnimations[i + j].fSpeed + 100) / 100;
                             // Ra: te współczynniki są bez sensu, bo modyfikują wektor przesunięcia
                         }
-                        // create sound emitters for the door
-                        m_doorsounds.emplace_back();
                     }
                 }
 
@@ -4837,11 +4843,27 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
                 else if( ( token == "tractionmotor:" )
                       && ( MoverParameters->Power > 0 ) ) {
                     // plik z dzwiekiem silnika, mnozniki i ofsety amp. i czest.
-                    m_powertrainsounds.motor.deserialize( parser, sound_type::single, sound_parameters::range | sound_parameters::amplitude | sound_parameters::frequency );
+                    sound_source motortemplate { sound_placement::external };
-                    m_powertrainsounds.motor.owner( this );
+                    motortemplate.deserialize( parser, sound_type::single, sound_parameters::range | sound_parameters::amplitude | sound_parameters::frequency );
+                    motortemplate.owner( this );
 
                     auto const amplitudedivisor = static_cast<float>( MoverParameters->nmax * 60 + MoverParameters->Power * 3 );
-                    m_powertrainsounds.motor.m_amplitudefactor /= amplitudedivisor;
+                    motortemplate.m_amplitudefactor /= amplitudedivisor;
+
+                    if( true == m_powertrainsounds.motors.empty() ) {
+                        // fallback for cases without specified motor locations, convert sound template to a single sound source
+                        m_powertrainsounds.motors.emplace_back( motortemplate );
+                    }
+                    else {
+                        // apply configuration to all defined motors
+                        for( auto &motor : m_powertrainsounds.motors ) {
+                            // combine potential x- and y-axis offsets of the sound template with z-axis offsets of individual motors
+                            auto motoroffset { motortemplate.offset() };
+                            motoroffset.z = motor.offset().z;
+                            motor = motortemplate;
+                            motor.offset( motoroffset );
+                        }
+                    }
                 }
 
 				else if( token == "inverter:" ) {
@@ -4976,20 +4998,26 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
                 }
 
 				else if( token == "dooropen:" ) {
-                    sound_source dooropen { sound_placement::general };
+                    sound_source doortemplate { sound_placement::general };
-                    dooropen.deserialize( parser, sound_type::single );
+                    doortemplate.deserialize( parser, sound_type::single );
-                    dooropen.owner( this );
+                    doortemplate.owner( this );
                     for( auto &door : m_doorsounds ) {
-                        door.rsDoorOpen = dooropen;
+                        // apply configuration to all defined doors, but preserve their individual offsets
+                        auto const dooroffset { door.rsDoorOpen.offset() };
+                        door.rsDoorOpen = doortemplate;
+                        door.rsDoorOpen.offset( dooroffset );
                     }
                 }
 
 				else if( token == "doorclose:" ) {
-                    sound_source doorclose { sound_placement::general };
+                    sound_source doortemplate { sound_placement::general };
-                    doorclose.deserialize( parser, sound_type::single );
+                    doortemplate.deserialize( parser, sound_type::single );
-                    doorclose.owner( this );
+                    doortemplate.owner( this );
                     for( auto &door : m_doorsounds ) {
-                        door.rsDoorClose = doorclose;
+                        // apply configuration to all defined doors, but preserve their individual offsets
+                        auto const dooroffset { door.rsDoorClose.offset() };
+                        door.rsDoorClose = doortemplate;
+                        door.rsDoorClose.offset( dooroffset );
                     }
                 }
 
@@ -5016,11 +5044,27 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
 
                 else if( token == "outernoise:" ) {
                     // szum podczas jazdy:
-                    rsOuterNoise.deserialize( parser, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, MoverParameters->Vmax );
+                    sound_source noisetemplate { sound_placement::external, EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
-                    rsOuterNoise.owner( this );
+                    noisetemplate.deserialize( parser, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, MoverParameters->Vmax );
+                    noisetemplate.owner( this );
 
-                    rsOuterNoise.m_amplitudefactor /= ( 1 + MoverParameters->Vmax );
+                    noisetemplate.m_amplitudefactor /= ( 1 + MoverParameters->Vmax );
-                    rsOuterNoise.m_frequencyfactor /= ( 1 + MoverParameters->Vmax );
+                    noisetemplate.m_frequencyfactor /= ( 1 + MoverParameters->Vmax );
+
+                    if( true == m_bogiesounds.empty() ) {
+                        // fallback for cases without specified noise locations, convert sound template to a single sound source
+                        m_bogiesounds.emplace_back( noisetemplate );
+                    }
+                    else {
+                        // apply configuration to all defined bogies
+                        for( auto &bogie : m_bogiesounds ) {
+                            // combine potential x- and y-axis offsets of the sound template with z-axis offsets of individual motors
+                            auto bogieoffset { noisetemplate.offset() };
+                            bogieoffset.z = bogie.offset().z;
+                            bogie = noisetemplate;
+                            bogie.offset( bogieoffset );
+                        }
+                    }
                 }
 
                 else if( token == "wheelflat:" ) {
@@ -5034,6 +5078,76 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
 
         } // sounds:
 
+        else if( token == "locations:" ) {
+            do {
+                token = "";
+                parser.getTokens(); parser >> token;
+
+                if( token == "doors:" ) {
+                    // a list of pairs: offset along vehicle's z-axis and sides on which the door is present; followed with "end"
+                    while( ( ( token = parser.getToken<std::string>() ) != "" )
+                        && ( token != "end" ) ) {
+                        // vehicle faces +Z in 'its' space, for door locations negative value means ahead of centre
+                        auto const offset { std::atof( token.c_str() ) * -1.f };
+                        // recognized side specifications are "right", "left" and "both"
+                        auto const sides { parser.getToken<std::string>() };
+                        // NOTE: we skip setting owner of the sounds, it'll be done during individual sound deserialization
+                        door_sounds door;
+                        // add entries to the list:
+                        if( ( sides == "both" )
+                         || ( sides == "left" ) ) {
+                            // left...
+                            auto const location { glm::vec3 { MoverParameters->Dim.W * 0.5f, MoverParameters->Dim.H * 0.5f, offset } };
+                            door.rsDoorClose.offset( location );
+                            door.rsDoorOpen.offset( location );
+                            m_doorsounds.emplace_back( door );
+                        }
+                        if( ( sides == "both" )
+                         || ( sides == "right" ) ) {
+                            // ...and right
+                            auto const location { glm::vec3 { MoverParameters->Dim.W * -0.5f, MoverParameters->Dim.H * 0.5f, offset } };
+                            door.rsDoorClose.offset( location );
+                            door.rsDoorOpen.offset( location );
+                            m_doorsounds.emplace_back( door );
+                        }
+                    }
+                }
+
+                else if( token == "tractionmotors:" ) {
+                    // a list of offsets along vehicle's z-axis; followed with "end"
+                    while( ( ( token = parser.getToken<std::string>() ) != "" )
+                        && ( token != "end" ) ) {
+                        // vehicle faces +Z in 'its' space, for motor locations negative value means ahead of centre
+                        auto const offset { std::atof( token.c_str() ) * -1.f };
+                        // NOTE: we skip setting owner of the sounds, it'll be done during individual sound deserialization
+                        sound_source motor { sound_placement::external }; // generally traction motor
+                        // add entry to the list
+                        auto const location { glm::vec3 { 0.f, 0.f, offset } };
+                        motor.offset( location );
+                        m_powertrainsounds.motors.emplace_back( motor );
+                    }
+                }
+
+                else if( token == "bogies:" ) {
+                    // a list of offsets along vehicle's z-axis; followed with "end"
+                    while( ( ( token = parser.getToken<std::string>() ) != "" )
+                        && ( token != "end" ) ) {
+                        // vehicle faces +Z in 'its' space, for bogie locations negative value means ahead of centre
+                        auto const offset { std::atof( token.c_str() ) * -1.f };
+                        // NOTE: we skip setting owner of the sounds, it'll be done during individual sound deserialization
+                        sound_source bogienoise { sound_placement::external, EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
+                        // add entry to the list
+                        auto const location { glm::vec3 { 0.f, 0.f, offset } };
+                        bogienoise.offset( location );
+                        m_bogiesounds.emplace_back( bogienoise );
+                    }
+                }
+
+            } while( ( token != "" )
+                  && ( token != "endlocations" ) );
+
+        } // locations:
+
         else if( token == "internaldata:" ) {
             // dalej nie czytaj
             do {
@@ -5247,25 +5361,13 @@ void TDynamicObject::LoadMMediaFile( std::string BaseDir, std::string TypeName,
         // zliczanie wcześniejszych animacji
         dooranimationfirstindex += iAnimType[ i ];
     }
-    std::size_t doorindex { 0 };
-    for( auto &doorsounds : m_doorsounds ) {
-
-        auto submodel { pAnimations[ dooranimationfirstindex + doorindex ].smAnimated };
-        if( submodel == nullptr ) { continue; }
-
-        auto const dooroffset { pAnimations[ dooranimationfirstindex + doorindex ].smAnimated->offset( std::numeric_limits<float>::max() ) };
-
-        doorsounds.rsDoorClose.offset( dooroffset );
-        doorsounds.rsDoorOpen.offset( dooroffset );
-        ++doorindex;
-    }
     // couplers
     auto const frontcoupleroffset { glm::vec3{ 0.f, 1.f, MoverParameters->Dim.L * 0.5f } };
     m_couplersounds[ side::front ].dsbCouplerAttach.offset( frontcoupleroffset );
     m_couplersounds[ side::front ].dsbCouplerDetach.offset( frontcoupleroffset );
     m_couplersounds[ side::front ].dsbCouplerStretch.offset( frontcoupleroffset );
     m_couplersounds[ side::front ].dsbBufferClamp.offset( frontcoupleroffset );
-    auto const rearcoupleroffset{ glm::vec3{ 0.f, 1.f, MoverParameters->Dim.L * -0.5f } };
+    auto const rearcoupleroffset { glm::vec3{ 0.f, 1.f, MoverParameters->Dim.L * -0.5f } };
     m_couplersounds[ side::rear ].dsbCouplerAttach.offset( rearcoupleroffset );
     m_couplersounds[ side::rear ].dsbCouplerDetach.offset( rearcoupleroffset );
     m_couplersounds[ side::rear ].dsbCouplerStretch.offset( rearcoupleroffset );
@@ -5961,10 +6063,12 @@ TDynamicObject::powertrain_sounds::render( TMoverParameters const &Vehicle, doub
     // motor sounds
     volume = 0.0;
     if( ( true == Vehicle.Mains )
-     && ( false == Vehicle.dizel_enginestart ) ) {
+     && ( false == Vehicle.dizel_enginestart )
+     && ( false == motors.empty() ) ) {
 
         if( std::fabs( Vehicle.enrot ) > 0.01 ) {
 
+            auto const &motor { motors.front() };
             // frequency calculation
             auto normalizer { 1.f };
             if( true == motor.is_combined() ) {
@@ -6026,19 +6130,28 @@ TDynamicObject::powertrain_sounds::render( TMoverParameters const &Vehicle, doub
             volume *= std::max( 0.25f, motor_momentum );
 
             if( motor_volume >= 0.05 ) {
-                motor
+                // apply calculated parameters to all motor instances
-                    .pitch( frequency )
+                for( auto &motor : motors ) {
-                    .gain( motor_volume )
+                    motor
-                    .play( sound_flags::exclusive | sound_flags::looping );
+                        .pitch( frequency )
+                        .gain( motor_volume )
+                        .play( sound_flags::exclusive | sound_flags::looping );
+                }
             }
         }
         else {
-            motor.stop();
+            // stop all motor instances
+            for( auto &motor : motors ) {
+                motor.stop();
+            }
         }
     }
     motor_volume = interpolate( motor_volume, volume, 0.25 );
     if( motor_volume < 0.05 ) {
-        motor.stop();
+        // stop all motor instances
+        for( auto &motor : motors ) {
+            motor.stop();
+        }
     }
     // inverter sounds
     if( Vehicle.EngineType == ElectricInductionMotor ) {

DynObj.h

@@ -303,7 +303,7 @@ private:
 
     struct powertrain_sounds {
         sound_source inverter { sound_placement::engine };
-        sound_source motor { sound_placement::external }; // generally traction motor
+        std::vector<sound_source> motors; // generally traction motor(s)
         double motor_volume { 0.0 }; // MC: pomocnicze zeby gladziej silnik buczal
         float motor_momentum { 0.f }; // recent change in motor revolutions
         sound_source motor_relay { sound_placement::engine };
@@ -395,7 +395,7 @@ private:
     sound_source sDepartureSignal { sound_placement::general };
     sound_source sHorn1 { sound_placement::external, 5 * EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
     sound_source sHorn2 { sound_placement::external, 5 * EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
-    sound_source rsOuterNoise { sound_placement::external, EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
+    std::vector<sound_source> m_bogiesounds; // TBD, TODO: wrapper for all bogie-related sounds (noise, brakes, squeal etc)
     sound_source m_wheelflat { sound_placement::external, EU07_SOUND_RUNNINGNOISECUTOFFRANGE };
     sound_source rscurve { sound_placement::external, EU07_SOUND_RUNNINGNOISECUTOFFRANGE }; // youBy
     sound_source rsDerailment { sound_placement::external, 250.f }; // McZapkie-051202

McZapkie/MOVER.h

@@ -1067,8 +1067,6 @@ public:
 	double TotalMassxg = 0.0; /*TotalMass*g*/
 
 	Math3D::vector3 vCoulpler[2]; // powtórzenie współrzędnych sprzęgów z DynObj :/
-	Math3D::vector3 DimHalf; // połowy rozmiarów do obliczeń geometrycznych
-					 // int WarningSignal; //0: nie trabi, 1,2: trabi syreną o podanym numerze
 	int WarningSignal = 0; // tymczasowo 8bit, ze względu na funkcje w MTools
 	double fBrakeCtrlPos = -2.0; // płynna nastawa hamulca zespolonego
 	bool bPantKurek3 = true; // kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z małą sprężarką // domyślnie zbiornik pantografu połączony jest ze zbiornikiem głównym

McZapkie/Mover.cpp

@@ -303,9 +303,6 @@ Name( NameInit )
     WriteLog("init default physic values for " + NameInit + ", [" + TypeNameInit + "], [" +
              LoadTypeInitial + "]");
     Dim = TDimension();
-    DimHalf.x = 0.5 * Dim.W; // połowa szerokości, OX jest w bok?
-    DimHalf.y = 0.5 * Dim.L; // połowa długości, OY jest do przodu?
-    DimHalf.z = 0.5 * Dim.H; // połowa wysokości, OZ jest w górę?
 
     // BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odcięcie (CHK jest jeszcze nie wczytane!)
     iLights[ 0 ] = 0;
@@ -6238,17 +6235,12 @@ bool TMoverParameters::Physic_ReActivation(void) // DO PRZETLUMACZENIA NA KONCU
 // *************************************************************************************************
 // FUNKCJE PARSERA WCZYTYWANIA PLIKU FIZYKI POJAZDU
 // *************************************************************************************************
-std::string p0, p1, p2, p3, p4, p5, p6, p7;
-std::string vS;
-int vI;
-double vD;
 bool startBPT;
 bool startMPT, startMPT0;
 bool startRLIST;
 bool startDLIST, startFFLIST, startWWLIST;
 bool startLIGHTSLIST;
 int LISTLINE;
-std::vector<std::string> x;
 
 // *************************************************************************************************
 // Q: 20160717
@@ -7058,6 +7050,7 @@ void TMoverParameters::LoadFIZ_Dimensions( std::string const &line ) {
     extract_value( Dim.L, "L", line, "" );
     extract_value( Dim.H, "H", line, "" );
     extract_value( Dim.W, "W", line, "" );
+
     extract_value( Cx, "Cx", line, "0.3" );
     if( Dim.H <= 2.0 ) {
         //gdyby nie było parametru, lepsze to niż zero

Train.cpp

@@ -204,6 +204,9 @@ TTrain::commandhandler_map const TTrain::m_commandhandlers = {
     { user_command::mubrakingindicatortoggle, &TTrain::OnCommand_mubrakingindicatortoggle },
     { user_command::reverserincrease, &TTrain::OnCommand_reverserincrease },
     { user_command::reverserdecrease, &TTrain::OnCommand_reverserdecrease },
+    { user_command::reverserforward, &TTrain::OnCommand_reverserforward },
+    { user_command::reverserneutral, &TTrain::OnCommand_reverserneutral },
+    { user_command::reverserbackward, &TTrain::OnCommand_reverserbackward },
     { user_command::alerteracknowledge, &TTrain::OnCommand_alerteracknowledge },
     { user_command::batterytoggle, &TTrain::OnCommand_batterytoggle },
     { user_command::batteryenable, &TTrain::OnCommand_batteryenable },
@@ -1398,6 +1401,61 @@ void TTrain::OnCommand_reverserdecrease( TTrain *Train, command_data const &Comm
     }
 }
 
+void TTrain::OnCommand_reverserforward( TTrain *Train, command_data const &Command ) {
+
+    if( Command.action == GLFW_PRESS ) {
+
+        if( Train->mvOccupied->ActiveDir < 1 ) {
+
+            while( ( Train->mvOccupied->ActiveDir < 1 )
+                && ( true == Train->mvOccupied->DirectionForward() ) ) {
+                // all work is done in the header
+            }
+            // aktualizacja skrajnych pojazdów w składzie
+            if( ( Train->mvOccupied->ActiveDir == 1 )
+             && ( Train->DynamicObject->Mechanik ) ) {
+
+                Train->DynamicObject->Mechanik->CheckVehicles( Change_direction );
+            }
+        }
+    }
+}
+
+void TTrain::OnCommand_reverserneutral( TTrain *Train, command_data const &Command ) {
+
+    if( Command.action == GLFW_PRESS ) {
+
+        while( ( Train->mvOccupied->ActiveDir < 0 )
+            && ( true == Train->mvOccupied->DirectionForward() ) ) {
+            // all work is done in the header
+        }
+        while( ( Train->mvOccupied->ActiveDir > 0 )
+            && ( true == Train->mvOccupied->DirectionBackward() ) ) {
+            // all work is done in the header
+        }
+    }
+}
+
+void TTrain::OnCommand_reverserbackward( TTrain *Train, command_data const &Command ) {
+
+    if( Command.action == GLFW_PRESS ) {
+
+        if( Train->mvOccupied->ActiveDir > -1 ) {
+
+            while( ( Train->mvOccupied->ActiveDir > -1 )
+                && ( true == Train->mvOccupied->DirectionBackward() ) ) {
+                // all work is done in the header
+            }
+            // aktualizacja skrajnych pojazdów w składzie
+            if( ( Train->mvOccupied->ActiveDir == -1 )
+             && ( Train->DynamicObject->Mechanik ) ) {
+
+                Train->DynamicObject->Mechanik->CheckVehicles( Change_direction );
+            }
+        }
+    }
+}
+
 void TTrain::OnCommand_alerteracknowledge( TTrain *Train, command_data const &Command ) {
 
     if( Command.action == GLFW_PRESS ) {
@@ -5770,8 +5828,8 @@ void TTrain::clear_cab_controls()
     btLampkaOgrzewanieSkladu.Clear(11);
     btHaslerBrakes.Clear(12); // ciśnienie w cylindrach do odbijania na haslerze
     btHaslerCurrent.Clear(13); // prąd na silnikach do odbijania na haslerze
-    // Jeśli ustawiamy nową wartość dla PoKeys wolna jest 15
     // Numer 14 jest używany dla buczka SHP w update_sounds()
+    // Jeśli ustawiamy nową wartość dla PoKeys wolna jest 15
 
     // other cab controls
     // TODO: arrange in more readable manner, and eventually refactor

Train.h

@@ -195,6 +195,9 @@ class TTrain
     static void OnCommand_mubrakingindicatortoggle( TTrain *Train, command_data const &Command );
     static void OnCommand_reverserincrease( TTrain *Train, command_data const &Command );
     static void OnCommand_reverserdecrease( TTrain *Train, command_data const &Command );
+    static void OnCommand_reverserforward( TTrain *Train, command_data const &Command );
+    static void OnCommand_reverserneutral( TTrain *Train, command_data const &Command );
+    static void OnCommand_reverserbackward( TTrain *Train, command_data const &Command );
     static void OnCommand_alerteracknowledge( TTrain *Train, command_data const &Command );
     static void OnCommand_batterytoggle( TTrain *Train, command_data const &Command );
     static void OnCommand_batteryenable( TTrain *Train, command_data const &Command );

World.cpp

@@ -1216,9 +1216,15 @@ TWorld::Update_UI() {
                         " Pressure: " + to_string( mover->BrakePress * 100.0, 2 ) + " kPa"
                         + " (train pipe: " + to_string( mover->PipePress * 100.0, 2 ) + " kPa)";
 
-                    auto const trackblockdistance{ std::abs( Controlled->Mechanik->TrackBlock() ) };
+                    auto const stoptime { static_cast<int>( -1.0 * Controlled->Mechanik->fStopTime ) };
-                    if( trackblockdistance <= 75.0 ) {
+                    if( stoptime > 0 ) {
-                        uitextline4 += " Another vehicle ahead (distance: " + to_string( trackblockdistance, 1 ) + " m)";
+                        uitextline4 += " Loading/unloading in progress (" + to_string( stoptime ) + ( stoptime > 1 ? " seconds" : " second" ) + " left)";
+                    }
+                    else {
+                        auto const trackblockdistance{ std::abs( Controlled->Mechanik->TrackBlock() ) };
+                        if( trackblockdistance <= 75.0 ) {
+                            uitextline4 += " Another vehicle ahead (distance: " + to_string( trackblockdistance, 1 ) + " m)";
+                        }
                     }
                 }
             }
@@ -1372,7 +1378,7 @@ TWorld::Update_UI() {
                 if( ( vehicle->MoverParameters->BrakeDelayFlag & bdelay_M ) == bdelay_M )
                     uitextline2 += "+Mg";
 
-                uitextline2 += ", Load: " + to_string( vehicle->MoverParameters->LoadFlag, 0 ) + " (" + to_string( vehicle->MoverParameters->Load, 0 ) + ")";
+                uitextline2 += ", Load: " + to_string( vehicle->MoverParameters->Load, 0 ) + " (" + to_string( vehicle->MoverParameters->LoadFlag, 0 ) + ")";
 
                 uitextline2 +=
                     "; Pant: "

color.h

@@ -4,6 +4,7 @@ namespace colors {
 
 glm::vec4 const none{ 0.f, 0.f, 0.f, 1.f };
 glm::vec4 const white{ 1.f, 1.f, 1.f, 1.f };
+glm::vec4 const shadow{ 0.65f, 0.65f, 0.65f, 1.f };
 
 inline
 glm::vec3

command.cpp

@@ -60,6 +60,9 @@ commanddescription_sequence Commands_descriptions = {
     { "sandboxactivate", command_target::vehicle },
     { "reverserincrease", command_target::vehicle },
     { "reverserdecrease", command_target::vehicle },
+    { "reverserforward", command_target::vehicle },
+    { "reverserneutral", command_target::vehicle },
+    { "reverserbackward", command_target::vehicle },
     { "linebreakertoggle", command_target::vehicle },
     { "linebreakeropen", command_target::vehicle },
     { "linebreakerclose", command_target::vehicle },

command.h

@@ -55,6 +55,9 @@ enum class user_command {
     sandboxactivate,
     reverserincrease,
     reverserdecrease,
+    reverserforward,
+    reverserneutral,
+    reverserbackward,
     linebreakertoggle,
     linebreakeropen,
     linebreakerclose,

keyboardinput.cpp

@@ -249,6 +249,12 @@ keyboard_input::default_bindings() {
         { GLFW_KEY_D },
         // reverserdecrease
         { GLFW_KEY_R },
+        // reverserforward
+        { -1 },
+        // reverserneutral
+        { -1 },
+        // reverserbackward
+        { -1 },
         // linebreakertoggle
         { GLFW_KEY_M },
         // linebreakeropen

renderer.cpp

@@ -1401,18 +1401,18 @@ opengl_renderer::Render( world_environment *Environment ) {
 
     // calculate shadow tone, based on positions of celestial bodies
     m_shadowcolor = interpolate(
-        glm::vec4{ 0.5f, 0.5f, 0.5f, 1.f },
+        glm::vec4{ colors::shadow },
         glm::vec4{ colors::white },
         clamp( -Environment->m_sun.getAngle(), 0.f, 6.f ) / 6.f );
     if( ( Environment->m_sun.getAngle() < -18.f )
      && ( Environment->m_moon.getAngle() > 0.f ) ) {
         // turn on moon shadows after nautical twilight, if the moon is actually up
-        m_shadowcolor = glm::vec4{ 0.5f, 0.5f, 0.5f, 1.f };
+        m_shadowcolor = colors::shadow;
     }
     // soften shadows depending on sky overcast factor
     m_shadowcolor = glm::min(
         colors::white,
-        m_shadowcolor + glm::vec4{ glm::vec3{ 0.5f * Global.Overcast }, 1.f } );
+        m_shadowcolor + ( ( colors::white - colors::shadow ) * Global.Overcast ) );
 
     if( Global.bWireFrame ) {
         // bez nieba w trybie rysowania linii

renderer.h

@@ -372,7 +372,7 @@ private:
     std::string m_debugstatstext;
 
     glm::vec4 m_baseambient { 0.0f, 0.0f, 0.0f, 1.0f };
-    glm::vec4 m_shadowcolor { 0.65f, 0.65f, 0.65f, 1.f };
+    glm::vec4 m_shadowcolor { colors::shadow };
 //    TEnvironmentType m_environment { e_flat };
     float m_specularopaquescalefactor { 1.f };
     float m_speculartranslucentscalefactor { 1.f };

uart.cpp

@@ -239,9 +239,9 @@ void uart_input::poll()
 	    uint16_t pipe_press = (uint16_t)std::min(conf.pipeuart, trainstate.pipe_pressure * 0.1f / conf.pipemax * conf.pipeuart);
 	    uint16_t brake_press = (uint16_t)std::min(conf.brakeuart, trainstate.brake_pressure * 0.1f / conf.brakemax * conf.brakeuart);
 	    uint16_t hv_voltage = (uint16_t)std::min(conf.hvuart, trainstate.hv_voltage / conf.hvmax * conf.hvuart);
-	    uint16_t current1 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[0]) / conf.currentmax * conf.currentuart;
+	    uint16_t current1 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[0] / conf.currentmax * conf.currentuart);
-	    uint16_t current2 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[1]) / conf.currentmax * conf.currentuart;
+	    uint16_t current2 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[1] / conf.currentmax * conf.currentuart);
-	    uint16_t current3 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[2]) / conf.currentmax * conf.currentuart;
+	    uint16_t current3 = (uint16_t)std::min(conf.currentuart, trainstate.hv_current[2] / conf.currentmax * conf.currentuart);
 
 	    std::array<uint8_t, 31> buffer {
             //byte 0
@@ -250,7 +250,7 @@ void uart_input::poll()
 	        0,
             //byte 2
 			(uint8_t)(
-                trainstate.motor_resistors << 1
+                trainstate.ventilator_overload << 1
               | trainstate.motor_overload_threshold << 2),
             //byte 3
 			0,
@@ -269,15 +269,26 @@ void uart_input::poll()
               | trainstate.line_breaker << 5
               | trainstate.compressor_overload << 6),
             //byte 6
-			(uint8_t)( trainstate.alerter_sound << 7),
+			(uint8_t)(
-	        SPLIT_INT16(brake_press), //byte 7-8
+                trainstate.recorder_braking << 3
-	        SPLIT_INT16(pipe_press), //byte 9-10
+              | trainstate.recorder_power << 4
-	        SPLIT_INT16(tank_press), //byte 11-12
+              | trainstate.alerter_sound << 7),
-	        SPLIT_INT16(hv_voltage), //byte 13-14
+            //byte 7-8
-	        SPLIT_INT16(current1), //byte 15-16
+	        SPLIT_INT16(brake_press),
-	        SPLIT_INT16(current2), //byte 17-18
+            //byte 9-10
-	        SPLIT_INT16(current3), //byte 19-20
+	        SPLIT_INT16(pipe_press),
-			0, 0, 0, 0, 0, 0, 0, 0, 0, 0 //byte 21-30
+            //byte 11-12
+	        SPLIT_INT16(tank_press),
+            //byte 13-14
+	        SPLIT_INT16(hv_voltage),
+            //byte 15-16
+	        SPLIT_INT16(current1),
+            //byte 17-18
+	        SPLIT_INT16(current2),
+            //byte 19-20
+	        SPLIT_INT16(current3),
+            //byte 21-30
+			0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 	    };
 
 		if (conf.debug)

version.h

@@ -1,5 +1,5 @@
 #pragma once
 
 #define VERSION_MAJOR 18
-#define VERSION_MINOR 223
+#define VERSION_MINOR 309
 #define VERSION_REVISION 0