diff --git a/.github/workflows/build_bin.yml b/.github/workflows/build_bin.yml index 2f1781ed8..d37817d5c 100644 --- a/.github/workflows/build_bin.yml +++ b/.github/workflows/build_bin.yml @@ -45,6 +45,15 @@ jobs: python-version: "3.14" architecture: "x64" + # the cab screens are drawn with Pillow; CMake copies this Python's Lib, site-packages included, next to the + # executable as python64\Lib, so Pillow has to be installed here to come with the build (as on Linux) + - name: Install Pillow for the screens + shell: pwsh + run: | + $pythonExe = "${{ steps.python.outputs.python-path }}" + & $pythonExe -m pip install --no-cache-dir Pillow + & $pythonExe -c "from PIL import Image; print('Pillow:', Image.__version__)" + - name: Show environment shell: pwsh run: | @@ -114,6 +123,18 @@ jobs: -Recurse ` -Force + # the Python 3 version of the module every cab screen builds on; the game data still has the Python 2 one + New-Item ` + -ItemType Directory ` + -Force ` + -Path "$output/python/local" | Out-Null + + Copy-Item ` + -Path "staticFiles/python/local/*" ` + -Destination "$output/python/local" ` + -Recurse ` + -Force + - name: Upload Windows build uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 with: @@ -251,9 +272,11 @@ jobs: - name: Copy shaders and translations run: | - mkdir -p build/bin/shaders build/bin/lang + mkdir -p build/bin/shaders build/bin/lang build/bin/python/local cp -R shaders/. build/bin/shaders/ cp -R lang/. build/bin/lang/ + # the Python 3 version of the module every cab screen builds on; the game data still has the Python 2 one + cp -R staticFiles/python/local/. build/bin/python/local/ - name: Upload Linux build uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 diff --git a/CMakeLists.txt b/CMakeLists.txt index de0f8c836..7137ab39a 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -464,6 +464,7 @@ set(CORE_SOURCES "utilities/utilities.cpp" "scripting/ladderlogic.cpp" "simulation/simulationtestrules.cpp" +"vehicle/enginestart.cpp" "vehicle/handover.cpp" "vehicle/horn.cpp" "vehicle/linebreaker.cpp" @@ -741,4 +742,4 @@ if(WITH_TESTS) # Visual Studio builds rerun them with the next change of the game) set_property(TARGET ${PROJECT_NAME} APPEND PROPERTY LINK_DEPENDS $ ${UNIT_TEST_DATA} "${CMAKE_CURRENT_SOURCE_DIR}/tests/unit/run_tests.cmake") -endif() \ No newline at end of file +endif() diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index a1a102075..62080b870 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -10,7 +10,9 @@ http://mozilla.org/MPL/2.0/. #pragma once //--------------------------------------------------------------------------- // Q: 20160805 - odlaczenie pliku fizyki .pas od kompilacji +#include #include +#include #include "hamulce.h" #include "scripting/ladderlogic.h" @@ -340,6 +342,21 @@ enum light highbeamlight_right = 1 << 10 }; +/// The cab interior light a position of the light preset selector sets (eu07/maszyna#529). +struct lights_preset_cablight +{ + /// Bits of the optional third column of a LightsList row. + enum flag + { + /// The cab light is on. + light_on = 1 << 0, + /// The cab light is dimmed. + light_dimmed = 1 << 1 + }; + bool light{false}; + bool dim{false}; +}; + /// Door operation method (who controls them and how) — mutually exclusive. enum control_t { @@ -1147,6 +1164,7 @@ class TSecuritySystem bool is_sifa = false; // Sifa-like pedal device, with inverted input for convenient keyboard usage bool separate_acknowledge = false; // cabsignal reset button is separate from vigilance bool cabsignal_lock = false; + bool vigilance_suspended = false; // the vigilance device switched off by the shunt mode of the vehicle, see AwareOffInShuntMode double vigilance_timer = 0.0; double alert_timer = 0.0; @@ -1162,6 +1180,7 @@ class TSecuritySystem double EmergencyBrakeDelay = 5.0; double MaxHoldTime = 1.5; bool CabDependent = false; + bool AwareOffInShuntMode = false; // the shunt mode of the vehicle switches the vigilance device off, as on the SM42 public: void set_enabled(bool e); @@ -1171,6 +1190,7 @@ class TSecuritySystem void update(double dt, double Vel, bool pwr, int cab); void set_cabsignal(); void set_cabsignal_lock(bool); + void set_shunt_mode(bool State); bool is_blinking() const; bool is_vigilance_blinking() const; bool is_cabsignal_blinking() const; @@ -1607,6 +1627,9 @@ class TMoverParameters double EpForce = 0.0; /*Poziom zadanej sily EP*/ bool Signalling = false; /*Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu*/ bool Radio = false; /*Czy jest zalaczony radiotelefon*/ + // the cut-off in the radio's power supply: a fuse in the cabinet, a lever on the desk or the switch on the radio's power + // supply (eu07/maszyna#438). Closed unless the driver opens it, so vehicles without such a switch work as before + bool RadioFuse = true; float NominalBatteryVoltage = 0.f; /*Winger - baterie w elektrykach*/ TDimension Dim; /*wymiary*/ double Cx = 0.0; /*wsp. op. aerodyn.*/ @@ -1720,6 +1743,13 @@ class TMoverParameters int LightsDefPos = 1; bool LightsWrap = false; int Lights[2][18]; // pozycje świateł, przód - tył, 1 .. 16 (17 do lightsset) + // the cab interior light each light preset sets, from the optional third column of LightsList (bits of + // lights_preset_cablight::flag); -1: the preset leaves the cab light as it is (eu07/maszyna#529) + std::array LightsCabLight{[] { + std::array positions; + positions.fill(-1); + return positions; + }()}; int ScndInMain{0}; /*zaleznosc bocznika od nastawnika*/ bool MBrake = false; /*Czy jest hamulec reczny*/ double maxTachoSpeed = {0.0}; // maksymalna predkosc na tarczce predkosciomierza analogowego @@ -1744,6 +1774,10 @@ class TMoverParameters bool UniCtrlIntegratedBrakeCtrl = false; /*zintegrowany nastawnik JH obsluguje hamowanie*/ bool UniCtrlIntegratedLocalBrakeCtrl = false; /*zintegrowany nastawnik JH obsluguje hamowanie hamulcem pomocniczym*/ int UniCtrlNoPowerPos{0}; // cached highesr position not generating traction force + // UCList CtrlValStep: the universal controller (EIMCtrlType 3) changes its setting in steps of this size (e.g. 0.05 for the + // 5% steps of the 6Dg), one at once when moved to a raising or lowering position, then one each time its SpeedUp / SpeedDown + // covers a step; 0 (the default) changes it continuously + double UniCtrlValStep{0.0}; std::pair> PantsPreset{"0132", {0, 0}}; // pantograph preset switches; .first holds possible setups as chars, .second holds currently selected preset in each cab /*-sekcja parametrow dla lokomotywy elektrycznej*/ @@ -1960,6 +1994,7 @@ class TMoverParameters double MirrorVelClose{5.0}; bool MirrorForbidden{false}; /*czy jest pozwolenie na otworzenie lusterek (przycisk)*/ bool ScndS = false; /*Czy jest bocznikowanie na szeregowej*/ + bool ScndCtrlResistiveLock{false}; // the shunt controller can't be moved, up or down, while the master controller is at zero or on a resistive position, and drops to 0 when the master controller gets there (ScndCtrlResistiveLock=Yes in Cntrl.) bool SpeedCtrl = false; /*czy jest tempomat*/ speed_control SpeedCtrlUnit; /*parametry tempomatu*/ double SpeedCtrlButtons[10]{30, 40, 50, 60, 70, 80, 90, 100, 110, 120}; /*przyciski prędkości*/ @@ -2110,6 +2145,9 @@ class TMoverParameters double MainsInitTime{0.0}; // config, initialization time (in seconds) of the main circuit after it receives power, before it can be closed double MainsInitTimeCountdown{0.0}; // current state of main circuit initialization, remaining time (in seconds) until it's ready start_t MainsStart{start_t::manual}; + // config, Engine:JointEngineStart. whether the cab's line breaker / engine start switch works the vehicles in multiple + // too; when it doesn't, the cab has separate switches for them (mainb_*, mainc_*) + bool JointEngineStart{true}; bool LineBreakerClosesOnlyAtNoPowerPos{false}; bool ControlPressureSwitch{false}; // activates if the main pipe and/or brake cylinder pressure aren't within operational levels bool HasControlPressureSwitch{true}; @@ -2188,6 +2226,10 @@ class TMoverParameters bool dizel_startup{false}; // engine startup procedure request indicator bool dizel_ignition{false}; // engine ignition request indicator bool dizel_spinup{false}; // engine spin up to idle speed flag + // the starter turns the engine a while before it fires: smoke comes out only after SmokeDelay (the Engine section of the vehicle's + // .fiz, seconds from the start of the spin up) has passed. 0, the default, lets it out as soon as the starter turns, as before eu07/maszyna#523 + double dizel_SmokeDelay{0.0}; + double dizel_FiringCountdown{0.0}; // seconds left until the engine being started fires, 0 once it runs on its own double dizel_engagedeltaomega = 0.0; /*roznica predkosci katowych tarcz sprzegla*/ double dizel_n_old = 0.0; /*poredkosc na potrzeby obliczen sprzegiel*/ double dizel_Torque = 0.0; /*aktualny moment obrotowy silnika spalinowego*/ @@ -2216,6 +2258,7 @@ class TMoverParameters double eimic = 0; /*aktualna pozycja zintegrowanego sterowania jazda i hamowaniem*/ double eimic_analog = 0; /*pozycja zadajnika analogowa*/ double eimic_real = 0; /*faktycznie uzywana pozycja zintegrowanego sterowania jazda i hamowaniem*/ + double eimic_step_progress{0.0}; // the part of the next UniCtrlValStep the controller has covered so far double eim_localbrake = 0; /*nastawa hamowania dodatkowego pneumatycznego lokomotywy*/ int EIMCtrlType = 0; /*rodzaj wariantu zadajnika jazdy*/ bool SpeedCtrlTypeTime = false; /*czy tempomat sterowany czasowo*/ @@ -2303,6 +2346,14 @@ class TMoverParameters // bool modernContainOffPos{true}; bool enableModernDimmer{false}; bool modernDimmerCanCycle{false}; + // the given dimmer position brought into the DimmerList, to its first or last entry; 0 for an empty list + int clampDimmerPosition(int Position) const; + // the entry of the current dimmer position, or a plain one (not off, not dimmed, no high beam) when the + // position is outside the DimmerList: the .fiz can give a short or an empty list, or a DefaultPos past its end + dimPosition currentDimPosition() const; + // moves the dimmer by Step positions within the DimmerList, around to its other end when it can cycle; + // a position outside the list is brought into it first. false when the dimmer doesn't move + bool stepDimmerPosition(int Step); // Barwa reflektora int refR{255}; // Czerwony @@ -2317,6 +2368,9 @@ class TMoverParameters plc::basic_controller m_plc; int AIHintPantstate{0}; // suggested pantograph setup + // suggested pantograph setup in shunting (AI: ShuntPantstate=, eu07/maszyna#461), the bits as in Pantstate: 1 front, + // 2 rear, 3 both; 0 (the default) shunts with the pantographs handled as in train mode + int AIHintShuntPantstate{0}; bool AIHintPantUpIfIdle{true}; // whether raise both pantographs if idling for a while double AIHintLocalBrakeAccFactor{1.05}; // suggested acceleration weight for local brake operation @@ -2389,6 +2443,11 @@ class TMoverParameters bool IncScndCtrl(int CtrlSpeed); bool DecScndCtrl(int CtrlSpeed); int GetVirtualScndPos() const; + // whether ScndCtrlResistiveLock keeps the shunt controller from being moved at the current master controller position + bool IsScndCtrlLockedByMainCtrl() const; + // ScndCtrlResistiveLock: the shunt controller drops to 0 once the master controller is at zero or on a resistive position, so it + // can't stay engaged there, locked in place (eu07/maszyna#402) + void ScndCtrlResistiveLockCheck(); bool IsScndCtrlNoPowerPos() const; bool IsScndCtrlMaxPowerPos() const; @@ -2430,6 +2489,8 @@ class TMoverParameters bool BrakeReleaser(int state); bool UniversalBrakeButton(int button, int state); /*uniwersalny przycisk hamulca*/ bool SwitchEPBrake(int state); + // whether the EP brake control of the cab has power: battery, the reverser out of neutral and the EP fuse on + bool EPBrakeControlPowered() const; bool AntiSlippingButton(void); /*! reczny wlacznik urzadzen antyposlizgowych*/ /*funkcje dla ukladow pneumatycznych*/ @@ -2470,6 +2531,14 @@ class TMoverParameters // whether the automatic couplers at the End of this vehicle and the OtherEnd of the other one can catch each other on // contact, rather than the vehicles colliding (with crash damage enabled, only at a closing speed which doesn't derail them) bool AutomaticCouplingSafe(int const End, TMoverParameters const &Other, int const OtherEnd) const; + // whether the control coupling (multiple-unit control) can join the End of this vehicle and the OtherEnd of the other + // one: not between an electric and a diesel traction vehicle, unless both couplers name the same control system + // (ControlType). Vehicles without own traction (cars, control trailers) take any. Global.control_coupling_engine_check + // off allows it always (eu07/maszyna#520) + bool ControlCouplingAllowed(int const End, TMoverParameters const &Other, int const OtherEnd) const; + // the CouplingType to join the End of this vehicle and the OtherEnd of the other one with, without the control coupling + // when ControlCouplingAllowed() rules it out. a permanent coupling (of the vehicles of one unit) is kept whole + int CompatibleCoupling(int const End, TMoverParameters const &Other, int const OtherEnd, int const CouplingType) const; // the horns of the Signal (WarningSignal bits) which have the air or the voltage they need to sound int SoundingHorns(int const Signal) const; // whether the signal lamps of the main circuit (line contactors, ground relay, motor overload relays) can light: @@ -2489,6 +2558,12 @@ class TMoverParameters } return false == StLinFlag && MainCircuitLampsEnabled(); } + // the vehicles the line breaker / engine start switch of this vehicle works, and its engine stopping on its own + // stops: the whole consist, or with JointEngineStart=No this vehicle alone (eu07/maszyna#80) + range_t MainSwitchRange() const + { + return JointEngineStart ? range_t::consist : range_t::local; + } // whether the cab command opening the main circuit opens it where the only cab switch of the circuit is the button // closing it: on a diesel that's the starter button, and the command is the one way to stop an engine whose fuel pump // starts on its own (eu07/maszyna#427). the other vehicles with such a button keep ignoring the command @@ -2503,10 +2578,10 @@ class TMoverParameters auto const oilmanual{OilPump.start_type != start_t::automatic}; return (fuelmanual || oilmanual) && (false == fuelmanual || FuelPump.is_enabled) && (false == oilmanual || OilPump.is_enabled); } - // whether the radio is switched on and has the low voltage to work + // whether the radio is switched on, its power supply isn't cut off and it has the low voltage to work bool RadioPowered() const { - return Radio && (Power24vIsAvailable || Power110vIsAvailable); + return Radio && RadioFuse && (Power24vIsAvailable || Power110vIsAvailable); } /*obrot kol uwzgledniajacy poslizg*/ double ComputeRotatingWheel(double WForce, double dt, double n) const; @@ -2623,6 +2698,8 @@ class TMoverParameters bool LoadFIZ_Text(std::string const &Text); // the same, from text in the .fiz format bool CheckLocomotiveParameters(bool ReadyFlag, int Dir); std::string EngineDescription(int what) const; + // the cab interior light the light preset at given position (1-based, as LightsPos) sets, if it sets one + std::optional LightsPresetCabLight(int Position) const; private: bool LoadFIZ_Parse(cParser &Parser); // reads the definition from either of the above diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index ce3c08458..e06b9052e 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -17,6 +17,7 @@ http://mozilla.org/MPL/2.0/. #include "utilities/parser.h" #include "simulation/simulation.h" +#include #include #include //--------------------------------------------------------------------------- @@ -152,11 +153,23 @@ void TSecuritySystem::update(double dt, double vel, bool pwr, int cab) velocity = vel; cabactive = cab; - if (vigilance_enabled && velocity > AwareMinSpeed) - vigilance_timer += dt; + if (vigilance_suspended) + { + // the vigilance device is switched off: no time counts towards a new alarm, of the alerter or of the button held + // too long. an alarm already on, with the emergency braking it leads to, stays until it's acknowledged as usual + if (vigilance_timer <= AwareDelay) + vigilance_timer = 0.0; + if (press_timer <= MaxHoldTime) + press_timer = 0.0; + } + else + { + if (vigilance_enabled && velocity > AwareMinSpeed) + vigilance_timer += dt; - if (pressed && (!is_sifa || velocity > AwareMinSpeed)) - press_timer += dt; + if (pressed && (!is_sifa || velocity > AwareMinSpeed)) + press_timer += dt; + } if (vigilance_timer > AwareDelay || press_timer > MaxHoldTime || cabsignal_active) alert_timer += dt; @@ -231,6 +244,11 @@ void TSecuritySystem::set_cabsignal_lock(bool v) cabsignal_lock = v; } +void TSecuritySystem::set_shunt_mode(bool const State) +{ + vigilance_suspended = State && AwareOffInShuntMode; +} + bool TSecuritySystem::is_engine_blocked() const { if (!is_sifa) @@ -260,6 +278,7 @@ void TSecuritySystem::load(std::string const &line, double Vmax) extract_value(radiostop_enabled, "RadioStop", line, ""); extract_value(MagnetLocation, "MagnetLocation", line, ""); extract_value(CabDependent, "CabDependent", line, ""); + extract_value(AwareOffInShuntMode, "AwareOffInShuntMode", line, ""); } double TableInterpolation(std::map &Map, double Parameter) @@ -599,7 +618,8 @@ bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters * } auto &thiscoupler{Couplers[ConnectNo]}; - auto &othercoupler = ConnectTo->Couplers[ConnectToNr != 2 ? ConnectToNr : thiscoupler.ConnectedNr]; + auto const otherend{ConnectToNr != 2 ? ConnectToNr : thiscoupler.ConnectedNr}; + auto &othercoupler = ConnectTo->Couplers[otherend]; auto const distance{CouplerDist(this, ConnectTo) - (thiscoupler.adapter_length + othercoupler.adapter_length)}; @@ -608,6 +628,18 @@ bool TMoverParameters::Attach(int ConnectNo, int ConnectToNr, TMoverParameters * return false; } + // no multiple-unit control between an electric and a diesel locomotive, whoever asks for it: the scenario, the AI + // or the player (eu07/maszyna#520) + if (auto const compatible{CompatibleCoupling(ConnectNo, *ConnectTo, otherend, CouplingType)}; compatible != CouplingType) + { + WriteLog(std::format("Vehicles \"{}\" and \"{}\" can't share their control, coupled without the control connection", Name, ConnectTo->Name)); + CouplingType = compatible; + if (CouplingType == coupling::faux) + { + return false; + } + } + // stykaja sie zderzaki i kompatybilne typy sprzegow, chyba że łączenie na starcie if (thiscoupler.CouplingFlag == coupling::faux) { @@ -809,6 +841,19 @@ bool TMoverParameters::ChangeCab(int direction) // rozruch wysoki (true) albo niski (false) bool TMoverParameters::CurrentSwitch(bool const State) { + // TBD, TODO: split off shunt mode toggle into a separate command? It doesn't make much sense to have these two together like that + // the diesels with a shunt mode have no motor overload relay threshold to switch, the switch sets their shunt mode alone. + // MaxCurrentSwitch() takes any change of the setting, so asked first it took the first move of the switch (eu07/maszyna#497) + if (true == ShuntModeAllow && (EngineType == TEngineType::DieselEngine || EngineType == TEngineType::DieselElectric)) + { + // dla 2Ls150 przed ustawieniem kierunku, for SM42/SP42 at the controller's zero position + if (EngineType == TEngineType::DieselEngine ? DirActive != 0 : false == IsMainCtrlNoPowerPos()) + { + return false; + } + ShuntMode = State; + return true; + } if (MaxCurrentSwitch(State)) { @@ -818,20 +863,6 @@ bool TMoverParameters::CurrentSwitch(bool const State) } return true; } - // TBD, TODO: split off shunt mode toggle into a separate command? It doesn't make much sense to have these two together like that - // dla 2Ls150 - if (EngineType == TEngineType::DieselEngine && true == ShuntModeAllow && DirActive == 0) - { - // przed ustawieniem kierunku - ShuntMode = State; - return true; - } - // for SM42/SP42 - if (EngineType == TEngineType::DieselElectric && true == ShuntModeAllow && IsMainCtrlNoPowerPos()) - { - ShuntMode = State; - return true; - } return false; }; @@ -1206,6 +1237,59 @@ bool TMoverParameters::AutomaticCouplingSafe(int const End, TMoverParameters con return false == Global.crash_damage || CollisionVelocity(End, Other, OtherEnd) <= SafeCollisionVelocity; } +namespace +{ + +// the kind of traction a vehicle's engine stands for, as far as its multiple-unit control goes +enum class traction_kind +{ + none, + electric, + diesel +}; + +traction_kind traction_of(TEngineType const Engine) +{ + switch (Engine) + { + case TEngineType::ElectricSeriesMotor: + case TEngineType::ElectricInductionMotor: + return traction_kind::electric; + case TEngineType::DieselEngine: + case TEngineType::DieselElectric: + return traction_kind::diesel; + default: + return traction_kind::none; + } +} + +} // namespace + +bool TMoverParameters::ControlCouplingAllowed(int const End, TMoverParameters const &Other, int const OtherEnd) const +{ + if (false == Global.control_coupling_engine_check) + { + return true; + } + // the same control system named on both couplers is the vehicle authors' word that they work together + if (auto const &controltype{Couplers[End].control_type}; false == controltype.empty() && controltype == Other.Couplers[OtherEnd].control_type) + { + return true; + } + auto const traction{traction_of(EngineType)}; + auto const othertraction{traction_of(Other.EngineType)}; + return traction == traction_kind::none || othertraction == traction_kind::none || traction == othertraction; +} + +int TMoverParameters::CompatibleCoupling(int const End, TMoverParameters const &Other, int const OtherEnd, int const CouplingType) const +{ + if ((CouplingType & coupling::control) == 0 || (CouplingType & coupling::permanent) != 0 || ControlCouplingAllowed(End, Other, OtherEnd)) + { + return CouplingType; + } + return CouplingType & ~coupling::control; +} + int TMoverParameters::SoundingHorns(int const Signal) const { auto const supplied{[this](horn_supply const Supply) { @@ -1631,6 +1715,8 @@ void TMoverParameters::compute_movement_(double const Deltatime) BRVentilators = false; } + // the master controller set directly, not through IncMainCtrl()/DecMainCtrl() (AI, consist): the locked shunt follows it as well + ScndCtrlResistiveLockCheck(); // automatyczny rozruch if (EngineType == TEngineType::ElectricSeriesMotor && AutoRelayCheck()) { @@ -2537,6 +2623,7 @@ bool TMoverParameters::IncMainCtrl(int CtrlSpeed) if (true == OK) { + ScndCtrlResistiveLockCheck(); // e.g. from the last series position on to the resistive parallel ones SendCtrlToNext("MainCtrl", MainCtrlPos, CabActive); //??? SendCtrlToNext("ScndCtrl", ScndCtrlPos, CabActive); } @@ -2662,6 +2749,7 @@ bool TMoverParameters::DecMainCtrl(int CtrlSpeed) if (OK) { + ScndCtrlResistiveLockCheck(); // the shunt drops when the master controller leaves a resistance-free position /*OK:=*/SendCtrlToNext("MainCtrl", MainCtrlPos, CabActive); // hmmmm...???!!! /*OK:=*/SendCtrlToNext("ScndCtrl", ScndCtrlPos, CabActive); } @@ -2751,7 +2839,7 @@ bool TMoverParameters::IncScndCtrl(int CtrlSpeed) { // if (RList[MainCtrlPos].R=0) and (MainCtrlPos>0) and (ScndCtrlPos 0 && CabActive != 0) { - if (ScndCtrlPos > 0 && !CoupledCtrl && (EngineType != TEngineType::DieselElectric || !AutoRelayFlag)) + if (ScndCtrlPos > 0 && !CoupledCtrl && (EngineType != TEngineType::DieselElectric || !AutoRelayFlag) && !IsScndCtrlLockedByMainCtrl()) { if (CtrlSpeed == 1) { @@ -2872,6 +2960,22 @@ bool TMoverParameters::DecScndCtrl(int CtrlSpeed) return OK; } +bool TMoverParameters::IsScndCtrlLockedByMainCtrl() const +{ + // ET21, ET22, EP09: the field shunting engages only on the resistance-free positions of the master controller (eu07/maszyna#402) + return ScndCtrlResistiveLock && (IsMainCtrlNoPowerPos() || RList[MainCtrlPos].R >= 0.01); +} + +void TMoverParameters::ScndCtrlResistiveLockCheck() +{ + // the shunt controller, locked in both directions on zero and the resistive positions, would otherwise stay engaged there once the + // master controller is taken back (or set from elsewhere, e.g. by the AI or another vehicle of the consist) with the shunt on + if (ScndCtrlPos > 0 && !CoupledCtrl && IsScndCtrlLockedByMainCtrl()) + { + ScndCtrlPos = 0; + } +} + int TMoverParameters::GetVirtualScndPos() const { if (TrainType == dt_ET42 && DynamicBrakeFlag && !ScndCtrlPos) @@ -3143,9 +3247,11 @@ void TMoverParameters::SecuritySystemReset(void) // zbijanie czuwaka/SHP void TMoverParameters::SecuritySystemCheck(double dt) { bool isPower = Power24vIsAvailable || Power110vIsAvailable; + // the shunt mode of the SM42 switches its vigilance device (CA) off, on the vehicles with AwareOffInShuntMode=Yes (eu07/maszyna#457) + SecuritySystem.set_shunt_mode(ShuntMode); SecuritySystem.update(dt, Vel, isPower, CabActive); - if (!Battery || !Radio) + if (!Battery || !Radio || !RadioFuse) { // wyłączenie baterii deaktywuje sprzęt RadiostopSwitch(false); } @@ -4161,7 +4267,8 @@ bool TMoverParameters::SwitchEPBrake(int state) OK = false; if (BrakeHandle == TBrakeHandle::St113 && CabOccupied != 0) { - if (state > 0) + // the handle works the EP contactors pneumatically, their supply is cut as the Oerlikon handle's is + if (state > 0 && EPBrakeControlPowered()) EpForce = Handle->GetEP(); // TODO: przetlumaczyc else EpForce = 0; @@ -4173,6 +4280,11 @@ bool TMoverParameters::SwitchEPBrake(int state) return OK; } +bool TMoverParameters::EPBrakeControlPowered() const +{ + return Power24vIsAvailable && DirActive != 0 && EpFuse; +} + // ************************************************************************************************* // Q: 20160711 // zwiększenie ciśnienia hamowania @@ -4706,7 +4818,7 @@ void TMoverParameters::UpdatePipePressure(double dt) if ((BrakeHandle == TBrakeHandle::FVel6 || BrakeHandle == TBrakeHandle::FVE408) && CabOccupied != 0) { - if (Power24vIsAvailable && DirActive != 0 && EpFuse) // tu powinien byc jeszcze bezpiecznik EP i baterie - + if (EPBrakeControlPowered()) // tu powinien byc jeszcze bezpiecznik EP i baterie - // temp = (Handle as TFVel6).GetCP EpForce = Handle->GetEP(); else @@ -4725,6 +4837,11 @@ void TMoverParameters::UpdatePipePressure(double dt) // Ra 2014-11: na tym się wysypuje, ale nie wiem, w jakich warunkach SendCtrlToNext("Brake", EpForce, CabActive); } + else if (BrakeHandle == TBrakeHandle::St113 && CabOccupied != 0 && std::abs(EpForce) > 0.001 && !EPBrakeControlPowered()) + { + // the EP brake switched on with the button drops out with the control's supply + SwitchEPBrake(0); + } Pipe->Act(); PipePress = Pipe->P(); @@ -5455,6 +5572,7 @@ double TMoverParameters::CouplerForce(int const End, double dt) { couplingtype &= ~coupling::control; } + couplingtype = CompatibleCoupling(End, *othervehicle, otherend, couplingtype); // too fast for the couplers to catch, the vehicles collide instead (and may derail, see CollisionDetect()) auto const safe{AutomaticCouplingSafe(End, *othervehicle, otherend)}; @@ -7291,6 +7409,60 @@ bool TMoverParameters::DropAllPantographs(bool const State, range_t const Notify return State != initialstate; } +namespace +{ +// the setting of the universal controller one UniCtrlValStep further from Value towards Limit, never past it +double next_uc_step(double const Value, double const Limit, double const Step) +{ + constexpr double epsilon{1e-6}; + if (Limit > Value) + { + return std::min((std::floor(Value / Step + epsilon) + 1.0) * Step, Limit); + } + return std::max((std::ceil(Value / Step - epsilon) - 1.0) * Step, Limit); +} + +// the universal controller with UniCtrlValStep: the setting the continuous ramp got to (Ramped) turned into whole steps. +// a move of the controller onto a position which changes the setting makes one step at once, the ramp then one step each +// time it covers a step's length; the steps stop at the position's set value (or its bound, past which the ramp doesn't go) +double stepped_uc_value(double const Current, double const Ramped, TUniversalCtrl const &Position, double const Step, bool const Moved, double &Progress) +{ + if (Moved) + { + Progress = 0.0; + } + double const delta{Ramped - Current}; + if (std::abs(delta) < 1e-9) + { + Progress = 0.0; + return Ramped; + } + double limit{0.0}; + if (delta > 0.0) + { + limit = Position.SetCtrlVal > Current ? Position.SetCtrlVal : Position.MaxCtrlVal; + } + else + { + limit = Position.SetCtrlVal < Current ? Position.SetCtrlVal : Position.MinCtrlVal; + } + Progress = Moved ? Step : Progress + std::abs(delta); + double value{Current}; + bool reached{std::abs(value - limit) < 1e-9}; + while (!reached && Progress >= Step - 1e-9) + { + value = next_uc_step(value, limit, Step); + Progress -= Step; + reached = std::abs(value - limit) < 1e-9; + } + if (reached) + { + Progress = 0.0; + } + return safe_clamp(value, Position.MinCtrlVal, Position.MaxCtrlVal); +} +} // namespace + void TMoverParameters::CheckEIMIC(double dt) { double offset = EIMCtrlAdditionalZeros ? 1.0 : 0.0; @@ -7415,11 +7587,14 @@ void TMoverParameters::CheckEIMIC(double dt) if (MainCtrlActualPos != MainCtrlPos || LastRelayTime > InitialCtrlDelay) { - eimic -= safe_clamp(-UniCtrlList[MainCtrlPos].SetCtrlVal + eimic, 0.0, - MainCtrlActualPos == MainCtrlPos ? dt * UniCtrlList[MainCtrlPos].SpeedDown : sign(UniCtrlList[MainCtrlPos].SpeedDown) * 0.01); // odejmuj do X - eimic += safe_clamp(UniCtrlList[MainCtrlPos].SetCtrlVal - eimic, 0.0, - MainCtrlActualPos == MainCtrlPos ? dt * UniCtrlList[MainCtrlPos].SpeedUp : sign(UniCtrlList[MainCtrlPos].SpeedUp) * 0.01); // dodawaj do X - eimic = safe_clamp(eimic, UniCtrlList[MainCtrlPos].MinCtrlVal, UniCtrlList[MainCtrlPos].MaxCtrlVal); + auto const &position{UniCtrlList[MainCtrlPos]}; + double ramped{eimic}; + ramped -= safe_clamp(-position.SetCtrlVal + ramped, 0.0, + MainCtrlActualPos == MainCtrlPos ? dt * position.SpeedDown : sign(position.SpeedDown) * 0.01); // odejmuj do X + ramped += safe_clamp(position.SetCtrlVal - ramped, 0.0, + MainCtrlActualPos == MainCtrlPos ? dt * position.SpeedUp : sign(position.SpeedUp) * 0.01); // dodawaj do X + ramped = safe_clamp(ramped, position.MinCtrlVal, position.MaxCtrlVal); + eimic = UniCtrlValStep > 0.0 ? stepped_uc_value(eimic, ramped, position, UniCtrlValStep, MainCtrlActualPos != MainCtrlPos, eimic_step_progress) : ramped; } if (MainCtrlActualPos == MainCtrlPos) LastRelayTime += dt; @@ -7844,6 +8019,9 @@ bool TMoverParameters::dizel_Update(double dt) WaterHeaterCheck(dt); OilPumpCheck(dt); FuelPumpCheck(dt); + // the engine being started fires once the starter has turned it a while; one stopped meanwhile starts over + dizel_FiringCountdown = (Mains ? std::max(0.0, dizel_FiringCountdown - dt) : 0.0); + if (true == dizel_startup && true == dizel_StartupCheck()) { dizel_ignition = true; @@ -7858,6 +8036,7 @@ bool TMoverParameters::dizel_Update(double dt) LastSwitchingTime = 0; Mains = true; dizel_spinup = true; + dizel_FiringCountdown = dizel_SmokeDelay; enrot = std::max(enrot, 0.35 * ( // TODO: dac zaleznie od temperatury i baterii EngineType == TEngineType::DieselEngine ? dizel_nmin : DElist[0].RPM / 60.0)); @@ -7869,7 +8048,8 @@ bool TMoverParameters::dizel_Update(double dt) { // knock out the engine if the fuel pump isn't feeding it // TBD, TODO: grace period before the engine is starved for fuel and knocked out - MainSwitch(false); + // an engine started on its own stops on its own + MainSwitch(false, MainSwitchRange()); } bool DU{false}; @@ -8160,7 +8340,13 @@ double TMoverParameters::dizel_Momentum(double Fill, double n, double dt) if (enrot <= 0 && false == dizel_spinup) { - MainSwitch(false); + // an engine stalling stops those started together with it, once. one already stopped, from its own switch or + // another vehicle's, or not started at all, has nothing to stop: it stays quiet, rather than stop every frame + // the engines started on their own or from the separate switches (eu07/maszyna#80) + if (true == Mains) + { + MainSwitch(false, MainSwitchRange()); + } enrot = 0; } @@ -9490,6 +9676,52 @@ bool TMoverParameters::readDimmerList(std::string const &line) return true; } +int TMoverParameters::clampDimmerPosition(int const Position) const +{ + if (dimPositions.empty()) + { + return 0; + } + return std::clamp(Position, 0, static_cast(dimPositions.size()) - 1); +} + +TMoverParameters::dimPosition TMoverParameters::currentDimPosition() const +{ + if (modernDimmerPosition < 0 || modernDimmerPosition >= static_cast(dimPositions.size())) + { + return {}; + } + return dimPositions[modernDimmerPosition]; +} + +bool TMoverParameters::stepDimmerPosition(int const Step) +{ + if (dimPositions.empty()) + { + return false; + } + auto const last{static_cast(dimPositions.size()) - 1}; + auto const current{clampDimmerPosition(modernDimmerPosition)}; + auto next{current + Step}; + if (next < 0 || next > last) + { + if (false == modernDimmerCanCycle) + { + next = current; + } + else + { + next = (next < 0 ? last : 0); + } + } + if (next == modernDimmerPosition) + { + return false; + } + modernDimmerPosition = next; + return true; +} + // parsowanie WWList bool TMoverParameters::readWWList(std::string const &line) { @@ -9535,10 +9767,38 @@ bool TMoverParameters::readLightsList(std::string const &Input) return false; } parser >> Lights[0][idx] >> Lights[1][idx]; + // optional third column: the cab interior light the preset sets (eu07/maszyna#529). anything but a whole number + // (some rows carry stray notes after the two columns) leaves the cab light to its own switch + LightsCabLight[idx] = -1; + if (true == parser.getTokens(1, false)) + { + std::string cablight; + parser >> cablight; + int flags{-1}; + auto const [end, error]{std::from_chars(cablight.data(), cablight.data() + cablight.size(), flags)}; + if (error == std::errc{} && end == cablight.data() + cablight.size() && flags >= 0) + { + LightsCabLight[idx] = flags; + } + } return true; } +std::optional TMoverParameters::LightsPresetCabLight(int const Position) const +{ + if (Position < 1 || Position > static_cast(LightsCabLight.size())) + { + return std::nullopt; + } + auto const flags{LightsCabLight[Position - 1]}; + if (flags < 0) + { + return std::nullopt; + } + return lights_preset_cablight{(flags & lights_preset_cablight::light_on) != 0, (flags & lights_preset_cablight::light_dimmed) != 0}; +} + bool TMoverParameters::readCompressorList(std::string const &Input) { @@ -10291,6 +10551,9 @@ bool TMoverParameters::LoadFIZ_Parse(cParser &fizparser) // NOSONAR the former b result = false; // ustawiamy domyslna pozycje dimmera + // the DefaultPos of a short or an empty DimmerList would put the dimmer outside of it + modernDimmerDefaultPosition = clampDimmerPosition(modernDimmerDefaultPosition); + modernDimmerPosition = clampDimmerPosition(modernDimmerPosition); if (!enableModernDimmer) { modernDimmerPosition = modernDimmerDefaultPosition; @@ -10942,6 +11205,7 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line) extract_value(EIMCtrlEmergency, "EIMCtrlEmergency", line, ""); extract_value(ScndS, "ScndS", line, ""); // brak pozycji rownoleglej przy niskiej nastawie PSR + extract_value(ScndCtrlResistiveLock, "ScndCtrlResistiveLock", line, ""); // bocznikowanie tylko na pozycjach bezoporowych extract_value(InitialCtrlDelay, "IniCDelay", line, ""); extract_value(CtrlDelay, "SCDelay", line, ""); @@ -11202,6 +11466,7 @@ void TMoverParameters::LoadFIZ_Engine(std::string const &Input) { EngineType = LoadFIZ_EngineDecode(extract_value("EngineType", Input)); + extract_value(JointEngineStart, "JointEngineStart", Input, ""); if (std::string transmission = extract_value("Trans", Input); false == transmission.empty()) { @@ -11410,6 +11675,9 @@ void TMoverParameters::LoadFIZ_Engine(std::string const &Input) // oil pump extract_value(OilPump.pressure_minimum, "OilMinPressure", Input, ""); extract_value(OilPump.pressure_maximum, "OilMaxPressure", Input, ""); + // the time the starter turns the engine before it fires and smokes (eu07/maszyna#523) + extract_value(dizel_SmokeDelay, "SmokeDelay", Input, "0"); + dizel_SmokeDelay = std::max(0.0, dizel_SmokeDelay); // engine cooling factore extract_value(dizel_heat.kw, "HeatKW", Input, ""); extract_value(dizel_heat.kv, "HeatKV", Input, ""); @@ -11435,7 +11703,7 @@ void TMoverParameters::LoadFIZ_Engine(std::string const &Input) // water heater extract_value(WaterHeater.config.temp_min, "HeaterMinTemperature", Input, ""); extract_value(WaterHeater.config.temp_max, "HeaterMaxTemperature", Input, ""); - float pf; + float pf{ 1235.f }; extract_value(pf, "NominalCoolingPower", Input, "1235"); dizel_heat.powerfactor = 1235 / pf; } @@ -11519,6 +11787,7 @@ void TMoverParameters::LoadFIZ_AI(std::string const &Input) { extract_value(AIHintPantstate, "Pantstate", Input, ""); + extract_value(AIHintShuntPantstate, "ShuntPantstate", Input, ""); extract_value(AIHintPantUpIfIdle, "IdlePantUp", Input, ""); extract_value(AIHintLocalBrakeAccFactor, "LocalBrakeAccFactor", Input, ""); } @@ -11560,6 +11829,8 @@ void TMoverParameters::LoadFIZ_UCList(std::string const &Input) extract_value(UniCtrlIntegratedBrakeCtrl, "IntegratedBrake", Input, ""); extract_value(UniCtrlIntegratedLocalBrakeCtrl, "IntegratedLocBrake", Input, ""); extract_value(UniCtrlIntegratedBrakePNCtrl, "IntegratedBrakePN", Input, ""); + extract_value(UniCtrlValStep, "CtrlValStep", Input, ""); + UniCtrlValStep = std::max(UniCtrlValStep, 0.0); } void TMoverParameters::LoadFIZ_DList(std::string const &Input) diff --git a/McZapkie/Oerlikon_ESt.cpp b/McZapkie/Oerlikon_ESt.cpp index 1e7a5be66..0717eff5d 100644 --- a/McZapkie/Oerlikon_ESt.cpp +++ b/McZapkie/Oerlikon_ESt.cpp @@ -379,8 +379,7 @@ void TNESt3::CheckState(double const BCP, double & /*dV1*/) // glowny przyrzad r Przys_blok = false; // sprawdzanie stanu - double const cel{ CelBCP( CVP, VVP ) }; - if (BCP < cel - 0.01 * BVM && Przys_blok) + if (double const cel{ CelBCP( CVP, VVP ) }; BCP < cel - 0.01 * BVM && Przys_blok) BrakeStatus |= b_on | b_hld; // hamowanie stopniowe; else if (BCP - 0.1 > cel + 0.01 * BVM) BrakeStatus &= ~( b_on | b_hld ); // luzowanie; @@ -486,6 +485,18 @@ void TNESt3::SetLBP(double const P) LBP = P; } +void TNESt3::ScaleNozzlesForAL2() // dysze cylindra przy przekladniku AL2 +{ + if( PrzekCiagly == nullptr ) { + return; + } + // dysze cylindra skalibrowane na komore impulsowa przekladnika AL2 (1 l) wg czasow z tablicy 3-9 + Nozzles[dON] *= 0.914; + Nozzles[dTN] *= 0.885; + Nozzles[dOO] *= 0.82; + Nozzles[dTO] *= 0.8; +} + void TNESt3::SetSize( int const size, std::string const ¶ms ) // ustawianie dysz (rozmiaru ZR) { static double const dNO1l = 1.250; @@ -673,13 +684,7 @@ void TNESt3::SetSize( int const size, std::string const ¶ms ) // ustawianie Nozzles[dSd] = 1.1; Nozzles[dSm] = 0.9; - if( PrzekCiagly != nullptr ) { - // dysze cylindra skalibrowane na komore impulsowa przekladnika AL2 (1 l) wg czasow z tablicy 3-9 - Nozzles[dON] *= 0.914; - Nozzles[dTN] *= 0.885; - Nozzles[dOO] *= 0.82; - Nozzles[dTO] *= 0.8; - } + ScaleNozzlesForAL2(); // przeliczanie z mm^2 na l/m for (auto &nozzle : Nozzles) diff --git a/McZapkie/Oerlikon_ESt.h b/McZapkie/Oerlikon_ESt.h index 02d65a285..eaae2c032 100644 --- a/McZapkie/Oerlikon_ESt.h +++ b/McZapkie/Oerlikon_ESt.h @@ -201,6 +201,7 @@ class TNESt3 : public TBrake { void CheckState(double const BCP, double &dV1); // glowny przyrzad rozrzadczy void CheckReleaser(double const dt); // odluzniacz double CVs(double const BP) const; // napelniacz sterujacego + void ScaleNozzlesForAL2(); // dysze cylindra przy przekladniku AL2 double BVs(double const BCP) const; // napelniacz pomocniczego void SetSize( int const size, std::string const ¶ms ); // ustawianie dysz (rozmiaru ZR), przekladniki void PLC(double const mass) override; // wspolczynnik cisnienia przystawki wazacej diff --git a/McZapkie/hamulce.cpp b/McZapkie/hamulce.cpp index c0a7d2a0e..9411dc425 100644 --- a/McZapkie/hamulce.cpp +++ b/McZapkie/hamulce.cpp @@ -968,6 +968,28 @@ double TESt::BVs(double const BCP) const return 0; } +/// +/// Refills the auxiliary reservoir (ZP) from the valve pre-chamber through the +/// check valve of the slide valve, opened as far as says for the +/// given cylinder (or impulse-chamber) pressure, while the pre-chamber is more +/// than 0.05 bar above the reservoir. The flows wait for the caller's Act(). +/// +/// Brake cylinder (or impulse-chamber) pressure. +/// Time step [s]. +/// Volume taken into the auxiliary reservoir, 0.96 of it drawn from the brake pipe. +double TESt::FillBrakeRes(double const BCP, double const dt) const +{ + double const BVP{BrakeRes->P()}; + double const VVP{ValveRes->P()}; + double const temp{BVs(BCP)}; + double dv{0.0}; + if (VVP - 0.05 > BVP) + dv = PF(BVP, VVP, 0.02 * SizeBR * temp / 1.87) * dt; + BrakeRes->Flow(dv); + ValveRes->Flow(-0.04 * dv); + return dv; +} + /// /// One-step Oerlikon ESt distributor advance: runs CheckState/CheckReleaser, /// integrates the ZS <-> PG, ZP <-> cylinder, ZP <-> pre-chamber and @@ -1021,15 +1043,7 @@ double TESt::GetPF(double const PP, double const dt, double const Vel) BrakeCyl->Flow(-dv); // przeplyw ZP <-> rozdzielacz - temp = BVs(BCP); - // if(BrakeStatus and b_hld)=b_off then - if (VVP - 0.05 > BVP) - dv = PF(BVP, VVP, 0.02 * SizeBR * temp / 1.87) * dt; - else - dv = 0; - BrakeRes->Flow(dv); - dV1 = dV1 + dv * 0.96; - ValveRes->Flow(-0.04 * dv); + dV1 = dV1 + FillBrakeRes(BCP, dt) * 0.96; // przeplyw PG <-> rozdzielacz dv = PF(PP, VVP, 0.01) * dt; ValveRes->Flow(-dv); @@ -1191,6 +1205,10 @@ double TEStEP2::GetPF(double const PP, double const dt, double const Vel) ValveRes->Flow(-0.04 * dv); dV1 = dV1 - 0.96 * dv; + // przeplyw ZP <-> rozdzielacz: as in every ESt, the auxiliary reservoir also charges from the brake pipe, + // not from the main reservoir pipe alone, so a unit hauled with the brake hose alone charges and brakes + dV1 = dV1 + FillBrakeRes(BCP, dt) * 0.96; + // hamulec EP EPCalc(dt); diff --git a/McZapkie/hamulce.h b/McZapkie/hamulce.h index 37b9b6a4d..2fb433a85 100644 --- a/McZapkie/hamulce.h +++ b/McZapkie/hamulce.h @@ -620,6 +620,15 @@ class TESt : public TBrake /// Brake cylinder pressure. /// Dimensionless opening coefficient. double BVs(double BCP) const; // napelniacz pomocniczego + /// + /// Refills the auxiliary reservoir (ZP) from the valve pre-chamber through the + /// check valve of the slide valve, opened as far as says, while + /// the pre-chamber is above the reservoir. The flows wait for the caller's Act(). + /// + /// Brake cylinder (or impulse-chamber) pressure for . + /// Time step [s]. + /// Volume taken into the auxiliary reservoir, 0.96 of it drawn from the brake pipe. + double FillBrakeRes(double BCP, double dt) const; // napelnianie pomocniczego z rozdzielacza /// Vents the valve, brake and control reservoirs to zero. void ForceEmptiness() override; // wymuszenie bycia pustym diff --git a/README.md b/README.md index 47741a511..675026ccf 100644 --- a/README.md +++ b/README.md @@ -110,7 +110,7 @@ MaSzyna compiles and runs natively on **Linux** and **Windows**. Other platforms ## Windows -Install **Python 3.14 x64** from [python.org](https://www.python.org/downloads/windows/) and include the optional **Python native development** feature (headers and `.lib` for embedding). Pass `-DPython3_ROOT_DIR="C:\Path\To\Python314"` on the `cmake` line when you want the layout under that directory used for embedding and for copying `Lib` / `DLLs` next to the executable. +Install **Python 3.14 x64** from [python.org](https://www.python.org/downloads/windows/) and include the optional **Python native development** feature (headers and `.lib` for embedding). Pass `-DPython3_ROOT_DIR="C:\Path\To\Python314"` on the `cmake` line when you want the layout under that directory used for embedding and for copying `Lib` / `DLLs` next to the executable. The cab screens are drawn with [Pillow](https://pypi.org/project/pillow/): install it into that Python (`python -m pip install Pillow`) before building, so it is copied along with `Lib`. **AppVeyor CI** builds with the worker image’s preinstalled Python at `C:/Python314-x64` (see [`appveyor.yml`](./appveyor.yml): `-DPython3_ROOT_DIR=...`). diff --git a/application/application.cpp b/application/application.cpp index 75ecde778..a398117c7 100644 --- a/application/application.cpp +++ b/application/application.cpp @@ -28,6 +28,7 @@ http://mozilla.org/MPL/2.0/. #include "utilities/translation.h" #include "vehicle/Train.h" #include "utilities/Timer.h" +#include "utilities/framepacer.h" #include "utilities/dictionary.h" #include "version_info.h" #include "simulation/simulationtest.h" @@ -488,9 +489,14 @@ bool eu07_application::is_client() const int eu07_application::run() { auto frame{0}; + frame_pacer framepacer; + Timer::subsystem.mainloop_period.start(); // main application loop while (!glfwWindowShouldClose(m_windows.front()) && !m_modestack.empty()) { + // the time from one frame's start to the next, the wait for fpslimit included + Timer::subsystem.mainloop_period.stop(); + Timer::subsystem.mainloop_period.start(); Timer::subsystem.mainloop_total.start(); glfwPollEvents(); @@ -650,10 +656,11 @@ int eu07_application::run() if (m_network) m_network->update(); - auto const frametime{Timer::subsystem.mainloop_total.stop()}; - if (Global.minframetime.count() != 0.0f && (Global.minframetime - frametime).count() > 0.0f) + Timer::subsystem.mainloop_total.stop(); + // fpslimit: wait for the next frame's slot (eu07/maszyna#416) + if (auto const nextframe{framepacer.next_frame(frame_pacer::clock::now(), Global.minframetime)}) { - std::this_thread::sleep_for(Global.minframetime - frametime); + std::this_thread::sleep_until(*nextframe); } } // Handled by application.exit diff --git a/application/driverhints.cpp b/application/driverhints.cpp index bcfd7dbd0..ae39ede7a 100644 --- a/application/driverhints.cpp +++ b/application/driverhints.cpp @@ -138,6 +138,16 @@ TController::cue_action( driver_hint const Action, float const Actionparameter ) return mvOccupied->Radio == true; } ); break; } + case driver_hint::radiofuseon: { + if( AIControllFlag ) { + mvOccupied->RadioFuse = true; + } + hint( + Action, + [this](float const /*Parameter*/) { + return mvOccupied->RadioFuse == true; } ); + break; + } case driver_hint::radiochannel: { if( AIControllFlag ) { iRadioChannel = static_cast( Actionparameter ); diff --git a/application/driverhints_def.h b/application/driverhints_def.h index f59ed734c..2ce896679 100644 --- a/application/driverhints_def.h +++ b/application/driverhints_def.h @@ -2,6 +2,7 @@ DRIVER_HINT_DEF(batteryon, STRN("Switch on battery")) DRIVER_HINT_DEF(batteryoff, STRN("Switch off battery")) DRIVER_HINT_DEF(radioon, STRN("Switch on radio")) DRIVER_HINT_DEF(radiooff, STRN("Switch off radio")) +DRIVER_HINT_DEF(radiofuseon, STRN("Close radio fuse")) DRIVER_HINT_DEF(radiochannel, STRN("Tune into channel %.0f")) DRIVER_HINT_DEF(oilpumpon, STRN("Switch on oil pump")) DRIVER_HINT_DEF(oilpumpoff, STRN("Switch off oil pump")) diff --git a/application/driveruipanels.cpp b/application/driveruipanels.cpp index e318d3563..029b8d7f1 100644 --- a/application/driveruipanels.cpp +++ b/application/driveruipanels.cpp @@ -206,6 +206,24 @@ drivingaid_panel::update() { } } +void +drivingaid_panel::render_contents() { + ImGui::Checkbox(STR_C("expand"), &is_expanded); + + ImGui::SameLine(); + + auto const *driver = (simulation::Train && simulation::Train->Dynamic()) ? simulation::Train->Dynamic()->Mechanik : nullptr; + if (driver && (false == Global.RealisticControlMode || DebugModeFlag)) { + bool autopilot = driver->AIControllFlag; + if (ImGui::Checkbox(STR_C("autopilot"), &autopilot)) { + command_relay commandrelay; + commandrelay.post(autopilot ? user_command::aidriverenable : user_command::aidriverdisable, 0.0, 0.0, GLFW_PRESS, 0); + } + } + + ui_panel::render_contents(); +} + void scenario_panel::update() { @@ -810,7 +828,7 @@ debug_panel::update_section_vehicle( std::vector &Output ) { mover.HeatingAllow ? 'h' : '.', mover.Hamulec->Releaser() ? '^' : '.', - std::string( m_input.mechanik ? STR(" R") + ( mover.Radio ? std::to_string( m_input.mechanik->iRadioChannel ) : "-" ) : "" ).c_str(), + std::string( m_input.mechanik ? STR(" R") + ( mover.Radio && mover.RadioFuse ? std::to_string( m_input.mechanik->iRadioChannel ) : "-" ) : "" ).c_str(), std::string( isdieselenginepowered ? STR(" oil pressure: ") + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(), // power transfers // 3000v diff --git a/application/driveruipanels.h b/application/driveruipanels.h index 96b9ac1c7..393d0e9a3 100644 --- a/application/driveruipanels.h +++ b/application/driveruipanels.h @@ -20,6 +20,7 @@ public: {} void update() override; + void render_contents() override; private: // members diff --git a/application/editormode.cpp b/application/editormode.cpp index 32f991c55..1ad3ef6ed 100644 --- a/application/editormode.cpp +++ b/application/editormode.cpp @@ -4804,8 +4804,12 @@ void editor_mode::render_gizmo() snapvalue = glm::vec3(0.1f); float const *snap = Global.ctrlState && snapvalue.x > 0.0f ? glm::value_ptr(snapvalue) : nullptr; + // the change of this frame alone: a turn is taken from it, not from the angles the whole matrix decomposes into, + // which can't tell a turn of more than 90 degrees about the vertical axis (it comes out as 180 - angle with the + // other two axes flipped, and the model turned back and forth while dragged one way) + glm::mat4 delta(1.0f); ImGuizmo::Manipulate(glm::value_ptr(view), glm::value_ptr(projection), - operation, mode, glm::value_ptr(matrix), nullptr, snap); + operation, mode, glm::value_ptr(matrix), glm::value_ptr(delta), snap); if (ImGuizmo::IsUsing()) { @@ -4822,9 +4826,11 @@ void editor_mode::render_gizmo() if (operation == ImGuizmo::ROTATE && model) { - // apply the rotation delta relative to the model's current orientation - glm::vec3 const newangles(newrotation[0], newrotation[1], newrotation[2]); - auto const turned{newangles - model->Angles()}; + // the turn of this frame, small, so its angles decompose with no ambiguity + float deltatranslation[3], deltarotation[3], deltascale[3]; + ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(delta), deltatranslation, deltarotation, deltascale); + auto const wrapped = [](float Angle) { return Angle - 360.0f * std::floor((Angle + 180.0f) / 360.0f); }; + glm::vec3 const turned{wrapped(deltarotation[0]), wrapped(deltarotation[1]), wrapped(deltarotation[2])}; m_editor.rotate(model, turned, 0.0f); selection_follow(glm::dvec3(0.0), turned, model->location()); } diff --git a/application/uilayer.cpp b/application/uilayer.cpp index 855bfbadc..9493f77f6 100644 --- a/application/uilayer.cpp +++ b/application/uilayer.cpp @@ -409,6 +409,8 @@ bool ui_layer::init(GLFWwindow *Window) if (!gamepadui) gamepadui = ""; auto const viewportsupport{(m_imguiio->BackendFlags & ImGuiBackendFlags_PlatformHasViewports) && (m_imguiio->BackendFlags & ImGuiBackendFlags_RendererHasViewports) && glfwGetPlatform() != GLFW_PLATFORM_WAYLAND && std::string_view{desktop} != "gamescope" && std::string_view{gamepadui} != "1"}; + // a tooltip as long as a paragraph is wrapped: in one line it can run past the screen + m_imguiio->ConfigTooltipsWrapWidth = std::round(Global.ui_fontsize * 40.0f); if (Global.ui_viewports && viewportsupport) { m_imguiio->ConfigFlags |= ImGuiConfigFlags_ViewportsEnable; diff --git a/imgui/imgui.cpp b/imgui/imgui.cpp index a9026b408..2579bf4d6 100644 --- a/imgui/imgui.cpp +++ b/imgui/imgui.cpp @@ -1508,6 +1508,7 @@ ImGuiIO::ImGuiIO() ConfigWindowsCopyContentsWithCtrlC = false; ConfigScrollbarScrollByPage = true; ConfigMemoryCompactTimer = 60.0f; + ConfigTooltipsWrapWidth = 0.0f; ConfigDebugIsDebuggerPresent = false; ConfigDebugHighlightIdConflicts = true; ConfigDebugHighlightIdConflictsShowItemPicker = true; @@ -12112,7 +12113,14 @@ void ImGui::SetTooltipV(const char* fmt, va_list args) { if (!BeginTooltipEx(ImGuiTooltipFlags_OverridePrevious, ImGuiWindowFlags_None)) return; + // MaSzyna addition: see io.ConfigTooltipsWrapWidth + ImGuiContext& g = *GImGui; + const bool wrap = g.IO.ConfigTooltipsWrapWidth > 0.0f; + if (wrap) + PushTextWrapPos(GetCursorPosX() + g.IO.ConfigTooltipsWrapWidth); TextV(fmt, args); + if (wrap) + PopTextWrapPos(); EndTooltip(); } @@ -16375,9 +16383,11 @@ static void ImGui::WindowSelectViewport(ImGuiWindow* window) } // Fallback: merge in default viewport if z-order matches, otherwise create a new viewport + // MaSzyna addition: with io.ConfigViewportsNoAutoDetach the tooltips and popups stay in the main viewport here too if (window->Viewport == NULL) if (!UpdateTryMergeWindowIntoHostViewport(window, main_viewport)) - window->Viewport = WindowStaysInHostViewport(window, main_viewport) ? main_viewport : AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_None); + window->Viewport = (WindowStaysInHostViewport(window, main_viewport) || (g.IO.ConfigViewportsNoAutoDetach && (flags & (ImGuiWindowFlags_Popup | ImGuiWindowFlags_Tooltip)))) + ? main_viewport : AddUpdateViewport(window, window->ID, window->Pos, window->Size, ImGuiViewportFlags_None); // Mark window as allowed to protrude outside of its viewport and into the current monitor if (!lock_viewport) @@ -16393,6 +16403,10 @@ static void ImGui::WindowSelectViewport(ImGuiWindow* window) window->ViewportAllowPlatformMonitorExtend = FindPlatformMonitorForPos((use_mouse_ref && mouse_valid) ? mouse_ref : NavCalcPreferredRefPos()); else window->ViewportAllowPlatformMonitorExtend = window->Viewport->PlatformMonitor; + // MaSzyna addition: see io.ConfigViewportsNoAutoDetach. Over the main viewport they stay inside it: the late creation of a + // viewport in Begin() needs the extent of the monitor + if (g.IO.ConfigViewportsNoAutoDetach && window->Viewport == main_viewport) + window->ViewportAllowPlatformMonitorExtend = -1; } else if (window->Viewport && window != window->Viewport->Window && window->Viewport->Window && !(flags & ImGuiWindowFlags_ChildWindow) && window->DockNode == NULL) { diff --git a/imgui/imgui.h b/imgui/imgui.h index 6bbc42dec..6988a0127 100644 --- a/imgui/imgui.h +++ b/imgui/imgui.h @@ -2360,7 +2360,7 @@ struct ImGuiIO bool ConfigViewportsNoTaskBarIcon; // = false // Disable default OS task bar icon flag for secondary viewports. When a viewport doesn't want a task bar icon, ImGuiViewportFlags_NoTaskBarIcon will be set on it. bool ConfigViewportsNoDecoration; // = true // Disable default OS window decoration flag for secondary viewports. When a viewport doesn't want window decorations, ImGuiViewportFlags_NoDecoration will be set on it. Enabling decoration can create subsequent issues at OS levels (e.g. minimum window size). bool ConfigViewportsNoDefaultParent; // = false // Disable default OS parenting to main viewport for secondary viewports. By default, viewports are marked with ParentViewportId = , expecting the platform backend to setup a parent/child relationship between the OS windows (some backend may ignore this). Set to true if you want the default to be 0, then all viewports will be top-level OS windows. - bool ConfigViewportsNoAutoDetach; // = false // MaSzyna addition: a floating window stays inside its host viewport: a resize stops at its edge, and a window left past it, or too big for it, is moved and shrunk to fit. It gets a viewport of its own only when dragged with the mouse cursor past the host viewport. Popups and tooltips are not affected. + bool ConfigViewportsNoAutoDetach; // = false // MaSzyna addition: a floating window stays inside its host viewport: a resize stops at its edge, and a window left past it, or too big for it, is moved and shrunk to fit. It gets a viewport of its own only when dragged with the mouse cursor past the host viewport. Tooltips and popups shown over the main viewport, or begun outside any window, get no viewport of their own either: they are placed inside the main viewport as with the viewports off. // Miscellaneous options // (you can visualize and interact with all options in 'Demo->Configuration') @@ -2375,6 +2375,7 @@ struct ImGuiIO bool ConfigWindowsCopyContentsWithCtrlC; // = false // [EXPERIMENTAL] CTRL+C copy the contents of focused window into the clipboard. Experimental because: (1) has known issues with nested Begin/End pairs (2) text output quality varies (3) text output is in submission order rather than spatial order. bool ConfigScrollbarScrollByPage; // = true // Enable scrolling page by page when clicking outside the scrollbar grab. When disabled, always scroll to clicked location. When enabled, Shift+Click scrolls to clicked location. float ConfigMemoryCompactTimer; // = 60.0f // Timer (in seconds) to free transient windows/tables memory buffers when unused. Set to -1.0f to disable. + float ConfigTooltipsWrapWidth; // = 0.0f // MaSzyna addition: the text of SetTooltip() and SetItemTooltip() wraps at this width, in pixels; 0: it doesn't wrap. BeginTooltip() is not affected. // Inputs Behaviors // (other variables, ones which are expected to be tweaked within UI code, are exposed in ImGuiStyle) diff --git a/input/command.cpp b/input/command.cpp index 0ae67cfa5..7d3fe7d1d 100644 --- a/input/command.cpp +++ b/input/command.cpp @@ -158,6 +158,9 @@ commanddescription_sequence Commands_descriptions = { {"radiovolumeincrease", command_target::vehicle, command_mode::oneoff}, {"radiovolumedecrease", command_target::vehicle, command_mode::oneoff}, {"radiovolumeset", command_target::vehicle, command_mode::oneoff}, + {"radiofusetoggle", command_target::vehicle, command_mode::oneoff}, + {"radiofuseenable", command_target::vehicle, command_mode::oneoff}, + {"radiofusedisable", command_target::vehicle, command_mode::oneoff}, {"cabchangeforward", command_target::vehicle, command_mode::oneoff}, {"cabchangebackward", command_target::vehicle, command_mode::oneoff}, {"modernlightdimmerdecrease", command_target::vehicle, command_mode::oneoff}, @@ -406,6 +409,12 @@ commanddescription_sequence Commands_descriptions = { {"wiperswitchdecrease", command_target::vehicle, command_mode::oneoff}, {"lightsset", command_target::vehicle, command_mode::oneoff}, {"oilfuelpumptoggle", command_target::vehicle, command_mode::oneoff}, + {"linebreakertoggleb", command_target::vehicle, command_mode::oneoff}, + {"linebreakeropenb", command_target::vehicle, command_mode::oneoff}, + {"linebreakercloseb", command_target::vehicle, command_mode::oneoff}, + {"linebreakertogglec", command_target::vehicle, command_mode::oneoff}, + {"linebreakeropenc", command_target::vehicle, command_mode::oneoff}, + {"linebreakerclosec", command_target::vehicle, command_mode::oneoff}, }; // Maps of command and coresponding strings @@ -544,6 +553,9 @@ std::unordered_map const commandMap = { {"radiovolumeincrease", user_command::radiovolumeincrease}, {"radiovolumedecrease", user_command::radiovolumedecrease}, {"radiovolumeset", user_command::radiovolumeset}, + {"radiofusetoggle", user_command::radiofusetoggle}, + {"radiofuseenable", user_command::radiofuseenable}, + {"radiofusedisable", user_command::radiofusedisable}, {"cabchangeforward", user_command::cabchangeforward}, {"cabchangebackward", user_command::cabchangebackward}, {"viewturn", user_command::viewturn}, @@ -791,6 +803,12 @@ std::unordered_map const commandMap = { {"wiperswitchdecrease", user_command::wiperswitchdecrease}, {"lightsset", user_command::lightsset}, {"oilfuelpumptoggle", user_command::oilfuelpumptoggle}, + {"linebreakertoggleb", user_command::linebreakertoggleb}, + {"linebreakeropenb", user_command::linebreakeropenb}, + {"linebreakercloseb", user_command::linebreakercloseb}, + {"linebreakertogglec", user_command::linebreakertogglec}, + {"linebreakeropenc", user_command::linebreakeropenc}, + {"linebreakerclosec", user_command::linebreakerclosec}, {"none", user_command::none}}; } // namespace simulation diff --git a/input/command.h b/input/command.h index ddacef4a0..aaf361e25 100644 --- a/input/command.h +++ b/input/command.h @@ -151,6 +151,9 @@ enum class user_command radiovolumeincrease, radiovolumedecrease, radiovolumeset, + radiofusetoggle, + radiofuseenable, + radiofusedisable, cabchangeforward, cabchangebackward, @@ -404,6 +407,12 @@ enum class user_command wiperswitchdecrease, lightsset, oilfuelpumptoggle, + linebreakertoggleb, + linebreakeropenb, + linebreakercloseb, + linebreakertogglec, + linebreakeropenc, + linebreakerclosec, none = -1 }; diff --git a/input/driverkeyboardinput.cpp b/input/driverkeyboardinput.cpp index e7e636b31..047f3678c 100644 --- a/input/driverkeyboardinput.cpp +++ b/input/driverkeyboardinput.cpp @@ -160,6 +160,9 @@ driverkeyboard_input::default_bindings() { // radiovolumeincrease, // radiovolumedecrease, // radiovolumeset, + // radiofusetoggle, + // radiofuseenable, + // radiofusedisable, { cabchangeforward, {GLFW_KEY_HOME, ""} }, { cabchangebackward, {GLFW_KEY_END, ""} }, // viewturn, diff --git a/input/drivermouseinput.cpp b/input/drivermouseinput.cpp index 22562b856..222c58a62 100644 --- a/input/drivermouseinput.cpp +++ b/input/drivermouseinput.cpp @@ -597,6 +597,18 @@ drivermouse_input::default_bindings() { { "main_on_bt:",{ linebreakerclose, none } }, + { "mainb_off_bt:", { + linebreakeropenb, + none } }, + { "mainb_on_bt:", { + linebreakercloseb, + none } }, + { "mainc_off_bt:", { + linebreakeropenc, + none } }, + { "mainc_on_bt:", { + linebreakerclosec, + none } }, { "security_reset_bt:", { alerteracknowledge, none } }, @@ -774,6 +786,12 @@ drivermouse_input::default_bindings() { { "main_sw:", { linebreakertoggle, none } }, + { "mainb_sw:", { + linebreakertoggleb, + none } }, + { "mainc_sw:", { + linebreakertogglec, + none } }, { "radio_sw:", { radiotoggle, none } }, @@ -783,6 +801,15 @@ drivermouse_input::default_bindings() { { "radiooff_sw:", { radiodisable, none } }, + { "radiofuse_sw:", { + radiofusetoggle, + none } }, + { "radiofuseon_sw:", { + radiofuseenable, + none } }, + { "radiofuseoff_sw:", { + radiofusedisable, + none } }, { "radiochannel_sw:", { radiochannelincrease, radiochanneldecrease } }, diff --git a/lang/editor_tutorial/camera.gif b/lang/editor_tutorial/camera.gif new file mode 100644 index 000000000..3558c0c12 Binary files /dev/null and b/lang/editor_tutorial/camera.gif differ diff --git a/lang/editor_tutorial/curves.gif b/lang/editor_tutorial/curves.gif new file mode 100644 index 000000000..2d9f93a05 Binary files /dev/null and b/lang/editor_tutorial/curves.gif differ diff --git a/lang/editor_tutorial/edit.gif b/lang/editor_tutorial/edit.gif new file mode 100644 index 000000000..e8aa5e162 Binary files /dev/null and b/lang/editor_tutorial/edit.gif differ diff --git a/lang/editor_tutorial/gizmo.gif b/lang/editor_tutorial/gizmo.gif new file mode 100644 index 000000000..c5f192c36 Binary files /dev/null and b/lang/editor_tutorial/gizmo.gif differ diff --git a/lang/editor_tutorial/join.gif b/lang/editor_tutorial/join.gif new file mode 100644 index 000000000..49c5e75e7 Binary files /dev/null and b/lang/editor_tutorial/join.gif differ diff --git a/lang/editor_tutorial/lay.gif b/lang/editor_tutorial/lay.gif new file mode 100644 index 000000000..09c9da71a Binary files /dev/null and b/lang/editor_tutorial/lay.gif differ diff --git a/lang/editor_tutorial/plan.gif b/lang/editor_tutorial/plan.gif new file mode 100644 index 000000000..03f5e7f77 Binary files /dev/null and b/lang/editor_tutorial/plan.gif differ diff --git a/lang/editor_tutorial/switch.gif b/lang/editor_tutorial/switch.gif new file mode 100644 index 000000000..56d219146 Binary files /dev/null and b/lang/editor_tutorial/switch.gif differ diff --git a/rendering/opengl33renderer.cpp b/rendering/opengl33renderer.cpp index 39c0d865c..d96c878f4 100644 --- a/rendering/opengl33renderer.cpp +++ b/rendering/opengl33renderer.cpp @@ -5692,12 +5692,15 @@ void opengl33_renderer::Update(double const Deltatime) } m_updateaccumulator = 0.0; - m_framerate = 1000.f / ( Timer::subsystem.mainloop_total.average() ); + // the frames actually shown, the wait for fpslimit included (eu07/maszyna#416) + m_framerate = 1000.f / ( Timer::subsystem.mainloop_period.average() ); + // the frames the work alone would allow, so a frame rate held down by fpslimit doesn't cut the draw ranges + auto const workframerate{1000.f / Timer::subsystem.mainloop_total.average()}; // adjust draw ranges etc, based on recent performance if (Global.targetfps != 0.0f) { - float fps_diff = Global.targetfps - m_framerate; + float fps_diff = Global.targetfps - workframerate; if (fps_diff > 0.0f) Global.fDistanceFactor = std::max(0.5f, Global.fDistanceFactor - 0.05f); else @@ -5705,7 +5708,7 @@ void opengl33_renderer::Update(double const Deltatime) } // legacy framerate parameters else if (Global.fFpsAverage != 0.f) { - auto const fps_diff = m_framerate - Global.fFpsAverage; + auto const fps_diff = workframerate - Global.fFpsAverage; if (fps_diff < -Global.fFpsDeviation) { Global.fDistanceFactor = std::min(std::max(1.0f, Global.fDistanceFactor - 0.05f), Global.gfx_distance_factor_max); } diff --git a/rendering/openglrenderer.cpp b/rendering/openglrenderer.cpp index 180dba771..8c6debdc7 100644 --- a/rendering/openglrenderer.cpp +++ b/rendering/openglrenderer.cpp @@ -68,6 +68,28 @@ submodel_material( TSubModel const *Submodel ) { null_handle ); } +bool +is_scaled( glm::vec3 const &Scale ) { + + return ( Scale.x != 1.0f ) || ( Scale.y != 1.0f ) || ( Scale.z != 1.0f ); +} + +// pushes the placement of a scaled model instance: the translation and rotation of Render( TModel3d *, ..., Position, Angle ), +// followed by the scale of the instance, applied before the submodel transforms (as in the opengl 3.3 renderer) +void +push_scaled_instance_transform( glm::dvec3 const &Position, glm::vec3 const &Angle, glm::vec3 const &Scale ) { + + ::glPushMatrix(); + ::glTranslated( Position.x, Position.y, Position.z ); + if( Angle.y != 0.0 ) + ::glRotatef( Angle.y, 0.f, 1.f, 0.f ); + if( Angle.x != 0.0 ) + ::glRotatef( Angle.x, 1.f, 0.f, 0.f ); + if( Angle.z != 0.0 ) + ::glRotatef( Angle.z, 0.f, 0.f, 1.f ); + ::glScalef( Scale.x, Scale.y, Scale.z ); +} + } // namespace float const EU07_OPACITYDEFAULT { 0.5f }; @@ -2475,12 +2497,23 @@ opengl_renderer::Render( TAnimModel *Instance ) { Instance->RaPrepare(); if( Instance->pModel ) { // renderowanie rekurencyjne submodeli - Render( - Instance->pModel, - Instance->Material(), - distancesquared, - Instance->location() - m_renderpass.camera.position(), - Instance->vAngle ); + auto const position { Instance->location() - m_renderpass.camera.position() }; + if( is_scaled( Instance->Scale() ) ) { + // the scale stretches the normals too, they're normalized again for the lighting + push_scaled_instance_transform( position, Instance->vAngle, Instance->Scale() ); + m_normalizenormals = true; + Render( Instance->pModel, Instance->Material(), distancesquared ); + m_normalizenormals = false; + ::glPopMatrix(); + } + else { + Render( + Instance->pModel, + Instance->Material(), + distancesquared, + position, + Instance->vAngle ); + } // debug data ++m_renderpass.draw_stats.models; } @@ -2848,7 +2881,7 @@ opengl_renderer::Render( TSubModel *Submodel ) { break; } } #else - if( true == m_renderspecular ) { + if( ( true == m_renderspecular ) || ( true == m_normalizenormals ) ) { ::glEnable( GL_NORMALIZE ); } #endif @@ -2937,7 +2970,7 @@ opengl_renderer::Render( TSubModel *Submodel ) { break; } } #else - if( true == m_renderspecular ) { + if( ( true == m_renderspecular ) || ( true == m_normalizenormals ) ) { ::glDisable( GL_NORMALIZE ); } #endif @@ -3632,12 +3665,23 @@ opengl_renderer::Render_Alpha( TAnimModel *Instance ) { Instance->RaPrepare(); if( Instance->pModel ) { // renderowanie rekurencyjne submodeli - Render_Alpha( - Instance->pModel, - Instance->Material(), - distancesquared, - Instance->location() - m_renderpass.camera.position(), - Instance->vAngle ); + auto const position { Instance->location() - m_renderpass.camera.position() }; + if( is_scaled( Instance->Scale() ) ) { + // the scale stretches the normals too, they're normalized again for the lighting + push_scaled_instance_transform( position, Instance->vAngle, Instance->Scale() ); + m_normalizenormals = true; + Render_Alpha( Instance->pModel, Instance->Material(), distancesquared ); + m_normalizenormals = false; + ::glPopMatrix(); + } + else { + Render_Alpha( + Instance->pModel, + Instance->Material(), + distancesquared, + position, + Instance->vAngle ); + } } } @@ -3940,7 +3984,7 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) { break; } } #else - if( true == m_renderspecular ) { + if( ( true == m_renderspecular ) || ( true == m_normalizenormals ) ) { ::glEnable( GL_NORMALIZE ); } #endif @@ -4010,7 +4054,7 @@ opengl_renderer::Render_Alpha( TSubModel *Submodel ) { break; } } #else - if( true == m_renderspecular ) { + if( ( true == m_renderspecular ) || ( true == m_normalizenormals ) ) { ::glDisable( GL_NORMALIZE ); } #endif @@ -4327,12 +4371,15 @@ opengl_renderer::Update( double const Deltatime ) { } m_updateaccumulator = 0.0; - m_framerate = 1000.f / ( Timer::subsystem.gfx_total.average() ); + // the frames actually shown, the wait for fpslimit included (eu07/maszyna#416) + m_framerate = 1000.f / ( Timer::subsystem.mainloop_period.average() ); + // the draw ranges follow the time spent on drawing alone, as before + auto const drawframerate { 1000.f / ( Timer::subsystem.gfx_total.average() ) }; // adjust draw ranges etc, based on recent performance // TODO: it doesn't make much sense with vsync if( Global.targetfps != 0.f ) { - auto const fps_diff = m_framerate - Global.targetfps; + auto const fps_diff = drawframerate - Global.targetfps; if( fps_diff < -0.5f ) { Global.fDistanceFactor = std::min( std::max( 1.0f, Global.fDistanceFactor - 0.05f ), Global.gfx_distance_factor_max ); } @@ -4342,7 +4389,7 @@ opengl_renderer::Update( double const Deltatime ) { } // legacy framerate parameters else if( Global.fFpsAverage != 0.f ) { - auto const fps_diff = m_framerate - Global.fFpsAverage; + auto const fps_diff = drawframerate - Global.fFpsAverage; if( fps_diff < -Global.fFpsDeviation ) { Global.fDistanceFactor = std::min( std::max( 1.0f, Global.fDistanceFactor - 0.05f ), Global.gfx_distance_factor_max ); } diff --git a/rendering/openglrenderer.h b/rendering/openglrenderer.h index 3a3538a6c..15c9e7cdb 100644 --- a/rendering/openglrenderer.h +++ b/rendering/openglrenderer.h @@ -364,6 +364,7 @@ private: float m_specularopaquescalefactor { 1.f }; float m_speculartranslucentscalefactor { 1.f }; bool m_renderspecular{ false }; // controls whether to include specular component in the calculations + bool m_normalizenormals{ false }; // set while a scaled model instance is drawn, its normals need normalizing for the lighting renderpass_config m_renderpass; // parameters for current render pass section_sequence m_sectionqueue; // list of sections in current render pass diff --git a/staticFiles/python/local/abstractscreenrenderer.py b/staticFiles/python/local/abstractscreenrenderer.py index ea8be2c56..3ebf20813 100644 --- a/staticFiles/python/local/abstractscreenrenderer.py +++ b/staticFiles/python/local/abstractscreenrenderer.py @@ -1,7 +1,25 @@ -from PIL import Image +from PIL import Image, ImageDraw, ImageFont from math import ceil, floor, cos, sin, radians import os +# Pillow 10 removed ImageFont.getsize(), ImageDraw.textsize() and Image.ANTIALIAS, which the screen scripts use; for +# Python 3.14 only a newer Pillow is available, so they are put back, on top of getbbox() / textbbox() and LANCZOS +def _font_getsize(self, text, *args, **kwargs): + box = self.getbbox(text, *args, **kwargs) + return (box[2], box[3]) + +def _draw_textsize(self, text, font=None, *args, **kwargs): + box = self.textbbox((0, 0), text, font, *args, **kwargs) + return (box[2], box[3]) + +for _fontclass in (ImageFont.FreeTypeFont, ImageFont.ImageFont, getattr(ImageFont, 'TransposedFont', None)): + if _fontclass is not None and not hasattr(_fontclass, 'getsize') and hasattr(_fontclass, 'getbbox'): + _fontclass.getsize = _font_getsize +if not hasattr(ImageDraw.ImageDraw, 'textsize'): + ImageDraw.ImageDraw.textsize = _draw_textsize +if not hasattr(Image, 'ANTIALIAS'): + Image.ANTIALIAS = Image.LANCZOS + class abstractscreenrenderer(): def __init__(self, lookup_path): self.width = 0 diff --git a/tests/unit/test_ai_hints.cpp b/tests/unit/test_ai_hints.cpp new file mode 100644 index 000000000..d01e421c9 --- /dev/null +++ b/tests/unit/test_ai_hints.cpp @@ -0,0 +1,31 @@ +#include "stdafx.h" +#include "doctest.h" +#include "vehicle.h" + +using test::definition; +using test::vehicle; + +// the hints for the AI driver from the AI section of the .fiz + +TEST_CASE("ai hints: without the AI section the pantographs follow the built-in logic") { + vehicle wagon{definition::load("wagon")}; + + CHECK(wagon->AIHintPantstate == 0); + CHECK(wagon->AIHintShuntPantstate == 0); + CHECK(wagon->AIHintPantUpIfIdle); +} + +TEST_CASE("ai hints: the suggested pantograph setup for shunting is read apart from the one for train mode") { + // eu07/maszyna#461: so the ET41 doesn't shunt with all of its four pantographs up + vehicle shunting{definition::load("wagon").set("AI", "Pantstate", 1).set("AI", "ShuntPantstate", 2)}; + + CHECK(shunting->AIHintPantstate == 1); + CHECK(shunting->AIHintShuntPantstate == 2); +} + +TEST_CASE("ai hints: a .fiz with the setup for train mode only has none for shunting") { + vehicle train{definition::load("wagon").set("AI", "Pantstate", 3)}; + + CHECK(train->AIHintPantstate == 3); + CHECK(train->AIHintShuntPantstate == 0); +} diff --git a/tests/unit/test_brake_handles.cpp b/tests/unit/test_brake_handles.cpp index 51c25243b..889beb338 100644 --- a/tests/unit/test_brake_handles.cpp +++ b/tests/unit/test_brake_handles.cpp @@ -4,6 +4,7 @@ #include "golden.h" #include "real_vehicles.h" #include "drive.h" +#include "consist.h" #include "McZapkie/hamulce.h" @@ -35,6 +36,7 @@ void hold(vehicle &Vehicle, test::trace &Trace, std::string const &Event, double // every position of the driver's handle, recorded in the trace void every_position(vehicle &Vehicle, test::trace &Trace) { Vehicle.hold_main_reservoir(std::max(Vehicle->MaxCompressor, 8.0)); + REQUIRE(Vehicle->Handle != nullptr); auto &handle{*Vehicle->Handle}; Vehicle.record(Trace); @@ -57,6 +59,13 @@ void every_position(vehicle &Vehicle, test::trace &Trace) { hold(Vehicle, Trace, "running", handle.GetPos(bh_RP), 60.0); } +// the handle put to the given position and the vehicle driven from its cab for Seconds, marked in the trace +void driven_at(vehicle &Vehicle, test::trace &Trace, std::string const &Event, double Position, double Seconds) { + Trace.mark(Event); + Vehicle->BrakeLevelSet(Position); + test::drive(test::driving(Vehicle), {}, Seconds); +} + } // namespace TEST_CASE("brake handles: every position of the driver's handle of every real vehicle") { @@ -96,6 +105,7 @@ TEST_CASE("brake handles: the local brake handle of every real vehicle") { real.hold_main_reservoir(std::max(real->MaxCompressor, 8.0)); test::trace trace{"local brake/" + path, handle_channels(), 100}; real.record(trace); + REQUIRE(real->Handle != nullptr); real->BrakeLevelSet(real->Handle->GetPos(bh_RP)); trace.mark("charge"); real.run(60.0); @@ -126,25 +136,21 @@ TEST_CASE("brake handles: the overload and the high pressure buttons of the MHZ real.hold_main_reservoir(std::max(real->MaxCompressor, 8.0)); test::trace trace{"brake handles/buttons/" + name, handle_channels(), 100}; real.record(trace); + REQUIRE(real->Handle != nullptr); auto &handle{*real->Handle}; - auto const at{[&trace, &real](std::string const &Event, double Position, double Seconds) { - trace.mark(Event); - real->BrakeLevelSet(Position); - test::drive(test::driving(real), {}, Seconds); - }}; - at("running", handle.GetPos(bh_RP), 60.0); + driven_at(real, trace, "running", handle.GetPos(bh_RP), 60.0); auto const running{real->PipePress}; handle.SetUniversalFlag(TUniversalBrake::ub_Overload); - at("overload button", handle.GetPos(bh_RP), 30.0); + driven_at(real, trace, "overload button", handle.GetPos(bh_RP), 30.0); handle.SetUniversalFlag(0); auto const overloaded{real->PipePress}; - at("overload decaying", handle.GetPos(bh_RP), 240.0); + driven_at(real, trace, "overload decaying", handle.GetPos(bh_RP), 240.0); auto const decayed{real->PipePress}; handle.SetUniversalFlag(TUniversalBrake::ub_HighPressure); - at("high pressure button, filling stroke", handle.GetPos(bh_FS), 10.0); + driven_at(real, trace, "high pressure button, filling stroke", handle.GetPos(bh_FS), 10.0); auto const filled{real->PipePress}; handle.SetUniversalFlag(0); - at("running", handle.GetPos(bh_RP), 120.0); + driven_at(real, trace, "running", handle.GetPos(bh_RP), 120.0); CHECK(running == doctest::Approx(5.0).epsilon(0.01)); CHECK(overloaded > running + 0.3); CHECK(decayed < overloaded); @@ -152,3 +158,110 @@ TEST_CASE("brake handles: the overload and the high pressure buttons of the MHZ trace.check(); } } + +// eu07/maszyna#134: the Knorr St113 of the EN57-001 releases the EP brake in the running position (bh_RP, Num 6) +// and applies it one position on (Num 8), short of the lap position (Num 5); the positions are those the keys +// select, and the EP brake works only with the control of the cab powered: the battery, the reverser out of +// neutral and the EP fuse on (Ctrl+Z), as the Oerlikon handle's +namespace { + +// the front car of the EN57-001 driven from its cab, with the motor car behind it, which has the battery of the two; +// air in the reservoirs, the battery on +void ready_knorr_ep(test::consist &Unit) { + Unit.add(definition::fiz("en57_v1/6bai"), 1); + Unit.add(definition::fiz("en57_v1/5bgb")); + auto &cab{Unit[0]}; + REQUIRE(cab->BrakeHandle == TBrakeHandle::St113); + REQUIRE(cab->Handle != nullptr); + cab->BatterySwitch(true); + cab->CabActivisation(); + cab.hold_brake_pipe(5.0); + cab->BrakeLevelSet(cab->Handle->GetPos(bh_RP)); + Unit.run(60.0); +} + +// the EP brake button pressed in the given handle position, held for Seconds; the cylinder pressure of the cab car +double ep_brake(test::consist &Unit, double Position, double Seconds) { + auto &cab{Unit[0]}; + cab->BrakeLevelSet(Position); + Unit.run(0.1); + cab->SwitchEPBrake(1); + Unit.run(Seconds); + return cab->BrakePress; +} + +// the EP force the St113 handle of the cab car gives in the given position +double ep_at(test::consist &Unit, double Position) { + auto &cab{Unit[0]}; + cab->BrakeLevelSet(Position); + Unit.run(0.1); + return cab->Handle->GetEP(); +} + +} // namespace + +TEST_CASE("brake handles: the positions of the Knorr St113 EP brake") { + test::consist unit; + ready_knorr_ep(unit); + auto &cab{unit[0]}; + REQUIRE(cab->Handle != nullptr); + auto &handle{*cab->Handle}; + // the keys: Num 6 running, Num 8 the first position on, Num 5 the middle of the handle + CHECK(handle.GetPos(bh_RP) == doctest::Approx(0.0)); + CHECK(ep_at(unit, 0.0) == doctest::Approx(-1.0)); // EP release + CHECK(ep_at(unit, 1.0) == doctest::Approx(1.0)); // EP brake + CHECK(ep_at(unit, cab->BrakeCtrlPosNo / 2) == doctest::Approx(0.0)); // lap, Num 5 + CHECK(ep_at(unit, handle.GetPos(bh_FB)) == doctest::Approx(0.0)); + CHECK(ep_at(unit, handle.GetPos(bh_EPR)) == doctest::Approx(-1.0)); + CHECK(ep_at(unit, handle.GetPos(bh_EPB)) == doctest::Approx(1.0)); +} + +TEST_CASE("brake handles: the Knorr St113 EP brake needs the control of the cab powered") { + for (std::string const cut : {"reverser in neutral", "EP fuse off", "battery off"}) { + CAPTURE(cut); + test::consist unit; + ready_knorr_ep(unit); + auto &cab{unit[0]}; + cab->DirectionForward(); + unit.run(1.0); + REQUIRE(cab->EPBrakeControlPowered()); + if (cut == "reverser in neutral") { + cab->DirectionBackward(); + } + else if (cut == "EP fuse off") { + cab->EpFuseSwitch(false); + } + else { + cab->BatterySwitch(false); + } + unit.run(1.0); + REQUIRE_FALSE(cab->EPBrakeControlPowered()); + // the button in the EP brake position does nothing + CHECK(ep_brake(unit, 1.0, 5.0) < 0.1); + CHECK(cab->EpForce == doctest::Approx(0.0)); + cab->SwitchEPBrake(0); + } + + test::consist unit; + ready_knorr_ep(unit); + auto &cab{unit[0]}; + cab->DirectionForward(); + unit.run(1.0); + // powered, the EP brake applies + auto const applied{ep_brake(unit, 1.0, 2.0)}; + CHECK(applied > 0.5); + // the reverser put to neutral with the button still held: the EP brake drops out and holds what it applied + cab->DirectionBackward(); + unit.run(0.1); + CHECK(cab->EpForce == doctest::Approx(0.0)); + auto const held{cab->BrakePress}; + unit.run(5.0); + CHECK(cab->BrakePress < held + 0.05); + CHECK(cab->BrakePress > 0.2); + // and doesn't release either, until the control is powered again + CHECK(ep_brake(unit, 0.0, 5.0) > 0.2); + cab->SwitchEPBrake(0); + cab->DirectionForward(); + unit.run(0.1); + CHECK(ep_brake(unit, 0.0, 10.0) < 0.1); +} diff --git a/tests/unit/test_brakes.cpp b/tests/unit/test_brakes.cpp index 834168074..e12694f3f 100644 --- a/tests/unit/test_brakes.cpp +++ b/tests/unit/test_brakes.cpp @@ -1,6 +1,7 @@ #include "stdafx.h" #include "doctest.h" #include "vehicle.h" +#include "consist.h" using test::definition; using test::vehicle; @@ -91,3 +92,48 @@ TEST_CASE("brakes: service braking stops a heavier wagon too") { wagon.run(40.0 /* s */, test::track{0.15 /* friction */, 0.0 /* gradient */}); CHECK(std::abs(wagon.speed()) < 0.1); } + +// eu07/maszyna#87: the ESt4d of the EN57's EP2 valve charged its auxiliary reservoir from the main reservoir pipe +// alone, so a dead unit hauled by a locomotive coupled with the hook and the brake hose ("3") never charged it, +// its control reservoir stopped half way, and it didn't brake. Like every ESt, it charges from the brake pipe too +TEST_CASE("brakes: a dead EN57 hauled with the brake hose alone charges from the brake pipe and brakes") { + test::consist train; + auto &locomotive{train.add(definition::fiz("sm42_v1/6d1"))}; + train.add(definition::fiz("en57_v1/5bgb"), 0, coupling::coupler | coupling::brakehose); + train.add(definition::fiz("en57_v1/6ba_840")); + train.add(definition::fiz("en57_v1/5bgaiii_led_spot")); + // a unit standing dead: no air anywhere, nothing in its main reservoir pipe + for (std::size_t i = 1; i < train.size(); ++i) { + auto &car{train[i].mover()}; + REQUIRE(car.BrakeValve == TBrakeValve::EP2); + car.Hamulec->ForceEmptiness(); + car.Pipe->CreatePress(0.0); + car.Pipe->Act(); + car.Pipe2->CreatePress(0.0); + car.Pipe2->Act(); + car.CompressedVolume = 0.0; + } + locomotive.hold_brake_pipe(5.0); + train.run(900.0); + for (std::size_t i = 1; i < train.size(); ++i) { + CAPTURE(i); + auto &car{train[i].mover()}; + REQUIRE(car.ScndPipePress < 0.1); // no main reservoir pipe + CHECK(car.Hamulec->GetBRP() > 4.8); + CHECK(car.Hamulec->GetCRP() > 4.8); + CHECK(car.BrakePress < 0.1); + } + // a full service application brakes the unit, and it releases again + locomotive.hold_brake_pipe(3.5); + train.run(20.0); + for (std::size_t i = 1; i < train.size(); ++i) { + CAPTURE(i); + CHECK(train[i]->BrakePress > 2.0); + } + locomotive.hold_brake_pipe(5.0); + train.run(60.0); + for (std::size_t i = 1; i < train.size(); ++i) { + CAPTURE(i); + CHECK(train[i]->BrakePress < 0.1); + } +} diff --git a/tests/unit/test_cab.cpp b/tests/unit/test_cab.cpp index 4c5ba9f53..063e70911 100644 --- a/tests/unit/test_cab.cpp +++ b/tests/unit/test_cab.cpp @@ -227,3 +227,204 @@ TEST_CASE("cab: the lamps and the buzzer of the security system left unattended" CHECK(security.radiostop_available()); scenario.check(); } + +namespace { + +// the SM42, its shunt mode switching its vigilance device (CA) off or not (AwareOffInShuntMode), set in the +// test whatever the converted definition says +definition sm42_vigilance(bool const Off) { + return definition::fiz("sm42_v1/6d1").set("Security", "AwareOffInShuntMode", Off ? "Yes" : "No"); +} + +// runs the train for Seconds with nobody acknowledging the vigilance; returns whether the vigilance alarm came +bool unattended(scenario &Scenario, int const Seconds) { + bool blinked{false}; + for (int i = 0; i < Seconds; ++i) { + Scenario.train().run(1.0, Scenario.line()); + blinked |= Scenario.cab().SecuritySystem.is_vigilance_blinking(); + } + return blinked; +} + +} // namespace + +TEST_CASE("cab: the SM42's vigilance device switched off in the shunt mode, where its definition says so") { + // eu07/maszyna#457: with AwareOffInShuntMode=Yes the shunt mode of the SM42 switches its vigilance device (CA) + // off, it alerts again once the shunt mode is off + scenario scenario{"cab/sm42 vigilance in shunt mode", motion() + brakes(), test::track{}}; + scenario.train().add(sm42_vigilance(true), 1); + REQUIRE(scenario.start_up()); + auto &sm42{scenario.cab()}; + auto const &security{sm42.SecuritySystem}; + REQUIRE(sm42.CurrentSwitch(true)); + REQUIRE(sm42.ShuntMode); + scenario.get_going(); + sm42.AnPos = 0.3; + sm42.IncMainCtrl(1); + scenario.act("unattended in shunt mode"); + bool blinked{false}; + for (int i = 0; i < 120; ++i) { + scenario.train().run(1.0, scenario.line()); + blinked |= security.is_blinking(); + } + CHECK(sm42.Vel > 1.0); + CHECK_FALSE(blinked); + CHECK(sm42.PipePress > 3.5); + scenario.act("shunt mode off"); + scenario.notch_back(0); + REQUIRE(sm42.CurrentSwitch(false)); + sm42.IncMainCtrl(1); + scenario.act("unattended"); + CHECK(unattended(scenario, 120)); + scenario.check(); +} + +TEST_CASE("cab: the vigilance device of the SM42 kept in the shunt mode, by default") { + // without AwareOffInShuntMode the shunt mode leaves the vigilance device alone: unattended, it alerts and brakes + scenario scenario{"cab/sm42 vigilance kept in shunt mode", motion() + brakes(), test::track{}}; + scenario.train().add(sm42_vigilance(false), 1); + REQUIRE(scenario.start_up()); + auto &sm42{scenario.cab()}; + REQUIRE(sm42.CurrentSwitch(true)); + REQUIRE(sm42.ShuntMode); + scenario.get_going(); + sm42.AnPos = 0.3; + sm42.IncMainCtrl(1); + scenario.act("unattended in shunt mode"); + CHECK(unattended(scenario, 120)); + CHECK(sm42.ShuntMode); + CHECK(sm42.PipePress < 1.0); + scenario.check(); +} + +TEST_CASE("cab: the SM42's vigilance alarm on, not cleared by switching into the shunt mode") { + // the shunt mode switches the vigilance device off for the time to come: an alarm already on goes on to the + // emergency braking, until the driver acknowledges it (#275 review) + scenario scenario{"cab/sm42 vigilance alarm into shunt mode", motion() + brakes(), test::track{}}; + scenario.train().add(sm42_vigilance(true), 1); + REQUIRE(scenario.start_up()); + auto &sm42{scenario.cab()}; + auto const &security{sm42.SecuritySystem}; + scenario.get_going(); + sm42.IncMainCtrl(1); + scenario.act("unattended"); + // the alerter counts only on the move, which takes a while on the first notch + for (int i = 0; i < 300 && false == security.is_vigilance_blinking(); ++i) { + scenario.train().run(1.0, scenario.line()); + } + REQUIRE(security.is_vigilance_blinking()); + REQUIRE_FALSE(security.is_braking()); + scenario.act("shunt mode on"); + for (int i = 0; i < 20 && false == sm42.IsMainCtrlNoPowerPos(); ++i) { + sm42.DecMainCtrl(1); + } + REQUIRE(sm42.CurrentSwitch(true)); + REQUIRE(sm42.ShuntMode); + scenario.train().run(15.0, scenario.line()); + CHECK(security.is_vigilance_blinking()); + CHECK(security.is_beeping()); + CHECK(security.is_braking()); + CHECK(sm42.PipePress < 1.0); + scenario.act("acknowledged"); + sm42.SecuritySystemReset(); + scenario.train().run(1.0, scenario.line()); + CHECK_FALSE(security.is_blinking()); + CHECK_FALSE(security.is_braking()); + scenario.check(); +} + +namespace { + +TSecuritySystem sm42_security(bool const OffInShuntMode) { + TSecuritySystem security; + security.load(std::string{"Security: AwareSystem=Active AwareMinSpeed=0.0 AwareDelay=60 SoundSignalDelay=2.5 MaxHoldTime=1.0 " + "EmergencyBrakeDelay=2.5 AwareOffInShuntMode="} + + (OffInShuntMode ? "Yes" : "No"), + 90.0); + security.set_enabled(true); + security.update(0.1, 20.0, true, 1); + return security; +} + +void run(TSecuritySystem &Security, double const Seconds) { + for (int i = 0; i < std::lround(Seconds / 0.1); ++i) { + Security.update(0.1, 20.0, true, 1); + } +} + +} // namespace + +TEST_CASE("cab: the alerter in the shunt mode, with and without AwareOffInShuntMode") { + for (auto const off : {false, true}) { + CAPTURE(off); + auto security{sm42_security(off)}; + security.set_shunt_mode(true); + run(security, 120.0); + // without the key the shunt mode changes nothing: the alerter alerts and brakes + CHECK(security.is_vigilance_blinking() != off); + CHECK(security.is_braking() != off); + } +} + +TEST_CASE("cab: the alerter's alarm on, not cleared by the shunt mode") { + auto security{sm42_security(true)}; + run(security, 61.0); + REQUIRE(security.is_vigilance_blinking()); + REQUIRE_FALSE(security.is_braking()); + security.set_shunt_mode(true); + run(security, 10.0); + CHECK(security.is_vigilance_blinking()); + CHECK(security.is_beeping()); + CHECK(security.is_braking()); + security.acknowledge_press(); + security.acknowledge_release(); + run(security, 0.1); + CHECK_FALSE(security.is_blinking()); + CHECK_FALSE(security.is_braking()); + // then nothing more on the move in the shunt mode + run(security, 300.0); + CHECK_FALSE(security.is_blinking()); + // and back in the line mode the alerter counts again + security.set_shunt_mode(false); + run(security, 61.0); + CHECK(security.is_vigilance_blinking()); +} + +TEST_CASE("cab: the vigilance button held too long, its alarm not cleared by the shunt mode") { + // the alarm of the button held too long stays on in the shunt mode too, until the button is let go + TSecuritySystem security; + security.load("Security: AwareSystem=Active AwareMinSpeed=0.0 AwareDelay=60 SoundSignalDelay=2.5 MaxHoldTime=1.0 " + "EmergencyBrakeDelay=2.5 AwareOffInShuntMode=Yes", + 90.0); + security.set_enabled(true); + security.update(0.1, 20.0, true, 1); + security.acknowledge_press(); + for (int i = 0; i < 20; ++i) { + security.update(0.1, 20.0, true, 1); + } + REQUIRE(security.is_vigilance_blinking()); + security.set_shunt_mode(true); + for (int i = 0; i < 60; ++i) { + security.update(0.1, 20.0, true, 1); + } + CHECK(security.is_vigilance_blinking()); + CHECK(security.is_braking()); + security.acknowledge_release(); + security.update(0.1, 20.0, true, 1); + CHECK_FALSE(security.is_blinking()); + CHECK_FALSE(security.is_braking()); + // held again in the shunt mode, no new alarm + security.acknowledge_press(); + for (int i = 0; i < 100; ++i) { + security.update(0.1, 20.0, true, 1); + } + CHECK_FALSE(security.is_blinking()); + security.acknowledge_release(); + // out of the shunt mode, held too long again + security.set_shunt_mode(false); + security.acknowledge_press(); + for (int i = 0; i < 20; ++i) { + security.update(0.1, 20.0, true, 1); + } + CHECK(security.is_vigilance_blinking()); +} diff --git a/tests/unit/test_cntrl.cpp b/tests/unit/test_cntrl.cpp index 0dd3ddc20..c73c45d85 100644 --- a/tests/unit/test_cntrl.cpp +++ b/tests/unit/test_cntrl.cpp @@ -37,3 +37,145 @@ TEST_CASE("cntrl: the relays of a multiple unit start on their own, of other veh CHECK(unit->ConverterOverloadRelayStart == start_t::automatic); } } + +namespace { + +// the first position of the master controller after Position without the starting resistors in the circuit +int resistance_free_position(TMoverParameters const &Vehicle, int Position = 0) { + for (auto position{Position + 1}; position <= Vehicle.MainCtrlPosNo; ++position) { + if (Vehicle.RList[position].R < 0.01) { + return position; + } + } + return 0; +} + +// the vehicle with its cab occupied, the master controller set to Position and the shunt controller off +void controllers_at(vehicle &Vehicle, int Position) { + Vehicle->CabActive = 1; + Vehicle->MainCtrlPos = Position; + Vehicle->ScndCtrlPos = 0; +} + +} // namespace + +TEST_CASE("cntrl: ScndCtrlResistiveLock keeps the field shunting off at zero and on the resistive positions (eu07/maszyna#402)") { + for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) { + CAPTURE(path); + vehicle locked{definition::fiz(path).set("Cntrl", "ScndCtrlResistiveLock", "Yes"), 0.0, "test", 1}; + REQUIRE(locked->ScndCtrlResistiveLock); + REQUIRE(locked->ScndCtrlPosNo > 0); + auto const resistancefree{resistance_free_position(locked.mover())}; + REQUIRE(resistancefree > 1); + if (resistancefree <= 1) { + continue; // not reached, the REQUIRE above ends the test; tells the static analysis the index below is in range + } + REQUIRE(locked->RList[resistancefree - 1].R >= 0.01); + + SUBCASE("zero") { + controllers_at(locked, 0); + CHECK(locked->IsScndCtrlLockedByMainCtrl()); + CHECK_FALSE(locked->IncScndCtrl(1)); + CHECK_FALSE(locked->IncScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 0); + } + SUBCASE("resistive positions") { + for (auto position{1}; position < resistancefree; ++position) { + CAPTURE(position); + controllers_at(locked, position); + CHECK_FALSE(locked->IncScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 0); + } + } + SUBCASE("every resistance-free position") { + for (auto position{resistancefree}; position > 0; position = resistance_free_position(locked.mover(), position)) { + CAPTURE(position); + controllers_at(locked, position); + CHECK_FALSE(locked->IsScndCtrlLockedByMainCtrl()); + CHECK(locked->IncScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 1); + } + } + SUBCASE("the shunt goes down on a resistance-free position") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + REQUIRE(locked->IncScndCtrl(1)); + CHECK(locked->DecScndCtrl(1)); + CHECK(locked->ScndCtrlPos == 1); + CHECK(locked->DecScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 0); + } + SUBCASE("the shunt doesn't go down on a resistive position either") { + // a state the lock doesn't let arise (see below), set by hand to check the controller alone + controllers_at(locked, resistancefree - 1); + locked->ScndCtrlPos = 1; + CHECK(locked->IsScndCtrlLockedByMainCtrl()); + CHECK_FALSE(locked->DecScndCtrl(1)); + CHECK_FALSE(locked->DecScndCtrl(2)); + CHECK(locked->ScndCtrlPos == 1); + } + SUBCASE("the master controller taken back from a shunt step drops the shunt") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + if (locked->TrainType == dt_ET22) { + // the ET22's master controller doesn't turn with the shunt on: the shunt goes off first, as before + CHECK_FALSE(locked->DecMainCtrl(1)); + CHECK(locked->MainCtrlPos == resistancefree); + CHECK(locked->DecScndCtrl(1)); + } + CHECK(locked->DecMainCtrl(1)); + CHECK(locked->MainCtrlPos == resistancefree - 1); + CHECK(locked->ScndCtrlPos == 0); + // and the master controller goes on down to zero, nothing left locked + while (locked->MainCtrlPos > 0 && locked->DecMainCtrl(1)) { + } + CHECK(locked->MainCtrlPos == 0); + } + SUBCASE("the master controller set directly (AI, consist) drops the shunt in the next update") { + controllers_at(locked, resistancefree); + REQUIRE(locked->IncScndCtrl(1)); + locked->MainCtrlPos = resistancefree - 1; + locked.step(); + CHECK(locked->ScndCtrlPos == 0); + CHECK(locked->MainCtrlPos == resistancefree - 1); + } + SUBCASE("the master controller moved up from a shunt step onto a resistive position drops the shunt") { + // the last series position, followed by the resistive parallel ones + auto lastseries{0}; + for (auto position{resistancefree}; position > 0 && position < locked->MainCtrlPosNo; position = resistance_free_position(locked.mover(), position)) { + if (locked->RList[position + 1].R >= 0.01) { + lastseries = position; + break; + } + } + REQUIRE(lastseries > 0); + controllers_at(locked, lastseries); + locked->DirActive = 1; + REQUIRE(locked->IncScndCtrl(1)); + if (locked->TrainType == dt_ET22) { + CHECK_FALSE(locked->IncMainCtrl(1)); // the ET22's interlock, as before + CHECK(locked->ScndCtrlPos == 1); + } + else { + CHECK(locked->IncMainCtrl(1)); + CHECK(locked->MainCtrlPos == lastseries + 1); + CHECK(locked->ScndCtrlPos == 0); + } + } + } +} + +TEST_CASE("cntrl: without ScndCtrlResistiveLock the field shunting engages on any position, as before") { + for (auto const *path : {"et22_v3/201e-rn", "ep09_v2/104e"}) { + CAPTURE(path); + vehicle unlocked{definition::fiz(path), 0.0, "test", 1}; + CHECK_FALSE(unlocked->ScndCtrlResistiveLock); + for (auto const position : {0, 1}) { + CAPTURE(position); + controllers_at(unlocked, position); + CHECK_FALSE(unlocked->IsScndCtrlLockedByMainCtrl()); + CHECK(unlocked->IncScndCtrl(1)); + CHECK(unlocked->ScndCtrlPos == 1); + } + } +} diff --git a/tests/unit/test_couplers.cpp b/tests/unit/test_couplers.cpp index 2a0ff6e50..bbb1c0dd9 100644 --- a/tests/unit/test_couplers.cpp +++ b/tests/unit/test_couplers.cpp @@ -525,3 +525,130 @@ TEST_CASE("couplers: a collision of coupled vehicles keeps the momentum of the p CHECK(0.5 * (front_wagon.speed() + rear_wagon.speed()) > 13.5); CHECK(0.5 * (front_wagon.speed() + rear_wagon.speed()) < 15.05 + 1e-6); } + +// eu07/maszyna#520: an electric and a diesel locomotive got their control coupled (multiple-unit control) when the +// scenario or the Starter asked for it, or when the couplers let it through, as a Vectron and an SM42 did + +namespace { + +// the given setting of the control coupling check for the test, restored after it +class control_coupling_check_setting { +public: + explicit control_coupling_check_setting(bool Enabled) { Global.control_coupling_engine_check = Enabled; } + ~control_coupling_check_setting() { Global.control_coupling_engine_check = m_previous; } + control_coupling_check_setting(control_coupling_check_setting const &) = delete; + control_coupling_check_setting &operator=(control_coupling_check_setting const &) = delete; + +private: + bool m_previous{Global.control_coupling_engine_check}; +}; + +constexpr int scenario_coupling{coupling::coupler | coupling::brakehose | coupling::mainhose | coupling::control}; + +// couples the rear of the first vehicle to the front of the second one the way the scenery does (forced, from the +// first one only), returns the coupling the pair got +int scenario_couple(vehicle &First, vehicle &Second, int Coupling = scenario_coupling) { + REQUIRE(First->Attach(end::rear, end::front, &Second.mover(), Coupling, true, false)); + CHECK(Second->Couplers[end::front].CouplingFlag == First->Couplers[end::rear].CouplingFlag); + return First->Couplers[end::rear].CouplingFlag; +} + +} // namespace + +TEST_CASE("couplers: an electric and a diesel locomotive don't share their control") { + control_coupling_check_setting const check{true}; + // the E6ACT names no control system (ControlType), as the Vectron doesn't; the SM42 names its own, the SM03 none + auto electric{vehicle{definition::fiz("e6act_v2/e6acta"), 0.0, "electric"}}; + REQUIRE(electric->EngineType == TEngineType::ElectricInductionMotor); + + SUBCASE("a diesel-electric one with its own control system") { + auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}}; + REQUIRE(diesel->EngineType == TEngineType::DieselElectric); + CHECK_FALSE(electric->ControlCouplingAllowed(end::rear, diesel.mover(), end::front)); + CHECK(scenario_couple(electric, diesel) == (scenario_coupling & ~coupling::control)); + } + SUBCASE("a diesel-mechanical one without a control system named, either") { + auto diesel{vehicle{definition::fiz("sm03_v1/sm03"), 0.0, "diesel"}}; + REQUIRE(diesel->EngineType == TEngineType::DieselEngine); + CHECK_FALSE(diesel->ControlCouplingAllowed(end::front, electric.mover(), end::rear)); + CHECK(scenario_couple(diesel, electric) == (scenario_coupling & ~coupling::control)); + } + SUBCASE("unless both name the same control system") { + auto diesel{vehicle{definition::fiz("sm03_v1/sm03").set("BuffCoupl", "ControlType", "shared"), 0.0, "diesel"}}; + auto shared{vehicle{definition::fiz("e6act_v2/e6acta").set("BuffCoupl", "ControlType", "shared"), 0.0, "electric"}}; + CHECK(scenario_couple(shared, diesel) == scenario_coupling); + } + SUBCASE("unless the vehicles make one unit, coupled for good") { + auto diesel{vehicle{definition::fiz("sm03_v1/sm03"), 0.0, "diesel"}}; + auto const forgood{scenario_coupling | coupling::permanent}; + CHECK(scenario_couple(electric, diesel, forgood) == forgood); + } + SUBCASE("unless the check is turned off") { + control_coupling_check_setting const off{false}; + auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}}; + CHECK(electric->ControlCouplingAllowed(end::rear, diesel.mover(), end::front)); + CHECK(scenario_couple(electric, diesel) == scenario_coupling); + } +} + +TEST_CASE("couplers: locomotives of the same traction and the cars keep their control coupling") { + control_coupling_check_setting const check{true}; + + SUBCASE("two locomotives or motor cars of the same traction") { + // two electric ones, an electric one of each motor type, two diesel ones, a diesel-mechanical and a + // diesel-electric one, an electric multiple unit's control trailer and its motor car + std::initializer_list> const pairs{ + {"ep09_v2/104e", "et22_v3/201e-w"}, + {"e6act_v2/e6acta", "eu04_v1/eu04-01"}, + {"sm03_v1/sm03", "wmb10_v1/wmb10"}, + {"sm03_v1/sm03", "st44_v2/m62-1151"}, + {"en57_v1/5bgb", "en57_v1/6bai"}}; + for (auto const &paths : pairs) { + CAPTURE(paths.first); + CAPTURE(paths.second); + auto first{vehicle{definition::fiz(paths.first), 0.0, "first"}}; + auto second{vehicle{definition::fiz(paths.second), 0.0, "second"}}; + CHECK(scenario_couple(first, second) == scenario_coupling); + } + } + SUBCASE("a diesel locomotive and a car") { + auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}}; + auto car{vehicle{definition::load("wagon"), 0.0, "car"}}; + CHECK(scenario_couple(diesel, car) == scenario_coupling); + } +} + +TEST_CASE("couplers: automatic couplers of an electric and a diesel locomotive couple without the control connection") { + crash_damage_setting const crashdamage{true}; + control_coupling_check_setting const check{true}; + auto const flag{coupling::coupler | coupling::brakehose | coupling::control}; + auto automatic = [flag](std::string const &Path) { + return definition::fiz(Path).set("BuffCoupl", "CType", "Automatic").set("BuffCoupl", "AutomaticFlag", flag); + }; + auto moving{vehicle{automatic("e6act_v2/e6acta"), 5.0, "moving"}}; + + SUBCASE("a diesel one") { + auto standing{vehicle{automatic("sm03_v1/sm03"), 0.0, "standing"}}; + test::pair pair{moving, end::front, standing, end::rear, 1.0}; + REQUIRE(couple_during(pair, 3.0)); + CHECK(pair.coupling() == (coupling::coupler | coupling::brakehose)); + } + SUBCASE("an electric one") { + auto standing{vehicle{automatic("ep09_v2/104e"), 0.0, "standing"}}; + test::pair pair{moving, end::front, standing, end::rear, 1.0}; + REQUIRE(couple_during(pair, 3.0)); + CHECK(pair.coupling() == flag); + } +} + +TEST_CASE("couplers: the AI and the player get the coupling the vehicles can take") { + control_coupling_check_setting const check{true}; + auto electric{vehicle{definition::fiz("e6act_v2/e6acta"), 0.0, "electric"}}; + auto diesel{vehicle{definition::fiz("sm42_v1/6d1"), 0.0, "diesel"}}; + auto other{vehicle{definition::fiz("ep09_v2/104e"), 0.0, "other"}}; + + CHECK(electric->CompatibleCoupling(end::rear, diesel.mover(), end::front, scenario_coupling) == (scenario_coupling & ~coupling::control)); + CHECK(electric->CompatibleCoupling(end::rear, other.mover(), end::front, scenario_coupling) == scenario_coupling); + // nothing to take away without the control connection asked for + CHECK(electric->CompatibleCoupling(end::rear, diesel.mover(), end::front, coupling::coupler) == coupling::coupler); +} diff --git a/tests/unit/test_diesel.cpp b/tests/unit/test_diesel.cpp index 07686dc10..c4ea147d3 100644 --- a/tests/unit/test_diesel.cpp +++ b/tests/unit/test_diesel.cpp @@ -177,3 +177,32 @@ TEST_CASE("diesel: the 214M railbus's speed control, up to the speed of a button CHECK_FALSE(railbus.SpeedCtrlUnit.IsActive); scenario.check(); } + +TEST_CASE("diesel: the SM42's shunt mode, switched on and off with one move of the switch") { + // eu07/maszyna#497: the shunt mode of the diesel-electrics (ShuntMode=1) shares its switch with the motor + // overload relay threshold of the electric locomotives (CurrentSwitch()). the SM42 has no such relay, so + // the switch sets the shunt mode at the first move, at the controller's zero position only + scenario scenario{"diesel/sm42 shunt mode", motion() + traction(), test::track{}}; + scenario.add("sm42_v1/6d1", 1); + REQUIRE(scenario.start_up()); + auto &sm42{scenario.cab()}; + REQUIRE(sm42.ShuntModeAllow); + CHECK_FALSE(sm42.ShuntMode); + scenario.act("shunt mode on"); + CHECK(sm42.CurrentSwitch(true)); + CHECK(sm42.ShuntMode); + scenario.get_going(); + scenario.act("shunting power"); + sm42.AnPos = 0.5; + CHECK(sm42.IncMainCtrl(1)); + scenario.wait(60.0); + CHECK(sm42.Vel > 1.0); + // not with the controller out of its zero position + CHECK_FALSE(sm42.CurrentSwitch(false)); + CHECK(sm42.ShuntMode); + scenario.notch_back(0); + scenario.act("shunt mode off"); + CHECK(sm42.CurrentSwitch(false)); + CHECK_FALSE(sm42.ShuntMode); + scenario.check(); +} diff --git a/tests/unit/test_dimmer.cpp b/tests/unit/test_dimmer.cpp new file mode 100644 index 000000000..d4d2e2663 --- /dev/null +++ b/tests/unit/test_dimmer.cpp @@ -0,0 +1,112 @@ +#include "stdafx.h" +#include "doctest.h" +#include "vehicle.h" + +using test::definition; +using test::vehicle; + +// the headlight dimmer's position indexes the DimmerList of the .fiz. a short or an empty list, or a DefaultPos +// past its end, put the dimmer outside the list, where the lights and the cab read past the end of it + +namespace { + +// rows: high beam, dimmed, off +nlohmann::ordered_json const plain{"no", "no", "no"}; +nlohmann::ordered_json const dimmed{"no", "yes", "no"}; +nlohmann::ordered_json const off{"no", "no", "yes"}; + +definition dimmer_list(nlohmann::ordered_json const &Rows, int const Defaultposition, bool const Cycle = false) { + return definition::load("cab_vehicle") + .set("DimmerList", "rows", Rows) + .set("DimmerList", "Size", static_cast(Rows.size())) + .set("DimmerList", "DefaultPos", Defaultposition) + .set("DimmerList", "Cycle", Cycle ? "yes" : "no"); +} + +} // namespace + +TEST_CASE("dimmer: a position outside the list reads as a plain one, neither off nor dimmed") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({off, dimmed}), 0)}; + REQUIRE(cab->dimPositions.size() == 2); + + for (auto const position : {-1, 2, 100}) { + CAPTURE(position); + cab->modernDimmerPosition = position; + auto const entry{cab->currentDimPosition()}; + CHECK_FALSE(entry.isOff); + CHECK_FALSE(entry.isDimmed); + CHECK_FALSE(entry.isHighBeam); + } + cab->modernDimmerPosition = 0; + CHECK(cab->currentDimPosition().isOff); + cab->modernDimmerPosition = 1; + CHECK(cab->currentDimPosition().isDimmed); +} + +TEST_CASE("dimmer: positions are clamped to the list") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)}; + + CHECK(cab->clampDimmerPosition(-3) == 0); + CHECK(cab->clampDimmerPosition(1) == 1); + CHECK(cab->clampDimmerPosition(3) == 2); + CHECK(cab->clampDimmerPosition(100) == 2); +} + +TEST_CASE("dimmer: a DefaultPos past the end of the list starts the dimmer at its last position") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed}), 7)}; + + CHECK(cab->modernDimmerDefaultPosition == 1); + // the cab puts the modern dimmer to its default position when it's entered (TTrain::set_cab_controls()) + cab->modernDimmerPosition = cab->modernDimmerDefaultPosition; + CHECK(cab->currentDimPosition().isDimmed); +} + +TEST_CASE("dimmer: without the modern dimmer a DefaultPos past the end of the list puts the dimmer at its last position") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed}), 7).set("Switches", "ModernDimmer", "No")}; + REQUIRE_FALSE(cab->enableModernDimmer); + + CHECK(cab->modernDimmerPosition == 1); + CHECK(cab->currentDimPosition().isDimmed); +} + +TEST_CASE("dimmer: an empty list leaves the dimmer at 0, reading as a plain position, and it doesn't move") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array(), 3, true)}; + REQUIRE(cab->dimPositions.empty()); + + CHECK(cab->modernDimmerDefaultPosition == 0); + CHECK(cab->modernDimmerPosition == 0); + CHECK(cab->clampDimmerPosition(1) == 0); + CHECK_FALSE(cab->currentDimPosition().isOff); + CHECK_FALSE(cab->stepDimmerPosition(1)); + CHECK_FALSE(cab->stepDimmerPosition(-1)); + CHECK(cab->modernDimmerPosition == 0); +} + +TEST_CASE("dimmer: stepping stays within the list") { + SUBCASE("without cycling it stops at the ends") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)}; + CHECK_FALSE(cab->stepDimmerPosition(-1)); + CHECK(cab->modernDimmerPosition == 0); + CHECK(cab->stepDimmerPosition(1)); + CHECK(cab->stepDimmerPosition(1)); + CHECK(cab->modernDimmerPosition == 2); + CHECK_FALSE(cab->stepDimmerPosition(1)); + CHECK(cab->modernDimmerPosition == 2); + } + SUBCASE("with cycling it goes around to the other end") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0, true)}; + CHECK(cab->stepDimmerPosition(-1)); + CHECK(cab->modernDimmerPosition == 2); + CHECK(cab->stepDimmerPosition(1)); + CHECK(cab->modernDimmerPosition == 0); + } + SUBCASE("a position past the end steps from the last one") { + vehicle cab{dimmer_list(nlohmann::ordered_json::array({plain, dimmed, off}), 0)}; + cab->modernDimmerPosition = 9; + CHECK(cab->stepDimmerPosition(-1)); + CHECK(cab->modernDimmerPosition == 1); + cab->modernDimmerPosition = 9; + CHECK(cab->stepDimmerPosition(1)); // can't go further, but comes back into the list + CHECK(cab->modernDimmerPosition == 2); + } +} diff --git a/tests/unit/test_door_wings.cpp b/tests/unit/test_door_wings.cpp new file mode 100644 index 000000000..290260f6a --- /dev/null +++ b/tests/unit/test_door_wings.cpp @@ -0,0 +1,54 @@ +#include "stdafx.h" +#include "doctest.h" + +#include "vehicle/doorwings.h" + +// the poses of the animated door wings (eu07/maszyna#512): a wing of the main model and its namesake in the low +// poly interior get the same pose, worked out once from the door position of the mover + +TEST_CASE("door wings: only the door animations move wings") { + CHECK(door_wings::is_wing(0x010)); // TAnim::TypeSet for the doors + CHECK_FALSE(door_wings::is_wing(0x000)); // axles + CHECK_FALSE(door_wings::is_wing(0x055)); // pantographs, five submodels + CHECK_FALSE(door_wings::is_wing(0x070)); // doorsteps + CHECK_FALSE(door_wings::is_wing(0x080)); // mirrors + CHECK(door_wings::is_wing(0x210)); // the parameter count in the upper bits doesn't matter +} + +TEST_CASE("door wings: odd wings are on the left, even ones on the right") { + CHECK_FALSE(door_wings::on_right_side(1)); + CHECK(door_wings::on_right_side(2)); + CHECK_FALSE(door_wings::on_right_side(3)); + CHECK(door_wings::on_right_side(4)); +} + +TEST_CASE("door wings: a sliding wing shifts along the vehicle by the door position") { + CHECK(door_wings::slide(0.f) == glm::vec3(0.f, 0.f, 0.f)); + CHECK(door_wings::slide(0.65f) == glm::vec3(0.f, 0.f, 0.65f)); +} + +TEST_CASE("door wings: a plug wing goes out first, then slides") { + auto const rangeout{0.1f}; + // closed + CHECK(door_wings::plug(0.f, rangeout) == glm::vec3(0.f, 0.f, 0.f)); + // still going out, and not sliding yet + auto const out{door_wings::plug(0.02f, rangeout)}; + CHECK(out.x == doctest::Approx(0.04f)); + CHECK(out.z == 0.f); + // out as far as it goes, sliding by what the position has beyond half of the way out + auto const open{door_wings::plug(0.7f, rangeout)}; + CHECK(open.x == rangeout); + CHECK(open.y == 0.f); + CHECK(open.z == doctest::Approx(0.65f)); +} + +TEST_CASE("door wings: a folding wing turns one way and its larger wing twice as far the other way") { + auto const angles{door_wings::fold(40.f)}; + CHECK(angles.smaller == 40.f); + CHECK(angles.larger == -80.f); + CHECK(angles.step == 40.f); + auto const closed{door_wings::fold(0.f)}; + CHECK(closed.smaller == 0.f); + CHECK(closed.larger == 0.f); + CHECK(closed.step == 0.f); +} diff --git a/tests/unit/test_engine_start.cpp b/tests/unit/test_engine_start.cpp new file mode 100644 index 000000000..c721e5a1a --- /dev/null +++ b/tests/unit/test_engine_start.cpp @@ -0,0 +1,298 @@ +#include "stdafx.h" +#include "doctest.h" +#include "consist.h" + +#include "vehicle/enginestart.h" + +// starting the engines of the vehicles in multiple from the cab (eu07/maszyna#80): the cab's own switch (main_*) works +// all of them unless Engine:JointEngineStart=No keeps it to its own vehicle, and the switches mainb_* and mainc_* start +// the second and the third vehicle alone. the cab (TTrain) passes the vehicle's MainSwitchRange() to its MainSwitch(), +// finds the vehicles with engine(), and runs remote_switch for the switches of the others + +using test::consist; +using test::definition; + +namespace { + +// the SN61 railcar, whose cab has a set of switches for each of up to three railcars in multiple +definition sn61(bool const Joint = true) { + auto railcar{definition::fiz("sn61_v2/sn61")}; + if (false == Joint) { + railcar.set("Engine", "JointEngineStart", "No"); + } + return railcar; +} + +// the battery, the cab and the pumps of every railcar of the train switched on from the first one's cab, the oil +// pressure built up, and the controller at the first position giving the engines fuel, which a mechanical diesel +// starts at: everything but the engines ready to start +void prepare(consist &Train) { + auto &cab{Train[0].mover()}; + cab.BatterySwitch(true); + cab.CabActivisation(); + cab.OilPumpSwitch(true); + cab.FuelPumpSwitch(true); + while (cab.RList[cab.MainCtrlPos].R == 0.0 && cab.IncMainCtrl(1)) { + // up to the first position with fuel + } + Train.run(20.0); +} + +bool running(TMoverParameters const &Vehicle) { + return Vehicle.Mains && Vehicle.enrot > 0.5 * Vehicle.dizel_nmin; +} + +// the time step of the train in the loops below +auto const dt{0.01}; + +// the count of the steps of dt making up Seconds +int steps(double const Seconds) { + return static_cast(std::lround(Seconds / dt)); +} + +// the switch of Engine held closed for Seconds, then let go, in steps of the train +void hold(consist &Train, engine_start::remote_switch &Switch, TMoverParameters *Engine, double const Seconds, bool const Closesonrelease = false) { + for (auto step = 0; step < steps(Seconds); ++step) { + Switch.update(Engine, true, false, dt, Closesonrelease); + Train.step({}, dt); + } + Switch.update(Engine, false, false, dt, Closesonrelease); +} + +} // namespace + +TEST_CASE("engine start: the joint start is the default, and JointEngineStart=No keeps the cab's switch to its vehicle") { + consist train; + auto const &joint{train.add(sn61(), 1).mover()}; + auto const &separate{train.add(sn61(false)).mover()}; + CHECK(joint.JointEngineStart); + CHECK_FALSE(separate.JointEngineStart); + CHECK(joint.MainSwitchRange() == range_t::consist); + CHECK(separate.MainSwitchRange() == range_t::local); +} + +TEST_CASE("engine start: the vehicles in multiple, counted from the cab's own one, those behind the cab first") { + consist train; + auto &first{train.add(sn61(), 1).mover()}; + auto &second{train.add(sn61()).mover()}; + auto &third{train.add(sn61()).mover()}; + CHECK(engine_start::engine(first, first, 1) == &first); + CHECK(engine_start::engine(first, first, 2) == &second); + CHECK(engine_start::engine(first, first, 3) == &third); + CHECK(engine_start::engine(first, first, 4) == nullptr); + CHECK(engine_start::engine(first, first, 0) == nullptr); + // from the rear cab of the first railcar the others are in front of the cab, in the same order + first.CabOccupied = -1; + CHECK(engine_start::engine(first, first, 2) == &second); + CHECK(engine_start::engine(first, first, 3) == &third); + // from the middle one, the one behind its cab comes first + second.CabOccupied = 1; + CHECK(engine_start::engine(second, second, 2) == &third); + CHECK(engine_start::engine(second, second, 3) == &first); + second.CabOccupied = -1; + CHECK(engine_start::engine(second, second, 2) == &first); + CHECK(engine_start::engine(second, second, 3) == &third); +} + +TEST_CASE("engine start: only the vehicles with an engine and under control through the cable count") { + consist train; + auto &first{train.add(sn61(), 1).mover()}; + // a vehicle without an engine between the railcars is passed over + auto &trailer{train.add(definition::fiz("ed72_v1/5bs-ra")).mover()}; + auto &second{train.add(sn61()).mover()}; + REQUIRE(trailer.Power < 0.01); + CHECK(engine_start::engine(first, first, 2) == &second); + // the vehicle with the cab doesn't drive itself: its engine is in the vehicle it controls, which isn't counted twice + trailer.CabOccupied = 1; + CHECK(engine_start::engine(trailer, first, 1) == &first); + CHECK(engine_start::engine(trailer, first, 2) == &second); + CHECK(engine_start::engine(trailer, first, 3) == nullptr); + + // coupled without the control cable, the other railcar isn't under the cab's control + consist apart; + auto &alone{apart.add(sn61(), 1).mover()}; + apart.add(sn61(), 0, coupling::coupler | coupling::brakehose); + CHECK(engine_start::engine(alone, alone, 2) == nullptr); +} + +TEST_CASE("engine start: by default the cab's switch starts and stops the engines of all the vehicles in multiple") { + consist train; + auto &first{train.add(sn61(), 1).mover()}; + auto const &second{train.add(sn61()).mover()}; + prepare(train); + REQUIRE_FALSE(first.Mains); + REQUIRE_FALSE(second.Mains); + first.MainSwitch(true, first.MainSwitchRange()); + train.run(15.0); + CHECK(running(first)); + CHECK(running(second)); + first.MainSwitch(false, first.MainSwitchRange()); + train.run(5.0); + CHECK_FALSE(first.Mains); + CHECK_FALSE(second.Mains); +} + +TEST_CASE("engine start: with JointEngineStart=No each engine has its own switch") { + consist train; + auto &first{train.add(sn61(false), 1).mover()}; + auto &second{train.add(sn61(false)).mover()}; + auto &third{train.add(sn61(false)).mover()}; + prepare(train); + // the cab's own switch starts its own engine only + first.MainSwitch(true, first.MainSwitchRange()); + train.run(15.0); + REQUIRE(running(first)); + CHECK_FALSE(second.Mains); + CHECK_FALSE(third.Mains); + + // the second one's switch, mainb_*, starts the second engine + engine_start::remote_switch switchb; + engine_start::remote_switch switchc; + auto *engineb{engine_start::engine(first, first, 2)}; + auto *enginec{engine_start::engine(first, first, 3)}; + REQUIRE(engineb == &second); + REQUIRE(enginec == &third); + hold(train, switchb, engineb, 2.0); // past the SN61's delay of 1.5 s + train.run(15.0); + CHECK(running(second)); + CHECK_FALSE(third.Mains); + // and the third one's, mainc_*, the third + hold(train, switchc, enginec, 2.0); + train.run(15.0); + CHECK(running(third)); + + // the switches open their own vehicles' circuits only + CHECK(engine_start::remote_switch::open(second)); + train.run(5.0); + CHECK_FALSE(second.Mains); + CHECK(running(first)); + CHECK(running(third)); + first.MainSwitch(false, first.MainSwitchRange()); + train.run(5.0); + CHECK_FALSE(first.Mains); + CHECK(running(third)); + CHECK_FALSE(engine_start::remote_switch::open(second)); // already stopped +} + +TEST_CASE("engine start: the switch of another vehicle is held for the vehicle's delay, with the vehicle ready") { + consist train; + train.add(sn61(false).set("Cntrl", "IniCDelay", "2.0"), 1); + auto &second{train.add(sn61(false).set("Cntrl", "IniCDelay", "2.0")).mover()}; + REQUIRE(second.InitialCtrlDelay == doctest::Approx(2.0)); + engine_start::remote_switch switchb; + + // without the battery the switch does nothing, however long it's held + hold(train, switchb, &second, 5.0); + train.run(5.0); + CHECK_FALSE(second.Mains); + CHECK_FALSE(second.dizel_startup); + + prepare(train); + // let go too early + hold(train, switchb, &second, 1.0); + CHECK_FALSE(engine_start::remote_switch::is_running(second)); + // the switch opening the circuit held along, the closing one does nothing + for (auto step = 0; step < steps(3.0); ++step) { + switchb.update(&second, true, true, dt, false); + train.step({}, dt); + } + CHECK_FALSE(engine_start::remote_switch::is_running(second)); + // held long enough + hold(train, switchb, &second, 2.5); + CHECK(engine_start::remote_switch::is_running(second)); + train.run(15.0); + CHECK(running(second)); +} + +TEST_CASE("engine start: a switch closing on release, as an electric locomotive's impulse switch, waits to be let go") { + consist train; + train.add(sn61(false), 1); + auto &second{train.add(sn61(false).set("Cntrl", "IniCDelay", "1.0")).mover()}; + prepare(train); + engine_start::remote_switch switchb; + // held past the delay, the circuit stays open while the switch is held + for (auto step = 0; step < steps(2.0); ++step) { + switchb.update(&second, true, false, dt, true); + train.step({}, dt); + } + CHECK_FALSE(engine_start::remote_switch::is_running(second)); + // and closes when let go + switchb.update(&second, false, false, dt, true); + CHECK(engine_start::remote_switch::is_running(second)); + train.run(15.0); + REQUIRE(running(second)); + // let go before the delay, it doesn't + CHECK(engine_start::remote_switch::open(second)); + train.run(5.0); + REQUIRE_FALSE(engine_start::remote_switch::is_running(second)); + hold(train, switchb, &second, 0.5, true); + CHECK_FALSE(engine_start::remote_switch::is_running(second)); +} + +TEST_CASE("engine start: an engine stopping on its own stops the others only when they started together") { + for (auto const joint : {true, false}) { + CAPTURE(joint); + consist train; + auto &first{train.add(sn61(joint), 1).mover()}; + auto const &second{train.add(sn61(joint)).mover()}; + prepare(train); + engine_start::remote_switch switchb; + first.MainSwitch(true, first.MainSwitchRange()); + hold(train, switchb, engine_start::engine(first, first, 2), 2.0); + train.run(15.0); + REQUIRE(running(first)); + REQUIRE(running(second)); + // the first one's fuel cut off, its engine stops + first.FuelPump.is_disabled = true; + train.run(15.0); + CHECK_FALSE(first.Mains); + CHECK(first.enrot == 0.0); + // started on their own, the others keep running + CHECK(running(second) == (false == joint)); + } +} + +// a stopped engine stays stopped on its own: only an engine stopping while it ran tells the others, as a joint start's +// engines stop together; one stopped from another vehicle's switch, or not started at all, doesn't stop those running, +// whatever the flags of the vehicles in a mixed train +TEST_CASE("engine start: an engine stopped from its own switch doesn't stop the others when it has spun down") { + consist train; + // the middle railcar keeps the joint start, as a .fiz without the key does. what a vehicle without the cab relays + // goes on away from the cab, so it's the third one that would stop + auto &first{train.add(sn61(false), 1).mover()}; + auto &second{train.add(sn61()).mover()}; + auto &third{train.add(sn61(false)).mover()}; + prepare(train); + engine_start::remote_switch switchb; + engine_start::remote_switch switchc; + first.MainSwitch(true, first.MainSwitchRange()); + hold(train, switchb, engine_start::engine(first, first, 2), 2.0); + hold(train, switchc, engine_start::engine(first, first, 3), 2.0); + train.run(15.0); + REQUIRE(running(first)); + REQUIRE(running(second)); + REQUIRE(running(third)); + // mainb_off + CHECK(engine_start::remote_switch::open(second)); + train.run(30.0); + CHECK_FALSE(second.Mains); + CHECK(second.enrot == 0.0); + CHECK(running(first)); + CHECK(running(third)); +} + +TEST_CASE("engine start: the stopped engine of the cab's vehicle doesn't stop the one started from its switch") { + consist train; + // the cab's railcar keeps the joint start, its engine stopped + auto &first{train.add(sn61(), 1).mover()}; + auto &second{train.add(sn61(false)).mover()}; + prepare(train); + REQUIRE_FALSE(first.Mains); + // mainb_on + engine_start::remote_switch switchb; + hold(train, switchb, engine_start::engine(first, first, 2), 2.0); + train.run(15.0); + CHECK(running(second)); + CHECK_FALSE(first.Mains); + CHECK(first.enrot == 0.0); +} diff --git a/tests/unit/test_framepacer.cpp b/tests/unit/test_framepacer.cpp new file mode 100644 index 000000000..bb9acb025 --- /dev/null +++ b/tests/unit/test_framepacer.cpp @@ -0,0 +1,110 @@ +#include "stdafx.h" +#include "doctest.h" +#include "utilities/framepacer.h" + +// the main loop's frame limiter (fpslimit in eu07.ini, eu07/maszyna#416), driven with made-up clock readings +namespace +{ +using namespace std::chrono_literals; +using clock_type = frame_pacer::clock; + +clock_type::time_point const kStart{clock_type::time_point{} + 100s}; +constexpr clock_type::duration kFrame{std::chrono::duration_cast(std::chrono::duration(1.f / 30.f))}; + +// runs frames that take Work each, with every wait overshooting by Oversleep; returns when the last of Frames ends +clock_type::time_point run_frames(frame_pacer &Pacer, int const Frames, clock_type::duration const Work, clock_type::duration const Oversleep) +{ + auto now{kStart}; + for (auto frame = 0; frame < Frames; ++frame) + { + now += Work; + if (auto const next{Pacer.next_frame(now, kFrame)}) + { + CHECK(*next > now); + now = *next + Oversleep; + } + } + return now; +} +} // namespace + +TEST_CASE("frame pacer: without a limit nothing waits") +{ + frame_pacer pacer; + CHECK_FALSE(pacer.next_frame(kStart, clock_type::duration::zero()).has_value()); + CHECK_FALSE(pacer.next_frame(kStart + 1ms, clock_type::duration::zero()).has_value()); +} + +TEST_CASE("frame pacer: a quick frame waits out the rest of the frame time") +{ + frame_pacer pacer; + // the first frame only sets the cadence + CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value()); + auto const next{pacer.next_frame(kStart + 5ms, kFrame)}; + REQUIRE(next.has_value()); + CHECK(*next == kStart + kFrame); +} + +TEST_CASE("frame pacer: a slow frame doesn't wait") +{ + frame_pacer pacer; + CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value()); + CHECK_FALSE(pacer.next_frame(kStart + kFrame + 5ms, kFrame).has_value()); +} + +TEST_CASE("frame pacer: the frame rate holds the limit with fast frames") +{ + frame_pacer pacer; + auto const end{run_frames(pacer, 301, 2ms, clock_type::duration::zero())}; + // 300 paced frames after the first + CHECK(end == kStart + 2ms + 300 * kFrame); +} + +TEST_CASE("frame pacer: a wait that overshoots is made up in the next frame") +{ + // the windows timer wakes a sleeping thread up to ~15.6 ms late; sleeping off what is left of each frame + // then drops 30 fps to about 22. on a fixed cadence the frame rate still averages to the limit + frame_pacer pacer; + auto const end{run_frames(pacer, 301, 2ms, 12ms)}; + auto const elapsed{std::chrono::duration(end - kStart).count()}; + CHECK(300.0 / elapsed == doctest::Approx(30.0).epsilon(0.01)); +} + +TEST_CASE("frame pacer: after a long frame the cadence starts anew instead of catching up") +{ + frame_pacer pacer; + CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value()); + // a hitch of half a second + auto const late{kStart + 500ms}; + CHECK_FALSE(pacer.next_frame(late, kFrame).has_value()); + // the next quick frame waits a whole frame time from there rather than running at once + auto const next{pacer.next_frame(late + 1ms, kFrame)}; + REQUIRE(next.has_value()); + CHECK(*next == late + kFrame); +} + +TEST_CASE("frame pacer: turning the limit off and on again starts a new cadence") +{ + frame_pacer pacer; + CHECK_FALSE(pacer.next_frame(kStart, kFrame).has_value()); + CHECK_FALSE(pacer.next_frame(kStart + 1ms, clock_type::duration::zero()).has_value()); + CHECK_FALSE(pacer.next_frame(kStart + 2s, kFrame).has_value()); + auto const next{pacer.next_frame(kStart + 2s + 1ms, kFrame)}; + REQUIRE(next.has_value()); + CHECK(*next == kStart + 2s + kFrame); +} + +TEST_CASE("frame pacer: the wait stays exact after days of system uptime") +{ + // fpslimit 60 gives the frame time as float seconds; the old limiter handed the float rest of the frame + // to sleep_for, which adds it to steady_clock::now() in float nanoseconds. after 95 hours of uptime that + // rounds the wake-up time to steps of ~33 ms, and a 14 ms wait came out as no wait at all + frame_pacer pacer; + std::chrono::duration const frametime{1.f / 60.f}; + auto const uptime{clock_type::time_point{} + 95h}; + CHECK_FALSE(pacer.next_frame(uptime, frametime).has_value()); + auto const next{pacer.next_frame(uptime + 2ms, frametime)}; + REQUIRE(next.has_value()); + auto const wait{std::chrono::duration(*next - (uptime + 2ms)).count()}; + CHECK(wait == doctest::Approx(1000.0 / 60.0 - 2.0).epsilon(0.001)); +} diff --git a/tests/unit/test_gauge_duplicates.cpp b/tests/unit/test_gauge_duplicates.cpp new file mode 100644 index 000000000..7bdbe9095 --- /dev/null +++ b/tests/unit/test_gauge_duplicates.cpp @@ -0,0 +1,53 @@ +#include "stdafx.h" +#include "doctest.h" + +#include "vehicle/gaugeduplicates.h" + +// cab controls with more than one submodel (eu07/maszyna#527): a definition of a control in the .mmd marked +// "duplicate: yes" adds a copy of the control already defined in the cab, instead of replacing it. TGauge itself +// (3d models, sounds) is not part of the core library, the rule which decides it is + +namespace { + +// stand-ins for the 3d models of the cab +struct model {}; + +} // namespace + +TEST_CASE("gauge duplicates: the values of the duplicate key which mark a duplicate") { + CHECK(gauge_duplicates::is_duplicate("yes")); + CHECK(gauge_duplicates::is_duplicate("true")); + CHECK(gauge_duplicates::is_duplicate("1")); + CHECK_FALSE(gauge_duplicates::is_duplicate("no")); + CHECK_FALSE(gauge_duplicates::is_duplicate("false")); + CHECK_FALSE(gauge_duplicates::is_duplicate("0")); + CHECK_FALSE(gauge_duplicates::is_duplicate("")); +} + +TEST_CASE("gauge duplicates: a duplicate adds a copy to the control loaded from either model of the cab") { + model cab; + model lowpoly; + CHECK(gauge_duplicates::adds_copy(true, &cab, &cab, &lowpoly)); + CHECK(gauge_duplicates::adds_copy(true, &lowpoly, &cab, &lowpoly)); + // a cab without a low poly interior + CHECK(gauge_duplicates::adds_copy(true, &cab, &cab, nullptr)); +} + +TEST_CASE("gauge duplicates: a definition not marked as a duplicate replaces the control, as before") { + model cab; + model lowpoly; + CHECK_FALSE(gauge_duplicates::adds_copy(false, &cab, &cab, &lowpoly)); + CHECK_FALSE(gauge_duplicates::adds_copy(false, nullptr, &cab, &lowpoly)); +} + +TEST_CASE("gauge duplicates: with nothing loaded in this cab a duplicate is the control itself") { + model cab; + model lowpoly; + model previouscab; + // the control isn't defined before it + CHECK_FALSE(gauge_duplicates::adds_copy(true, nullptr, &cab, &lowpoly)); + CHECK_FALSE(gauge_duplicates::adds_copy(true, nullptr, &cab, nullptr)); + // the control is left over from the cab loaded before + CHECK_FALSE(gauge_duplicates::adds_copy(true, &previouscab, &cab, &lowpoly)); + CHECK_FALSE(gauge_duplicates::adds_copy(true, &previouscab, &cab, nullptr)); +} diff --git a/tests/unit/test_hold_coil_lever.cpp b/tests/unit/test_hold_coil_lever.cpp new file mode 100644 index 000000000..cd3a3fee5 --- /dev/null +++ b/tests/unit/test_hold_coil_lever.cpp @@ -0,0 +1,30 @@ +#include "stdafx.h" +#include "doctest.h" + +#include "vehicle/holdcoillever.h" + +// the lever of the line breaker's hold coil on the ET22 and the EP09 stays where it's put (eu07/maszyna#364), when the +// cab declares its main_off_bt control with "type: toggle"; otherwise main_off_bt is the push button it always was + +TEST_CASE("hold coil lever: only a main_off_bt declared as a toggle switch is the bistable lever (eu07/maszyna#364)") { + CHECK(hold_coil_lever::is_bistable(true, true)); + // declared as a push button + CHECK_FALSE(hold_coil_lever::is_bistable(true, false)); + // no type given: a control defaults to the toggle type, which existing cabs relied on for the push button + CHECK_FALSE(hold_coil_lever::is_bistable(false, true)); +} + +TEST_CASE("hold coil lever: operated, it goes over to the other position and stays there") { + // on: the hold coil fed, the line breaker can close + CHECK_FALSE(hold_coil_lever::cuts_off(0.f)); + auto const off{hold_coil_lever::operated(0.f)}; + CHECK(off == doctest::Approx(1.f)); + CHECK(hold_coil_lever::cuts_off(off)); + // operated again it goes back on + auto const on{hold_coil_lever::operated(off)}; + CHECK(on == doctest::Approx(0.f)); + CHECK_FALSE(hold_coil_lever::cuts_off(on)); + // caught on the way between the positions it goes to the far one + CHECK(hold_coil_lever::operated(0.3f) == doctest::Approx(1.f)); + CHECK(hold_coil_lever::operated(0.7f) == doctest::Approx(0.f)); +} diff --git a/tests/unit/test_lights_preset_cablight.cpp b/tests/unit/test_lights_preset_cablight.cpp new file mode 100644 index 000000000..7c64c7d5a --- /dev/null +++ b/tests/unit/test_lights_preset_cablight.cpp @@ -0,0 +1,96 @@ +#include "stdafx.h" +#include "doctest.h" +#include "vehicle.h" + +// the cab interior light set by the positions of the light preset selector: an optional third column of LightsList, +// 1 the cab light on, 2 dimmed, 0 off; a row without it leaves the cab light to its own switch (eu07/maszyna#529) + +using test::definition; +using test::vehicle; + +namespace { + +auto const shunting{light::headlight_left | light::headlight_right}; + +} // namespace + +TEST_CASE("lights preset cab light: a table without the column sets no position's cab light") { + vehicle wagon{definition::load("wagon") + .set("LightsList", "Size", 2) + .set("LightsList", "Default", 1) + .set("LightsList", "rows", {{0, 0}, {shunting, shunting}})}; + + REQUIRE(wagon->LightsPosNo == 2); + CHECK(wagon->Lights[end::front][1] == shunting); + CHECK_FALSE(wagon->LightsPresetCabLight(1).has_value()); + CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value()); +} + +TEST_CASE("lights preset cab light: the third column turns the cab light off, on, or on dimmed") { + // off - shunting - shunting with the cab lit - shunting with the cab lit dimmed - shunting leaving the cab light + vehicle wagon{definition::load("wagon") + .set("LightsList", "Size", 5) + .set("LightsList", "Default", 1) + .set("LightsList", "rows", {{0, 0, 0}, {shunting, shunting}, {shunting, shunting, 1}, {shunting, shunting, 3}, {shunting, 0, -1}})}; + + REQUIRE(wagon->LightsPosNo == 5); + // the light columns read as before + CHECK(wagon->Lights[end::front][2] == shunting); + CHECK(wagon->Lights[end::rear][2] == shunting); + CHECK(wagon->Lights[end::rear][4] == 0); + + auto const off{wagon->LightsPresetCabLight(1)}; + REQUIRE(off.has_value()); + CHECK_FALSE(off->light); + CHECK_FALSE(off->dim); + + CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value()); + + auto const lit{wagon->LightsPresetCabLight(3)}; + REQUIRE(lit.has_value()); + CHECK(lit->light); + CHECK_FALSE(lit->dim); + + auto const dimmed{wagon->LightsPresetCabLight(4)}; + REQUIRE(dimmed.has_value()); + CHECK(dimmed->light); + CHECK(dimmed->dim); + + // a negative value is the same as no value + CHECK_FALSE(wagon->LightsPresetCabLight(5).has_value()); +} + +TEST_CASE("lights preset cab light: positions outside the table, and the lightsset custom one, set nothing") { + vehicle wagon{definition::load("wagon") + .set("LightsList", "Size", 1) + .set("LightsList", "Default", 1) + .set("LightsList", "rows", {{shunting, shunting, 1}})}; + + CHECK(wagon->LightsPresetCabLight(1).has_value()); + CHECK_FALSE(wagon->LightsPresetCabLight(0).has_value()); + CHECK_FALSE(wagon->LightsPresetCabLight(2).has_value()); + CHECK_FALSE(wagon->LightsPresetCabLight(18).has_value()); + CHECK_FALSE(wagon->LightsPresetCabLight(19).has_value()); +} + +TEST_CASE("lights preset cab light: a stray note after the two columns is not read as the cab light") { + // some vehicles of the game carry rows like "38 38 / A" + auto text{definition::load("wagon") + .set("LightsList", "Size", 2) + .set("LightsList", "Default", 1) + .set("LightsList", "rows", {{0, 0}, {38, 38}}) + .text()}; + auto const list{text.find("LightsList")}; + REQUIRE(list != std::string::npos); + auto const row{text.find("38", list)}; + REQUIRE(row != std::string::npos); + auto const rowend{text.find('\n', row)}; + REQUIRE(rowend != std::string::npos); + text.insert(rowend, " / A"); + TMoverParameters wagon(0.0, "wagon", "test", 0); + REQUIRE(wagon.LoadFIZ_Text(text)); + REQUIRE(wagon.LightsPosNo == 2); + CHECK(wagon.Lights[end::front][1] == 38); + CHECK(wagon.Lights[end::rear][1] == 38); + CHECK_FALSE(wagon.LightsPresetCabLight(2).has_value()); +} diff --git a/tests/unit/test_lights_programmer.cpp b/tests/unit/test_lights_programmer.cpp new file mode 100644 index 000000000..8a31563d8 --- /dev/null +++ b/tests/unit/test_lights_programmer.cpp @@ -0,0 +1,93 @@ +#include "stdafx.h" +#include "doctest.h" + +#include "vehicle/lightsprogrammer.h" + +// the lights the light preset selector (programmer) of the occupied cab gives the vehicles of the consist, +// TDynamicObject::SetLights(): the cab's front lights at the end the cab faces, its back lights at the other +// end, and no lights at an end with another vehicle coupled + +namespace { + +int const pc1{light::headlight_left | light::headlight_upper | light::headlight_right}; +int const tailmarkers{light::redmarker_left | light::redmarker_right}; +std::array const cablights{pc1, tailmarkers}; // Lights[end::front], Lights[end::rear] + +// the lights at the vehicle's own end, placed the way TDynamicObject::RaLightsSet() places them +int lights_at(lights_programmer::consist_lights const &Lights, int const Direction, end const Side) { + auto const headend{Direction > 0 ? end::front : end::rear}; + return Side == headend ? Lights.head : Lights.rear; +} + +struct setup { + int cab; // CabOccupied of the vehicle with the programmer + int direction; // its iDirection + std::array coupled; // vehicle coupled at its end::front / end::rear +}; + +lights_programmer::consist_lights lights_for(setup const &Setup) { + // TDynamicObject::SetLights(): the cab faces the head of the consist when CabOccupied * DirectionGet() >= 0 + auto const cabfacinghead{Setup.cab * (Setup.direction > 0 ? 1 : -1) >= 0}; + return lights_programmer::vehicle_lights(cablights, cabfacinghead, Setup.direction, Setup.coupled); +} + +} // namespace + +TEST_CASE("lights programmer: a lone vehicle gets the cab's front lights ahead of the cab and its back lights behind it") { + for (auto const direction : {0, 1}) { + CAPTURE(direction); + // cab 1 faces end::front + auto const fromcab1{lights_for({1, direction, {false, false}})}; + CHECK(lights_at(fromcab1, direction, end::front) == pc1); + CHECK(lights_at(fromcab1, direction, end::rear) == tailmarkers); + // cab -1 faces end::rear + auto const fromcab2{lights_for({-1, direction, {false, false}})}; + CHECK(lights_at(fromcab2, direction, end::rear) == pc1); + CHECK(lights_at(fromcab2, direction, end::front) == tailmarkers); + } +} + +TEST_CASE("lights programmer: the end with the train coupled goes dark, not the other one (eu07/maszyna#395)") { + // a locomotive driven from either cab, with the train coupled at either end, either way round in the consist. + // the end with the train goes dark, the free end shows the lights meant for it + for (auto const direction : {0, 1}) { + for (auto const cab : {1, -1}) { + for (auto const trainend : {end::front, end::rear}) { + CAPTURE(direction); + CAPTURE(cab); + CAPTURE(trainend); + std::array coupled{false, false}; + coupled[trainend] = true; + auto const freeend{trainend == end::front ? end::rear : end::front}; + auto const cabfront{cab > 0 ? end::front : end::rear}; + + auto const lights{lights_for({cab, direction, coupled})}; + + CHECK(lights_at(lights, direction, trainend) == 0); + CHECK(lights_at(lights, direction, freeend) == (freeend == cabfront ? pc1 : tailmarkers)); + } + } + } +} + +TEST_CASE("lights programmer: 6Dg driven backwards from its second cab position pulls the train with its head lights lit (eu07/maszyna#395)") { + // the reported case: the train coupled behind the driver (end::front, which cab -1 has at its back), the + // locomotive running towards end::rear, the train in tow. the head lights stay lit, the end with the train goes dark; + // before the fix the couplings were looked up at the swapped ends and it was the other way round + auto const lights{lights_for({-1, 1, {true, false}})}; + + CHECK(lights_at(lights, 1, end::rear) == pc1); + CHECK(lights_at(lights, 1, end::front) == 0); +} + +TEST_CASE("lights programmer: a vehicle coupled at both ends stays dark") { + for (auto const direction : {0, 1}) { + for (auto const cab : {1, -1}) { + CAPTURE(direction); + CAPTURE(cab); + auto const lights{lights_for({cab, direction, {true, true}})}; + CHECK(lights.head == 0); + CHECK(lights.rear == 0); + } + } +} diff --git a/tests/unit/test_radio.cpp b/tests/unit/test_radio.cpp index 33a12f72d..b65cc2ced 100644 --- a/tests/unit/test_radio.cpp +++ b/tests/unit/test_radio.cpp @@ -26,3 +26,33 @@ TEST_CASE("radio: a radio switched off or without the low voltage doesn't") { } CHECK_FALSE(vehicle->RadioPowered()); } + +// the cut-off in the radio's power supply (eu07/maszyna#438): a fuse, a desk lever or the switch on the radio's +// power supply, closed unless the driver opens it + +TEST_CASE("radio: the radio fuse is closed by default") { + test::vehicle vehicle{test::definition::load("wagon")}; + CHECK(vehicle->RadioFuse); +} + +TEST_CASE("radio: an opened radio fuse cuts the radio off") { + test::vehicle vehicle{test::definition::load("wagon")}; + vehicle->Radio = true; + vehicle->Power24vIsAvailable = true; + vehicle->RadioFuse = false; + CHECK_FALSE(vehicle->RadioPowered()); + vehicle->RadioFuse = true; + CHECK(vehicle->RadioPowered()); +} + +TEST_CASE("radio: opening the radio fuse at a standstill resets the radio-stop, as switching the radio off does") { + test::vehicle loco{test::definition::fiz("4e_v1/4e")}; + loco->Battery = true; + loco->Radio = true; + REQUIRE(loco->RadiostopSwitch(true)); + loco->SecuritySystemCheck(0.1); + CHECK(loco->RadioStopFlag); + loco->RadioFuse = false; + loco->SecuritySystemCheck(0.1); + CHECK_FALSE(loco->RadioStopFlag); +} diff --git a/tests/unit/test_smoke.cpp b/tests/unit/test_smoke.cpp index 05fb8ae8b..281b5dbf6 100644 --- a/tests/unit/test_smoke.cpp +++ b/tests/unit/test_smoke.cpp @@ -2,6 +2,7 @@ #include "doctest.h" #include "vehicle.h" +#include "drive.h" #include "vehicle/smoke.h" @@ -83,3 +84,78 @@ TEST_CASE("smoke: the pending particles never outgrow the room of the source") { CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, rate, 10.0) == rate.limit); } + +TEST_CASE("smoke: an engine the starter turns lets out no smoke until it fires (#523)") { + auto vehicle{diesel()}; + vehicle->dizel_spinup = true; + auto pending{source}; + pending.pending = 5.f; + + vehicle->dizel_FiringCountdown = 0.5; + CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, pending, update) == 0.f); + + vehicle->dizel_FiringCountdown = 0.0; + CHECK(smoke::vehicle_spawn_count(vehicle.mover(), true, pending, update) >= 1.f); +} + +namespace { + +// the locomotive's engine started the way the AI starts it, a second at a time, until it runs (Mains) +bool start_engine(test::driven const &Driven, test::track const &Track) { + for (int second = 0; second < 120 && false == Driven.controlling.Mains; ++second) { + test::start_up(Driven, Track, 1.0); + } + return Driven.controlling.Mains; +} + +} // namespace + +TEST_CASE("smoke: a real diesel smokes only once its engine has fired, SmokeDelay after the starter began (#523)") { + // a diesel with a mechanical transmission and a diesel-electric one + for (auto const *path : {"sm42_v1/6d1", "st44_v2/m62-1151"}) { + CAPTURE(path); + test::track const track{}; + { + // SmokeDelay set in the .fiz of the locomotive + test::vehicle locomotive{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 2)}; + REQUIRE(locomotive->dizel_SmokeDelay == doctest::Approx(2.0)); + auto const driven{test::driving(locomotive)}; + REQUIRE(start_engine(driven, track)); + // the engine started less than a second ago: the starter still turns it + CHECK(locomotive->dizel_FiringCountdown > 0.5); + CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) == 0.f); + // it has fired since + test::drive(driven, track, 3.0); + CHECK(locomotive->Mains); + CHECK(locomotive->dizel_FiringCountdown == 0.0); + CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f); + } + { + // a longer delay from the .fiz + test::vehicle locomotive{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 5)}; + auto const driven{test::driving(locomotive)}; + REQUIRE(start_engine(driven, track)); + test::drive(driven, track, 3.0); + CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) == 0.f); + test::drive(driven, track, 3.0); + CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f); + } + } +} + +TEST_CASE("smoke: without SmokeDelay in its .fiz a diesel smokes as soon as the starter turns, as before (#523)") { + for (auto const *path : {"sm42_v1/6d1", "st44_v2/m62-1151"}) { + CAPTURE(path); + test::track const track{}; + // a locomotive which has the delay, loaded first, doesn't hand it on to the next one: the value is the vehicle's own + test::vehicle delayed{test::definition{test::definition::fiz(path)}.set("Engine", "SmokeDelay", 3)}; + REQUIRE(delayed->dizel_SmokeDelay == doctest::Approx(3.0)); + test::vehicle locomotive{test::definition::fiz(path)}; + REQUIRE(locomotive->dizel_SmokeDelay == 0.0); + CHECK(delayed->dizel_SmokeDelay == doctest::Approx(3.0)); + auto const driven{test::driving(locomotive)}; + REQUIRE(start_engine(driven, track)); + CHECK(locomotive->dizel_FiringCountdown == 0.0); + CHECK(smoke::vehicle_spawn_count(locomotive.mover(), true, source, update) >= 1.f); + } +} diff --git a/tests/unit/test_uc_steps.cpp b/tests/unit/test_uc_steps.cpp new file mode 100644 index 000000000..eb1b26fa4 --- /dev/null +++ b/tests/unit/test_uc_steps.cpp @@ -0,0 +1,115 @@ +#include "stdafx.h" +#include "doctest.h" +#include "vehicle.h" +#include "drive.h" + +#include + +// the universal controller (EIMCtrlType 3) setting its power demand in steps (UCList CtrlValStep), as the 6Dg does +// in steps of 5% (eu07/maszyna#412). the 214M railbus's controller: 3 lowers the power to 0, 4 holds it, 5 raises it +// to 1, at 0.15 a second after IniCDelay (1 s) + +using test::definition; +using test::vehicle; + +namespace { + +constexpr int lower{3}; +constexpr int hold{4}; +constexpr int raise{5}; + +// the railbus started up, its brakes released and its direction set, its controller holding no power +void get_ready(vehicle &Railbus, test::track const &Track) { + auto driven{test::driving(Railbus)}; + REQUIRE(test::start_up(driven, Track)); + test::release_brakes(driven.cab); + for (int i = 0; i < 3 && Railbus->DirActive <= 0; ++i) { + Railbus->DirectionForward(); + } + while (Railbus->MainCtrlPos < hold && Railbus->IncMainCtrl(1)) { + ; + } + while (Railbus->MainCtrlPos > hold && Railbus->DecMainCtrl(1)) { + ; + } + REQUIRE(Railbus->MainCtrlPos == hold); + Railbus.run(2.0, Track); + REQUIRE(Railbus->eimic == doctest::Approx(0.0)); +} + +void move_to(vehicle &Railbus, int const Position) { + while (Railbus->MainCtrlPos < Position && Railbus->IncMainCtrl(1)) { + ; + } + while (Railbus->MainCtrlPos > Position && Railbus->DecMainCtrl(1)) { + ; + } + REQUIRE(Railbus->MainCtrlPos == Position); +} + +bool on_step(double const Value, double const Step) { + return std::abs(Value / Step - std::round(Value / Step)) < 1e-6; +} + +} // namespace + +TEST_CASE("controls: the universal controller with CtrlValStep sets its power in whole steps") { + test::track const line{0.15, 0.0}; + vehicle railbus{definition::fiz("21xm_v1/214ma").set("UCList", "CtrlValStep", 0.05), 0.0, "test", 1}; + REQUIRE(railbus->UniCtrlValStep == doctest::Approx(0.05)); + get_ready(railbus, line); + + // a tap on the raising position: one step at once, kept by the holding one + move_to(railbus, raise); + railbus.step(line); + CHECK(railbus->eimic == doctest::Approx(0.05)); + move_to(railbus, hold); + railbus.run(2.0, line); + CHECK(railbus->eimic == doctest::Approx(0.05)); + + // held there: after the initial delay a step each third of a second (0.15 a second), never in between + move_to(railbus, raise); + for (int i = 0; i < 310; ++i) { // 3.1 s + railbus.step(line); + CAPTURE(i); + CHECK(on_step(railbus->eimic, 0.05)); + } + // the first step at once, 1 s of the initial delay, then 2.1 s of 0.15 a second (6 steps) + CHECK(railbus->eimic == doctest::Approx(0.40)); + move_to(railbus, hold); + railbus.run(2.0, line); + CHECK(railbus->eimic == doctest::Approx(0.40)); + + // up to the full power, and not past it + move_to(railbus, raise); + railbus.run(10.0, line); + CHECK(railbus->eimic == doctest::Approx(1.0)); + + // down the same way: a tap is one step, holding it goes on in steps down to nothing + move_to(railbus, lower); + railbus.step(line); + CHECK(railbus->eimic == doctest::Approx(0.95)); + move_to(railbus, hold); + railbus.run(1.0, line); + CHECK(railbus->eimic == doctest::Approx(0.95)); + move_to(railbus, lower); + for (int i = 0; i < 800; ++i) { // 8 s + railbus.step(line); + CAPTURE(i); + CHECK(on_step(railbus->eimic, 0.05)); + } + CHECK(railbus->eimic == doctest::Approx(0.0)); +} + +TEST_CASE("controls: the universal controller without CtrlValStep sets its power continuously, as before") { + test::track const line{0.15, 0.0}; + vehicle railbus{definition::fiz("21xm_v1/214ma"), 0.0, "test", 1}; + REQUIRE(railbus->UniCtrlValStep == 0.0); + get_ready(railbus, line); + // a tap moves it by 0.01, held it goes on at 0.15 a second after the initial delay + move_to(railbus, raise); + railbus.step(line); + CHECK(railbus->eimic == doctest::Approx(0.01)); + railbus.run(2.0 - 0.01, line); + CHECK(railbus->eimic == doctest::Approx(0.01 + 0.15).epsilon(0.05)); +} diff --git a/utilities/Globals.cpp b/utilities/Globals.cpp index 8957a4a0e..ce299ce5d 100644 --- a/utilities/Globals.cpp +++ b/utilities/Globals.cpp @@ -811,6 +811,12 @@ bool global_settings::ConfigParseSimulation(cParser& Parser, const std::string& return true; } + if (token == "controlcoupling.enginecheck") + { + ParseOne(Parser, control_coupling_engine_check, 1); + return true; + } + return false; } @@ -1653,6 +1659,7 @@ global_settings::export_as_text( std::ostream &Output ) const { export_as_text( Output, "scenario.time.current", ScenarioTimeCurrent ); export_as_text( Output, "scenario.weather.temperature", AirTemperature ); export_as_text( Output, "ai.trainman", AITrainman ); + export_as_text( Output, "controlcoupling.enginecheck", control_coupling_engine_check ); export_as_text( Output, "scalespeculars", ScaleSpecularValues ); export_as_text( Output, "gfxrenderer", GfxRenderer ); export_as_text( Output, "shadows", RenderShadows ); diff --git a/utilities/Globals.h b/utilities/Globals.h index 50e42085b..872338b46 100644 --- a/utilities/Globals.h +++ b/utilities/Globals.h @@ -275,6 +275,7 @@ struct global_settings { bool captureonstart = true; bool render_cab = true; bool crash_damage = true; + bool control_coupling_engine_check = true; // no multiple-unit control between electric and diesel traction vehicles (eu07/maszyna#520) bool gui_defaultwindows = true; bool gui_showtranscripts = true; bool gui_trainingdefault = false; diff --git a/utilities/Timer.h b/utilities/Timer.h index 15fdd4f6b..38a5d101e 100644 --- a/utilities/Timer.h +++ b/utilities/Timer.h @@ -67,6 +67,7 @@ struct subsystem_stopwatches { stopwatch sim_events; stopwatch sim_ai; stopwatch mainloop_total; + stopwatch mainloop_period; // start to start, the wait for fpslimit included }; extern subsystem_stopwatches subsystem; diff --git a/utilities/framepacer.h b/utilities/framepacer.h new file mode 100644 index 000000000..a0de0144d --- /dev/null +++ b/utilities/framepacer.h @@ -0,0 +1,59 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +#include +#include + +// paces the main loop to the frame time set by fpslimit in eu07.ini. +// the frames are scheduled on a fixed cadence rather than by sleeping off what is left of each frame, +// so a sleep that overshoots (the windows timer wakes up in steps of up to ~15.6 ms) is made up by +// a shorter wait in the next frame, and the frame rate averages to the limit. +// all the time arithmetic is done in the clock's integer ticks: a sleep_for() given a float duration +// adds it to now() as float nanoseconds, which after a few hours of system uptime rounds the wake-up +// time to tens of milliseconds and lets the limit fall through (eu07/maszyna#416) +class frame_pacer { + +public: + using clock = std::chrono::steady_clock; + + // called at the end of each frame. returns the point in time the next frame may start at, + // or nothing when it may start right away + [[nodiscard]] std::optional next_frame(clock::time_point const Now, std::chrono::duration const Frametime) { + return next_frame(Now, std::chrono::duration_cast(Frametime)); + } + [[nodiscard]] std::optional next_frame(clock::time_point const Now, clock::duration const Minframetime) { + if (Minframetime <= clock::duration::zero()) { + // no limit + m_framestart.reset(); + return std::nullopt; + } + if (!m_framestart) { + // first paced frame + m_framestart = Now; + return std::nullopt; + } + auto const nextframe{*m_framestart + Minframetime}; + if (Now >= nextframe + Minframetime) { + // a whole frame or more behind: start the cadence anew rather than run frames back to back to catch up + m_framestart = Now; + return std::nullopt; + } + m_framestart = nextframe; + if (Now >= nextframe) { + return std::nullopt; + } + return nextframe; + } + +private: + // the scheduled start of the current frame + std::optional m_framestart; +}; diff --git a/utilities/translation.cpp b/utilities/translation.cpp index c0dbeb1a0..e172eabf1 100644 --- a/utilities/translation.cpp +++ b/utilities/translation.cpp @@ -225,6 +225,10 @@ std::string locale::label_cab_control(std::string const &Label) { "coolingfans_sw:", STRN("cooling fans") }, { "main_off_bt:", STRN("line breaker") }, { "main_on_bt:", STRN("line breaker") }, + { "mainb_off_bt:", STRN("line breaker B") }, + { "mainb_on_bt:", STRN("line breaker B") }, + { "mainc_off_bt:", STRN("line breaker C") }, + { "mainc_on_bt:", STRN("line breaker C") }, { "security_reset_bt:", STRN("alerter") }, { "shp_reset_bt:", STRN("shp") }, { "releaser_bt:", STRN("independent brake releaser") }, @@ -270,7 +274,14 @@ std::string locale::label_cab_control(std::string const &Label) { "converterlocal_sw:", STRN("local converter") }, { "converteroff_sw:", STRN("converter") }, { "main_sw:", STRN("line breaker") }, + { "mainb_sw:", STRN("line breaker B") }, + { "mainc_sw:", STRN("line breaker C") }, { "radio_sw:", STRN("radio") }, + { "radioon_sw:", STRN("radio") }, + { "radiooff_sw:", STRN("radio") }, + { "radiofuse_sw:", STRN("radio fuse") }, + { "radiofuseon_sw:", STRN("radio fuse") }, + { "radiofuseoff_sw:", STRN("radio fuse") }, { "radiochannel_sw:", STRN("radio channel") }, { "radiochannelprev_sw:", STRN("radio channel") }, { "radiochannelnext_sw:", STRN("radio channel") }, diff --git a/vehicle/Driver.cpp b/vehicle/Driver.cpp index 709cb0e43..ed65910dd 100644 --- a/vehicle/Driver.cpp +++ b/vehicle/Driver.cpp @@ -2769,6 +2769,7 @@ bool TController::PrepareEngine() cue_action( driver_hint::batteryon ); cue_action( driver_hint::cabactivation); + cue_action( driver_hint::radiofuseon ); cue_action( driver_hint::radioon ); if( has_diesel_engine() ) { @@ -3014,6 +3015,74 @@ bool TController::ReleaseEngine() { // defined further down, with the braking demand it is used for static double brake_response_horizon( TMoverParameters const *Vehicle, TBrakeSystem const Brakesystem, double const Acceleration, double const Brakea0 ); +// one step more of the train brake, sized from the consist brake table against the deceleration asked for +bool +TController::increase_train_brake() { + + // dodane dla towarowego + float pos_corr = 0; + + TDynamicObject *d; + d = pVehicles[0]; // pojazd na czele składu + while (d) + { // przeliczanie dodatkowego potrzebnego spadku ciśnienia + if( ( d->MoverParameters->Hamulec->GetBrakeStatus() & b_dmg ) == 0 ) { + pos_corr -= ( std::min( 5.0, d->MoverParameters->Hamulec->GetCRP() ) - 5.0 ) * d->MoverParameters->TotalMass; + } + d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła) + } + pos_corr = pos_corr / fMass * 2.5; + + if (mvOccupied->BrakeHandle == TBrakeHandle::FV4a) + { + pos_corr += mvOccupied->Handle->GetCP()*0.2; + + } + if( double const deltaAcc = -AccDesired*BrakeAccFactor() - (fBrake_a0[0] + 4.0 * (/*GBH mvOccupied->BrakeCtrlPosR*/BrakeCtrlPosition - 1 - pos_corr)*fBrake_a1[0]); + deltaAcc > brake_increase_margin() ) + { + if( /*GBH mvOccupied->BrakeCtrlPosR*/BrakeCtrlPosition < 0.1 ) { + auto const OK { /*mvOccupied->*/BrakeLevelAdd( BrakingInitialLevel ) }; //GBH + // HACK: stronger braking to overcome SA134 engine behaviour + if( is_dmu() + && VelNext == 0.0 + && fBrakeDist < 200.0 ) { + BrakeLevelAdd( + fBrakeDist / ActualProximityDist < 0.8 ? + 0.5 : + 1.0 ); + } + return OK; + } + auto const OK { /*mvOccupied->*/BrakeLevelAdd( BrakingLevelIncrease ) }; //GBH + // brake harder if the acceleration is much higher than desired + /*if( ( deltaAcc > 2 * fBrake_a1[ 0 ] ) + && ( mvOccupied->BrakeCtrlPosR + BrakingLevelIncrease <= 5.0 ) ) { + mvOccupied->BrakeLevelAdd( BrakingLevelIncrease ); + } GBH */ + if( deltaAcc > 2 * fBrake_a1[0] + && BrakeCtrlPosition + BrakingLevelIncrease <= 5.0 ) { + /*mvOccupied->*/BrakeLevelAdd( BrakingLevelIncrease ); + } + return OK; + } + if( BrakeCtrlPosition > 0.0 + && AccDesired < 0.0 // only while braking is asked for, not when called for a train slipping back while starting + && ( fBrakeHeldTime > ( + mvOccupied->BrakeDelayFlag > bdelay_G ? + mvOccupied->BrakeDelay[ 1 ] : + mvOccupied->BrakeDelay[ 3 ] ) + // a train falling further behind needs no full fill time to be seen not to get enough + || ( ( fShortfall > 0.02 ) + && ( fBrakeHeldTime > brake_response_horizon( mvOccupied, BrakeSystem, 1.0, fBrake_a0[ 0 ] ) ) ) ) ) { + // the table says the present position is enough, but the brake has had its full fill + // time since the handle last moved and the train is still not slowing down as asked: + // believe the train rather than the table + return BrakeLevelAdd( BrakingLevelIncrease ); + } + return false; +} + bool TController::IncBrake() { // zwiększenie hamowania auto OK { false }; @@ -3105,70 +3174,7 @@ bool TController::IncBrake() OK = false; } else { - // dodane dla towarowego - float pos_corr = 0; - - TDynamicObject *d; - d = pVehicles[0]; // pojazd na czele składu - while (d) - { // przeliczanie dodatkowego potrzebnego spadku ciśnienia - if( ( d->MoverParameters->Hamulec->GetBrakeStatus() & b_dmg ) == 0 ) { - pos_corr -= ( std::min( 5.0, d->MoverParameters->Hamulec->GetCRP() ) - 5.0 ) * d->MoverParameters->TotalMass; - } - d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła) - } - pos_corr = pos_corr / fMass * 2.5; - - if (mvOccupied->BrakeHandle == TBrakeHandle::FV4a) - { - pos_corr += mvOccupied->Handle->GetCP()*0.2; - - } - double deltaAcc = -AccDesired*BrakeAccFactor() - (fBrake_a0[0] + 4.0 * (/*GBH mvOccupied->BrakeCtrlPosR*/BrakeCtrlPosition - 1 - pos_corr)*fBrake_a1[0]); - - if( deltaAcc > brake_increase_margin() ) - { - if( /*GBH mvOccupied->BrakeCtrlPosR*/BrakeCtrlPosition < 0.1 ) { - OK = /*mvOccupied->*/BrakeLevelAdd( BrakingInitialLevel ); //GBH - // HACK: stronger braking to overcome SA134 engine behaviour - if( is_dmu() - && VelNext == 0.0 - && fBrakeDist < 200.0 ) { - BrakeLevelAdd( - fBrakeDist / ActualProximityDist < 0.8 ? - 0.5 : - 1.0 ); - } - } - else { - OK = /*mvOccupied->*/BrakeLevelAdd( BrakingLevelIncrease ); //GBH - // brake harder if the acceleration is much higher than desired - /*if( ( deltaAcc > 2 * fBrake_a1[ 0 ] ) - && ( mvOccupied->BrakeCtrlPosR + BrakingLevelIncrease <= 5.0 ) ) { - mvOccupied->BrakeLevelAdd( BrakingLevelIncrease ); - } GBH */ - if( deltaAcc > 2 * fBrake_a1[0] - && BrakeCtrlPosition + BrakingLevelIncrease <= 5.0 ) { - /*mvOccupied->*/BrakeLevelAdd( BrakingLevelIncrease ); - } - } - } - else if( BrakeCtrlPosition > 0.0 - && AccDesired < 0.0 // only while braking is asked for, not when called for a train slipping back while starting - && ( fBrakeHeldTime > ( - mvOccupied->BrakeDelayFlag > bdelay_G ? - mvOccupied->BrakeDelay[ 1 ] : - mvOccupied->BrakeDelay[ 3 ] ) - // a train falling further behind needs no full fill time to be seen not to get enough - || ( ( fShortfall > 0.02 ) - && ( fBrakeHeldTime > brake_response_horizon( mvOccupied, BrakeSystem, 1.0, fBrake_a0[ 0 ] ) ) ) ) ) { - // the table says the present position is enough, but the brake has had its full fill - // time since the handle last moved and the train is still not slowing down as asked: - // believe the train rather than the table - OK = BrakeLevelAdd( BrakingLevelIncrease ); - } - else - OK = false; + OK = increase_train_brake(); } } if( /*GBH mvOccupied->BrakeCtrlPos*/ @@ -3206,6 +3212,14 @@ bool TController::IncBrake() mvOccupied->SwitchEPBrake( 1 ); // to nie chce działać OK = true; } + else if( ( mvOccupied->Handle->GetPos( bh_EPR ) - mvOccupied->Handle->GetPos( bh_EPN ) < 0.1 ) + && ( mvOccupied->EpForce <= 0.0 ) + && ( mvOccupied->EPBrakeControlPowered() ) ) { + // the handle already in the EP brake position, but the EP brake dropped out with the control's + // supply (e.g. the EP fuse off in the running brake test): switch it on again + mvOccupied->SwitchEPBrake( 1 ); + OK = ( mvOccupied->EpForce > 0.0 ); + } else OK = false; break; @@ -3286,6 +3300,16 @@ bool TController::DecBrake() { // a distributor applied at all gives at least its minimum stage, about what the first position does, so // a position short of the first one brakes no weaker than that deltaAcc = -AccDesired * BrakeAccFactor() - ( fBrake_a0[ 0 ] + 4 * std::max( 0.0, BrakeCtrlPosition - pos_diff ) * fBrake_a1[ 0 ] ); + } + if( bUphillStart ) { + // starting uphill the train brake holds the train until the power does + break; + } + if( ( BrakeCtrlPosition > 0.0 ) + && ( uphill_stop_hold() ) ) { + // any release now raises the pipe, and a long train releases more than the handle is moved back, too late + // to apply again before the train stands: keep the brake as it is, and the locomotive brake with it + break; } if (deltaAcc < 0 && /*GBH mvOccupied->BrakeCtrlPosR*/ BrakeCtrlPosition > 0) { OK = /*mvOccupied->*/ BrakeLevelAdd(-0.25); @@ -3463,7 +3487,7 @@ bool TController::IncSpeed() mvOccupied->Vel <= (IsCargoTrain ? 40 : 30) + (seriesmodefieldshunting ? 5 : 0) - (fAccGravity < -0.025 ? 10 : 0)); // when not in series mode use the first available parallel mode configuration until 50/60 km/h for passenger/cargo train // (if there's only one parallel mode configuration it'll be used regardless of current speed) - auto const usefieldshunting = mvControlling->StLinFlag && mvControlling->RList[mvControlling->MainCtrlPos].R < 0.01 && + auto const usefieldshunting = mvControlling->StLinFlag && mvControlling->RList[mvControlling->MainCtrlPos].R < 0.01 && false == mvControlling->IsScndCtrlLockedByMainCtrl() && (useseriesmode ? mvControlling->RList[mvControlling->MainCtrlPos].Bn == 1 : true == sufficientacceleration && true == sufficienttractionforce && mvOccupied->Vel <= (IsCargoTrain ? 60 : 50) + (parallelmodefieldshunting ? 5 : 0) ? mvControlling->RList[mvControlling->MainCtrlPos].Bn > 1 : @@ -6027,6 +6051,8 @@ TController::determine_consist_state() { { // sprawdzenie odhamowania wszystkich połączonych pojazdów auto *vehicle { p->MoverParameters }; auto const bp { std::max( 0.0, vehicle->BrakePress - ( vehicle->SpeedCtrlUnit.Parking ? vehicle->MaxBrakePress[ 0 ] * vehicle->StopBrakeDecc : 0.0 ) ) }; + // starting uphill the power is applied against the train brake on purpose, until the power holds the train + auto const heldforstart { bUphillStart }; if (Ready) { // bo jak coś nie odhamowane, to dalej nie ma co sprawdzać if( auto const isbraking { TestFlagAny( vehicle->Hamulec->GetBrakeStatus(), b_hld | b_on ) }; @@ -6035,7 +6061,9 @@ TController::determine_consist_state() { // once in motion a brake down to 0.4 bar counts as released (UIC), even if its distributor // is still in the lap position while the brake pipe recharges ( isbraking && bp > 0.4 ) || vehicle->Fb > 10000.0 ) { // 10 kN - Ready = false; + // ready all the same only at a standstill with the power going on against the brake on purpose; + // in motion a braking force left anywhere in the train (a hand brake) stops it as before + Ready = heldforstart && ( vehicle->Vel < 1.0 ); } // Ra: odluźnianie przeładowanych lokomotyw, ciągniętych na zimno - prowizorka... if( bp >= 0.4 && (AIControllFlag || Global.AITrainman && mvOccupied->Vel < EU07_AI_NOMOVEMENT && !is_emu() && !is_dmu()) && BrakeCtrlPosition == gbh_RP // jest pozycja jazdy @@ -6053,7 +6081,7 @@ TController::determine_consist_state() { vehicle->BrakeReleaser(0); } } - fReady = std::max( bp, fReady ); // szukanie najbardziej zahamowanego + fReady = std::max( heldforstart ? 0.0 : bp, fReady ); // szukanie najbardziej zahamowanego if( ( dy = p->VectorFront().y ) != 0.0 ) { // istotne tylko dla pojazdów na pochyleniu // ciężar razy składowa styczna grawitacji @@ -6221,6 +6249,13 @@ TController::control_pantographs() { fActionTime = -2.0 - Random(10); } + // the pantograph setup the .fiz suggests for shunting (AI: ShuntPantstate=, eu07/maszyna#461), 0 when there's none + // or the vehicle isn't shunting + auto const shuntpantographsetup { + ( OrderCurrentGet() & ( Shunt | Loose_shunt ) ) != 0 ? + mvOccupied->AIHintShuntPantstate : + 0 }; + // raise/lower pantographs as needed auto const useregularpantographlayout { pVehicle->Next(coupling::control) == nullptr // standalone @@ -6247,7 +6282,11 @@ TController::control_pantographs() { // jeśli nie trzeba opuszczać pantografów // TODO: check if faction alone reduces frequency enough if( fActionTime > 0.0 ) { - if( mvOccupied->AIHintPantstate == 0 ) { + if( shuntpantographsetup != 0 ) { + // shunting with the pantograph setup the .fiz suggests for it + control_pantographs_setup( shuntpantographsetup ); + } + else if( mvOccupied->AIHintPantstate == 0 ) { // jazda na tylnym if( iDirection >= 0 && useregularpantographlayout ) { // jak jedzie w kierunku sprzęgu 0 @@ -6300,6 +6339,12 @@ TController::control_pantographs() { } } } + else if( shuntpantographsetup != 0 ) { + // shunting with the suggested setup, also while standing, and without raising more pantographs when idling + if( fOverhead2 <= 0.0 && iOverheadDown == 0 ) { + control_pantographs_setup( shuntpantographsetup ); + } + } else { if( !mvOccupied->AIHintPantUpIfIdle || IdleTime <= 45.0 || std::abs(fStopTime) <= 15.0 || mvPantographUnit->EnginePowerSource.CollectorParameters.CollectorsNo <= 1 ) { @@ -6326,6 +6371,31 @@ TController::control_pantographs() { } } +// raises the pantographs of the suggested setup (bit 0: front, bit 1: rear) and lowers the others, these only once +// a pantograph of the setup collects the voltage, so the vehicle doesn't lose its power on the way +void +TController::control_pantographs_setup( int const Setup ) { + + auto const front { ( Setup & 1 << 0 ) != 0 }; + auto const rear { ( Setup & 1 << 1 ) != 0 }; + if( front ) { + cue_action( driver_hint::frontpantographvalveon ); + } + if( rear ) { + cue_action( driver_hint::rearpantographvalveon ); + } + if( auto const setuplive { ( front && mvPantographUnit->PantFrontVolt != 0.0 ) || ( rear && mvPantographUnit->PantRearVolt != 0.0 ) }; + false == setuplive ) { + return; + } + if( false == front ) { + cue_action( driver_hint::frontpantographvalveoff ); + } + if( false == rear ) { + cue_action( driver_hint::rearpantographvalveoff ); + } +} + void TController::control_horns( double const Timedelta ) { // horn control @@ -6400,13 +6470,19 @@ TController::control_security_system( double const Timedelta ) { } } if( iEngineActive - && false == mvOccupied->Radio + && ( false == mvOccupied->Radio || false == mvOccupied->RadioFuse ) && false == mvOccupied->RadioStopFlag ) { // otherwise if it's safe to do so, turn the radio back on // arbitrary 5 sec delay before switching radio back on m_radiocontroltime = std::min( m_radiocontroltime, 5.0 ); if( m_radiocontroltime < 0.0 ) { - cue_action( driver_hint::radioon ); + // hint at whichever of the two is open, the radio's switch or the cut-off in its power supply + if( false == mvOccupied->RadioFuse ) { + cue_action( driver_hint::radiofuseon ); + } + if( false == mvOccupied->Radio ) { + cue_action( driver_hint::radioon ); + } } else { m_radiocontroltime -= Timedelta; @@ -6990,8 +7066,14 @@ TController::UpdateConnect() { auto *vehicle { iCouplingVehicle.value().first }; auto const couplingend { iCouplingVehicle.value().second }; auto *vehicleparameters { vehicle->MoverParameters }; - if( vehicleparameters->Couplers[ couplingend ].CouplingFlag != iCoupler ) { - auto const &neighbour { vehicleparameters->Neighbours[ couplingend ] }; + auto const &neighbour { vehicleparameters->Neighbours[ couplingend ] }; + // vehicles which can't share their control get coupled without the control connection (eu07/maszyna#520) + auto expectedcoupling { iCoupler }; + if( neighbour.vehicle != nullptr ) { + auto const neighbourend { neighbour.vehicle_end != 2 ? neighbour.vehicle_end : vehicleparameters->Couplers[ couplingend ].ConnectedNr }; + expectedcoupling = vehicleparameters->CompatibleCoupling( couplingend, *neighbour.vehicle->MoverParameters, neighbourend, iCoupler ); + } + if( vehicleparameters->Couplers[ couplingend ].CouplingFlag != expectedcoupling ) { if( neighbour.vehicle != nullptr && neighbour.distance < 10 ) { // check whether we need to attach coupler adapter auto coupleriscompatible{true}; @@ -7013,7 +7095,7 @@ TController::UpdateConnect() { } } // NOTE: no else as the preceeding block can potentially establish expected connection - if( vehicleparameters->Couplers[ couplingend ].CouplingFlag == iCoupler ) { + if( vehicleparameters->Couplers[ couplingend ].CouplingFlag == expectedcoupling ) { // jeżeli został podłączony CheckVehicles( Connect ); // sprawdzić światła nowego składu @@ -7272,6 +7354,61 @@ TController::handle_orders() { UpdateChangeDirection(); } +// the stages of uncoupling: each one sets the speed for the next +void +TController::set_velocity_for_uncoupling() { + + if( iVehicleCount < 0 ) { + // 4th stage: restore initial direction + if( ( iDrivigFlags & movePress ) != 0 ) { + SetVelocity( 0, 0, stopJoin ); + } + return; + } + // 3rd stage: compress buffers and uncouple + if( ( iDrivigFlags & movePress ) != 0 && iDirection == iDirectionOrder ) { + SetVelocity( 2, 0 ); // jazda w ustawionym kierunku z prędkością 2 + return; + } + // 1st stage: bring it to stop + // 2nd stage: apply consist brakes and change direction + SetVelocity( 0, 0, stopJoin ); +} + +// uphill, the gradient alone brings a slow train to a stand within metres, far sooner than a released +// brake applies; so the train brake goes on while the train is coming to a stand, stays on while it +// stands, and is applied for real if the train has started to roll back +void +TController::hold_train_coming_to_stand_uphill() { + + if( ( false == is_train() ) + || ( ( OrderCurrentGet() & Obey_train ) == 0 ) + || ( VelNext != 0.0 ) + || ( ActualProximityDist > fMaxProximityDist ) + || ( fAccGravity >= EU07_AI_UPHILLGRAVITY ) ) { + return; + } + auto const vel { DirectionalVel() }; + if( std::abs( vel ) < EU07_AI_NOMOVEMENT ) { + VelDesired = 0.0; + AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); + return; + } + if( ( vel < 0.0 ) + || ( ( vel < 5.0 ) && ( AccDesired < 0.0 ) ) + // rolling to a stand on the gradient alone, the brake has to be on its way before the train stops: + // once the time left to the stand is no longer than half of what the brake takes to apply, apply it; any + // sooner and the brake takes off more of the distance than the stop was planned with + || ( ( BrakeSystem == TBrakeSystem::Pneumatic ) + // not for a train that is short of where it is to stop and is to pull up further + && ( AccDesired <= 0.0 ) + && ( vel / 3.6 / -fAccGravity <= 0.5 * brake_response_horizon( mvOccupied, BrakeSystem, 1.0, fBrake_a0[ 0 ] ) ) ) ) { + // the gradient alone already slows the train down nearly this much; ask for enough on top of it that + // the brake is applied for sure, not held back by the margin against small corrections + AccDesired = std::min( AccDesired, fAccGravity - std::max( 0.15, fBrake_a0[ 0 ] ) - brake_increase_margin() ); + } +} + void TController::pick_optimal_speed( double const Range ) { @@ -7307,23 +7444,7 @@ TController::pick_optimal_speed( double const Range ) { } // uncoupling mode changes velocity/acceleration between stages if( ( OrderCurrentGet() & Disconnect ) != 0 ) { - if( iVehicleCount >= 0 ) { - // 3rd stage: compress buffers and uncouple - if( (iDrivigFlags & movePress) != 0 && iDirection == iDirectionOrder ) { - SetVelocity( 2, 0 ); // jazda w ustawionym kierunku z prędkością 2 - } - // 1st stage: bring it to stop - // 2nd stage: apply consist brakes and change direction - else { - SetVelocity( 0, 0, stopJoin ); - } - } - else { - // 4th stage: restore initial direction - if( ( iDrivigFlags & movePress ) != 0 ) { - SetVelocity( 0, 0, stopJoin ); - } - } + set_velocity_for_uncoupling(); } VelLimitLastDist = { VelDesired, -1 }; @@ -7376,25 +7497,8 @@ TController::pick_optimal_speed( double const Range ) { is_car() ? -2.0 : -0.9, is_car() ? 2.0 : 0.9 ); - if( is_train() - && ( ( OrderCurrentGet() & Obey_train ) != 0 ) - && ( VelNext == 0.0 ) - && ( ActualProximityDist <= fMaxProximityDist ) - && ( fAccGravity < -0.025 ) ) { - // uphill, the gradient alone brings a slow train to a stand within metres, far sooner than a released - // brake applies; so the train brake goes on while the train is coming to a stand, stays on while it - // stands, and is applied for real if the train has started to roll back. done last, so that none of - // the adjustments above, made for a train moving forward, can undo it - auto const vel { DirectionalVel() }; - if( std::abs( vel ) < EU07_AI_NOMOVEMENT ) { - VelDesired = 0.0; - AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); - } - else if( ( vel < 0.0 ) - || ( ( vel < 5.0 ) && ( AccDesired < 0.0 ) ) ) { - AccDesired = std::min( AccDesired, fAccGravity - 0.15 ); - } - } + // done last, so that none of the adjustments above, made for a train moving forward, can undo it + hold_train_coming_to_stand_uphill(); // if the route ahead is blocked we might need to head the other way check_route_behind( 1000 ); // NOTE: legacy scan range value @@ -7573,13 +7677,10 @@ brake_response_horizon( TMoverParameters const *Vehicle, TBrakeSystem const Brak auto horizon { ( 1.0 - Brakea0 ) * 30.0 / 3.6 }; if( Brakesystem == TBrakeSystem::Pneumatic ) { + // BrakeDelay holds the release and the application time in G, then the same two in P + auto const delays { Vehicle->BrakeDelayFlag > bdelay_G ? 0 : 2 }; auto const isrelease { Acceleration < 0.0 }; - horizon = std::max( - horizon, - 0.5 * ( - Vehicle->BrakeDelayFlag > bdelay_G ? - Vehicle->BrakeDelay[ isrelease ? 0 : 1 ] : - Vehicle->BrakeDelay[ isrelease ? 2 : 3 ] ) ); + horizon = std::max( horizon, 0.5 * Vehicle->BrakeDelay[ delays + ( isrelease ? 0 : 1 ) ] ); } return horizon; } @@ -7599,15 +7700,26 @@ uphill_coasting_speed( double const Distance, double const Gravity ) { // resultant acceleration [m/s2] to ask for now so that a steady application of the pneumatic brake takes the train // from Velocity down to Target [km/h] over Distance [m], with the brake force following the speed the way the // consist brake table says it does (cast iron blocks grip harder as the train slows) +struct consist_brake_table { + double const *a0; // deceleration at handle position 1, by speed + double const *a1; // deceleration added by each quarter of a position, by speed + int size; // entries, up to the vehicle's top speed + double vmax; // the vehicle's top speed [km/h] + + // deceleration [m/s2] of a full service application at Kmh + double full_braking( double const Kmh ) const { + auto const index { std::clamp( static_cast( size * Kmh / std::max( 1.0, vmax ) ), 1, size ) }; + return std::max( 0.01, a0[ index ] + 12.0 * a1[ index ] ); } +}; + static double shaped_braking_demand( double const Velocity, double const Target, double const Distance, double const Gravity, - double const Vmax, double const *Brakea0, double const *Brakea1, int const Tablesize ) { + consist_brake_table const &Table ) { - auto const fullbraking = [&]( double const Kmh ) { - auto const index { std::clamp( static_cast( Tablesize * Kmh / std::max( 1.0, Vmax ) ), 1, Tablesize ) }; - return std::max( 0.01, Brakea0[ index ] + 12.0 * Brakea1[ index ] ); }; - auto const travel = [&]( double const Ratio ) { + auto const fullbraking = [&Table]( double const Kmh ) { + return Table.full_braking( Kmh ); }; + auto const travel = [Velocity, Target, Gravity, &fullbraking]( double const Ratio ) { auto const steps { 24 }; auto const step { ( Velocity - Target ) / steps }; auto distance { 0.0 }; @@ -7633,6 +7745,135 @@ shaped_braking_demand( return Gravity - high * fullbraking( Velocity ); } +// outside of max safe range: follow the braking curve down to the speed ahead, Vel is the present speed in the +// direction of travel +void +TController::adjust_desired_speed_for_braking_curve( double const Vel ) { + + AccDesired = AccPreferred; + if( Vel <= min_speed( ActualProximityDist > 10.0 ? 10.0 : 5.0, VelDesired ) ) { + return; + } + // allow to coast at reasonably low speed + auto const brakingdistance { fBrakeDist * braking_distance_multiplier( VelNext ) }; + if( auto const slowdowndistance { ( + mvOccupied->CategoryFlag == 2 ? // cars can stop on a dime, for bigger vehicles we enforce some minimal braking distance + brakingdistance : + std::max( + (OrderCurrentGet() & Connect) == 0 ? 100.0 : 25.0, + brakingdistance ) ) }; + brakingdistance + std::max(slowdowndistance, fMaxProximityDist) < ActualProximityDist - fMaxProximityDist ) { + // don't slow down prematurely; as long as we have room to come to a full stop at a safe distance, we're good + return; + } + // ensure some minimal coasting speed, otherwise a vehicle entering this zone at very low speed will be crawling forever + auto const brakingpointoffset = ( + ( VelNext == 0.0 ) && is_train() && ( OrderCurrentGet() & Obey_train ) ? + stopping_margin() : // the same stopping point as the final approach + VelNext * braking_distance_multiplier( static_cast( VelNext ) ) ); + // a pneumatic brake acts on the state the train will be in once it has responded; while the + // train is still speeding up, plan the deceleration from there, so more is asked for at once + auto velocity { Vel }; + auto distance { ActualProximityDist }; + if( ( BrakeSystem == TBrakeSystem::Pneumatic ) + && ( AbsAccS > 0.0 ) ) { + auto const horizon { brake_response_horizon( mvOccupied, BrakeSystem, AbsAccS, fBrake_a0[ 0 ] ) }; + velocity = Vel + 3.6 * horizon * AbsAccS; + distance = std::max( 0.5 * ActualProximityDist, ActualProximityDist - ( Vel + velocity ) * 0.5 / 3.6 * horizon ); + } + auto const brakingroom { + std::max( + distance - brakingpointoffset, + std::min( + distance, + brakingpointoffset ) ) }; + auto deceleration { ( VelNext * VelNext - velocity * velocity ) / ( 25.92 * brakingroom + 0.1 ) }; + if( ( BrakeSystem == TBrakeSystem::Pneumatic ) && ( velocity > VelNext ) ) { + // follow the shape of the consist brake force over speed rather than assume a constant + // deceleration, over the distance left once the brake has had time to fill (while the + // train is still speeding up, the prediction above has taken that off already) + auto room { brakingroom }; + if( ( AbsAccS <= 0.0 ) + && ( BrakeCtrlPosition <= 0.0 ) ) { // only while the brake is still to be applied: once it acts, the room it needs to respond is behind + // making for a passenger stop only the time the brake takes to fill: the look-ahead the horizon + // keeps as its floor was set for the stops at a signal, and a vehicle that brakes with its + // independent brake, which leaves the train brake handle where it is, kept braking earlier + // and earlier the whole way in, to crawl the last tens of metres to the stop point + auto const brakea0 { bStopTargetIsPassengerStop ? 1.0 : fBrake_a0[ 0 ] }; + room = std::max( + 0.5 * brakingroom, + brakingroom - Vel / 3.6 * brake_response_horizon( mvOccupied, BrakeSystem, 1.0, brakea0 ) ); + } + deceleration = shaped_braking_demand( + velocity, VelNext, room + 0.1 / 25.92, fAccGravity, + { fBrake_a0, fBrake_a1, BrakeAccTableSize, mvOccupied->Vmax } ); + } + AccDesired = std::min( AccDesired, deceleration ); // najpierw hamuje mocniej, potem zluzuje + if( Vel <= VelNext ) { + return; + } + if( deceleration < fAccGravity - 0.001 ) { + // no power while still above the speed being braked for + AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); + } + else if( ( fAccGravity < -0.025 ) + && ( ( OrderCurrentGet() & Obey_train ) != 0 ) + && ( false == uphill_brake_committed( Vel ) ) + && ( ActualProximityDist - uphill_stopping_distance( Vel, fAccGravity ) > brakingpointoffset ) ) { + // uphill the gradient alone slows the train down more than it is asked to; + // keep it rolling at the present speed until that changes + AccDesired = std::min( 0.0, AccPreferred ); + VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - brakingpointoffset, fAccGravity ) ); + } +} + +// the final approach to a stop, inside the proximity range: Vel is the present speed in the direction of travel +void +TController::adjust_desired_speed_for_final_approach( double const Vel ) { + + if( ( mvOccupied->CategoryFlag & 1 ) == 0 ) { + // for cars (and others) coast at low speed until we hit min proximity range + VelDesired = min_speed( VelDesired, 5.0 ); + return; + } + // trains + if( ( OrderCurrentGet() & ( Shunt | Connect ) ) + && ( Obstacle.distance < 50 ) ) { + // crude detection of edge case, if approaching another vehicle coast slowly until min distance + // this should allow to bunch up trainsets more on sidings + VelDesired = min_speed( 5.0, VelDesired ); + return; + } + // hamowanie tak, aby stanąć + if( ( OrderCurrentGet() & Obey_train ) == 0 ) { + VelDesired = VelNext; + AccDesired = ( VelNext * VelNext - Vel * Vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) ); + AccDesired = std::min( AccDesired, fAccThreshold ); + return; + } + // a train keeps its desired speed until the lower edge of the stopping window (a desired + // speed of 0 here asks for hard braking whatever the distance left), aims at the middle + // of the window, and asks only for what that takes + auto const stoppingroom { std::max( 0.5, ActualProximityDist - stopping_margin() ) }; + AccDesired = ( + BrakeSystem == TBrakeSystem::Pneumatic ? + // cast iron blocks grip harder as the train comes to a stand + shaped_braking_demand( + Vel, VelNext, stoppingroom, fAccGravity, + { fBrake_a0, fBrake_a1, BrakeAccTableSize, mvOccupied->Vmax } ) : + ( VelNext * VelNext - Vel * Vel ) / ( 25.92 * stoppingroom ) ); + if( ( fAccGravity < -0.025 ) + && ( AccDesired >= fAccGravity - 0.001 ) // no brake needed at all + && ( false == uphill_brake_committed( Vel ) ) + && ( ActualProximityDist - uphill_stopping_distance( Vel, fAccGravity ) > stopping_margin() ) ) { + // uphill the gradient alone would bring the train to a stand short of the + // middle of the stopping window; keep it rolling at the present speed until that changes, + // but no faster than the gradient alone can take off by the middle of the window + AccDesired = std::min( 0.0, AccPreferred ); + VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - stopping_margin(), fAccGravity ) ); + } +} + void TController::adjust_desired_speed_for_target_speed( double const Range ) { // ustalanie zadanego przyspieszenia @@ -7664,137 +7905,21 @@ TController::adjust_desired_speed_for_target_speed( double const Range ) { AccDesired = AccPreferred; } } + else if( ( ActualProximityDist > fMinProximityDist ) + // only a stop has a final approach of its own inside the proximity range; a lower speed ahead + // keeps the braking curve below right up to where it begins, or the train would stop braking + // (and even take power) that far out + && ( VelNext == 0.0 ) + && ( ActualProximityDist < fMaxProximityDist ) ) { + // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko + // jak minął już maksymalny dystans po prostu hamuj (niski stopień) + // ma stanąć, a jest w drodze hamowania albo ma jechać + adjust_desired_speed_for_final_approach( vel ); + AccDesired = std::min( AccDesired, AccPreferred ); + } else if (ActualProximityDist > fMinProximityDist) { // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko - // only a stop has a final approach of its own inside the proximity range; a lower speed ahead - // keeps the braking curve below right up to where it begins, or the train would stop braking - // (and even take power) that far out - if( ( VelNext == 0.0 ) && ( ActualProximityDist < fMaxProximityDist ) ) { - // jak minął już maksymalny dystans po prostu hamuj (niski stopień) - // ma stanąć, a jest w drodze hamowania albo ma jechać -/* - VelDesired = min_speed( VelDesired, VelNext ); -*/ - if( VelNext == 0.0 ) { - if( mvOccupied->CategoryFlag & 1 ) { - // trains - if( OrderCurrentGet() & (Shunt | Connect) - && Obstacle.distance < 50 ) { - // crude detection of edge case, if approaching another vehicle coast slowly until min distance - // this should allow to bunch up trainsets more on sidings - VelDesired = min_speed( 5.0, VelDesired ); - } - else { - // hamowanie tak, aby stanąć - if( ( OrderCurrentGet() & Obey_train ) == 0 ) { - VelDesired = VelNext; - AccDesired = ( VelNext * VelNext - vel * vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) ); - AccDesired = std::min( AccDesired, fAccThreshold ); - } - else { - // a train keeps its desired speed until the lower edge of the stopping window (a desired - // speed of 0 here asks for hard braking whatever the distance left), aims at the middle - // of the window, and asks only for what that takes - auto const stoppingroom { std::max( 0.5, ActualProximityDist - stopping_margin() ) }; - AccDesired = ( - BrakeSystem == TBrakeSystem::Pneumatic ? - // cast iron blocks grip harder as the train comes to a stand - shaped_braking_demand( - vel, VelNext, stoppingroom, fAccGravity, - mvOccupied->Vmax, fBrake_a0, fBrake_a1, BrakeAccTableSize ) : - ( VelNext * VelNext - vel * vel ) / ( 25.92 * stoppingroom ) ); - if( ( fAccGravity < -0.025 ) - && ( AccDesired >= fAccGravity - 0.001 ) // no brake needed at all - && ( ActualProximityDist - uphill_stopping_distance( vel, fAccGravity ) > stopping_margin() ) ) { - // uphill the gradient alone would bring the train to a stand short of the - // middle of the stopping window; keep it rolling at the present speed until that changes, - // but no faster than the gradient alone can take off by the middle of the window - AccDesired = std::min( 0.0, AccPreferred ); - VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - stopping_margin(), fAccGravity ) ); - } - } - } - } - else { - // for cars (and others) coast at low speed until we hit min proximity range - VelDesired = min_speed( VelDesired, 5.0 ); - } - } - } - else { - // outside of max safe range - AccDesired = AccPreferred; - if( vel > min_speed( ActualProximityDist > 10.0 ? 10.0 : 5.0, VelDesired ) ) { - // allow to coast at reasonably low speed - auto const brakingdistance { fBrakeDist * braking_distance_multiplier( VelNext ) }; - auto const slowdowndistance { ( - mvOccupied->CategoryFlag == 2 ? // cars can stop on a dime, for bigger vehicles we enforce some minimal braking distance - brakingdistance : - std::max( - (OrderCurrentGet() & Connect) == 0 ? 100.0 : 25.0, - brakingdistance ) ) }; - if( brakingdistance + std::max(slowdowndistance, fMaxProximityDist) >= ActualProximityDist - fMaxProximityDist ) { - // don't slow down prematurely; as long as we have room to come to a full stop at a safe distance, we're good - // ensure some minimal coasting speed, otherwise a vehicle entering this zone at very low speed will be crawling forever - auto const brakingpointoffset = ( - ( VelNext == 0.0 ) && is_train() && ( OrderCurrentGet() & Obey_train ) ? - stopping_margin() : // the same stopping point as the final approach - VelNext * braking_distance_multiplier( VelNext ) ); - // a pneumatic brake acts on the state the train will be in once it has responded; while the - // train is still speeding up, plan the deceleration from there, so more is asked for at once - auto velocity { vel }; - auto distance { ActualProximityDist }; - if( ( BrakeSystem == TBrakeSystem::Pneumatic ) - && ( AbsAccS > 0.0 ) ) { - auto const horizon { brake_response_horizon( mvOccupied, BrakeSystem, AbsAccS, fBrake_a0[ 0 ] ) }; - velocity = vel + 3.6 * horizon * AbsAccS; - distance = std::max( 0.5 * ActualProximityDist, ActualProximityDist - ( vel + velocity ) * 0.5 / 3.6 * horizon ); - } - auto const brakingroom { - std::max( - distance - brakingpointoffset, - std::min( - distance, - brakingpointoffset ) ) }; - auto deceleration { ( VelNext * VelNext - velocity * velocity ) / ( 25.92 * brakingroom + 0.1 ) }; - if( ( BrakeSystem == TBrakeSystem::Pneumatic ) && ( velocity > VelNext ) ) { - // follow the shape of the consist brake force over speed rather than assume a constant - // deceleration, over the distance left once the brake has had time to fill (while the - // train is still speeding up, the prediction above has taken that off already) - auto room { brakingroom }; - if( ( AbsAccS <= 0.0 ) - && ( BrakeCtrlPosition <= 0.0 ) ) { // only while the brake is still to be applied: once it acts, the room it needs to respond is behind - // making for a passenger stop only the time the brake takes to fill: the look-ahead the horizon - // keeps as its floor was set for the stops at a signal, and a vehicle that brakes with its - // independent brake, which leaves the train brake handle where it is, kept braking earlier - // and earlier the whole way in, to crawl the last tens of metres to the stop point - auto const brakea0 { bStopTargetIsPassengerStop ? 1.0 : fBrake_a0[ 0 ] }; - room = std::max( - 0.5 * brakingroom, - brakingroom - vel / 3.6 * brake_response_horizon( mvOccupied, BrakeSystem, 1.0, brakea0 ) ); - } - deceleration = shaped_braking_demand( - velocity, VelNext, room + 0.1 / 25.92, fAccGravity, - mvOccupied->Vmax, fBrake_a0, fBrake_a1, BrakeAccTableSize ); - } - AccDesired = std::min( AccDesired, deceleration ); // najpierw hamuje mocniej, potem zluzuje - if( vel > VelNext ) { - if( deceleration < fAccGravity - 0.001 ) { - // no power while still above the speed being braked for - AccDesired = std::min( AccDesired, EU07_AI_NOACCELERATION ); - } - else if( ( fAccGravity < -0.025 ) - && ( ( OrderCurrentGet() & Obey_train ) != 0 ) - && ( ActualProximityDist - uphill_stopping_distance( vel, fAccGravity ) > brakingpointoffset ) ) { - // uphill the gradient alone slows the train down more than it is asked to; - // keep it rolling at the present speed until that changes - AccDesired = std::min( 0.0, AccPreferred ); - VelDesired = min_speed( VelDesired, uphill_coasting_speed( ActualProximityDist - brakingpointoffset, fAccGravity ) ); - } - } - } - } - } + adjust_desired_speed_for_braking_curve( vel ); AccDesired = std::min( AccDesired, AccPreferred ); } else { @@ -7918,11 +8043,8 @@ TController::adjust_desired_speed_for_current_speed() { -0.05 + fAccThreshold, std::max( EU07_AI_NOACCELERATION, AccPreferred ) ) ); // HACK: for cargo trains with high braking threshold ensure we cross that threshold - if( IsCargoTrain - && fBrake_a0[0] > 0.2 - && speedestimate > holdlimit ) { - AccDesired -= std::clamp( fBrake_a0[ 0 ] - 0.2, 0.0, 0.15 ); - } + auto const crossthreshold { IsCargoTrain && fBrake_a0[ 0 ] > 0.2 && speedestimate > holdlimit }; + AccDesired -= ( crossthreshold ? std::clamp( fBrake_a0[ 0 ] - 0.2, 0.0, 0.15 ) : 0.0 ); } // final tweaks if( vel > EU07_AI_NOMOVEMENT ) { @@ -8153,6 +8275,8 @@ void TController::control_motor_connectors() { void TController::control_tractive_force() { + control_uphill_start(); + auto const velocity { DirectionalVel() }; // jeśli przyspieszenie pojazdu jest mniejsze niż żądane oraz... if( AccDesired > EU07_AI_NOACCELERATION // don't add power if not asked for actual speed-up @@ -8200,6 +8324,64 @@ bool TController::is_too_fast_uphill() const { return ( VelNext == 0.0 && ActualProximityDist <= fMaxProximityDist && AbsAccS > AccDesired + 0.05 ); } +// starting uphill a driver of a heavy train keeps the train brake applied, lets the locomotive's own brake off (the +// independent brake, and its share of the train brake with the releaser), applies the power, and releases the train +// brake only once the power holds the train. releasing everything first lets the train roll back before the power is +// there, and holding the train on the locomotive brake is no way out where that brake cuts the power (asynchronous +// drives, the control pressure switch) +void TController::control_uphill_start() { + + auto const velocity { DirectionalVel() }; + if( auto const uphill { + ( BrakeSystem == TBrakeSystem::Pneumatic ) + && is_train() + && ( false == is_emu() ) && ( false == is_dmu() ) // a multiple unit has no locomotive to hold a train behind it + && ( fAccGravity < EU07_AI_UPHILLGRAVITY ) }; + false == uphill ) { + bUphillStart = false; + return; + } + if( false == bUphillStart ) { + if( ( std::abs( velocity ) < EU07_AI_NOMOVEMENT ) + && ( AccDesired > EU07_AI_NOACCELERATION ) + && ( VelDesired > 0.0 ) + && ( BrakeCtrlPosition > 0.0 ) ) { // only with the train brake still applied to hold the train + bUphillStart = true; + fUphillStartTime = ElapsedTime; + } + else { + return; + } + } + if( AccDesired <= EU07_AI_NOACCELERATION ) { + // no longer to start: the standing rules take over + bUphillStart = false; + return; + } + if( velocity < -0.5 ) { + // rolling back all the same: the rules for a train slipping back take over and apply the brakes + bUphillStart = false; + return; + } + if( ( mvOccupied->LocalBrake != TLocalBrake::ManualBrake ) + && ( mvOccupied->LocalBrakePosA > 0.0 ) ) { + cue_action( driver_hint::independentbrakerelease ); + } + auto tractiveforce { 0.0 }; + for( auto const *vehicle { pVehicles[ end::front ] }; vehicle != nullptr; vehicle = vehicle->Next() ) { + // Ft is signed in the vehicle's own frame + tractiveforce += std::max( 0.0, vehicle->MoverParameters->Ft * ( vehicle->DirectionGet() == iDirection ? 1 : -1 ) ); + } + auto const holdingforce { fMass * -fAccGravity }; + if( ( velocity > 1.0 ) + || ( tractiveforce > 1.1 * holdingforce ) + // a locomotive that can't hold the train on its own power gets the brake off in the end all the same + || ( ElapsedTime - fUphillStartTime > 45.0 ) ) { + // the power holds the train: the train brake can be released + bUphillStart = false; + } +} + void TController::increase_tractive_force() { if( fActionTime < 0.0 ) { return; } // gdy jest nakaz poczekać z jazdą, to nie ruszać @@ -8236,6 +8418,35 @@ TController::brake_increase_margin() const { return fBrake_a1[ 0 ]; } +// a train coming to a stand with at least part of it on an up gradient: a long train brake released now cannot be +// applied again before the train stops and starts to roll back, so the train brake is not released any further, and the +// locomotive brake, which acts at once, helps to hold the train +bool +TController::uphill_stop_hold() const { + + return ( + ( BrakeSystem == TBrakeSystem::Pneumatic ) && is_train() && ( ( OrderCurrentGet() & Obey_train ) != 0 ) + && ( VelNext == 0.0 ) + && ( ActualProximityDist <= fMaxProximityDist ) + && ( fAccGravity < EU07_AI_UPHILLGRAVITY ) + && ( std::abs( DirectionalVel() ) < 10.0 ) + // not while the train is to be driven on + && ( AccDesired <= 0.0 ) ); +} + +// uphill with the train brake applied, the gradient brings a slow train to a stand sooner than the brake of the consist +// can be released: letting the train roll on (or pulling up) at this speed only releases the brake for nothing, and the +// train stands with the brake on its way off instead +bool +TController::uphill_brake_committed( double const Velocity ) const { + + return ( + ( BrakeSystem == TBrakeSystem::Pneumatic ) + && ( BrakeCtrlPosition > 0.0 ) + && ( fAccGravity < EU07_AI_UPHILLGRAVITY ) + && ( Velocity / 3.6 / -fAccGravity < brake_response_horizon( mvOccupied, BrakeSystem, -1.0, fBrake_a0[ 0 ] ) ) ); +} + void TController::control_braking_force() { // don't touch the brakes when compressing buffers during coupling/uncoupling @@ -8300,7 +8511,7 @@ void TController::control_braking_force() { else { // a stara wersja w miarę dobrze działa na składy wagonowe if( (accdesiredresultant < fAccGravity - 0.1 && AbsAccS > accdesiredresultant + brake_increase_margin() // regular braking - || fAccGravity < -0.05 && velocity < -0.1) && // also brake if uphill and slipping back + || fAccGravity < -0.05 && velocity < -0.1 && false == bUphillStart) && // also brake if uphill and slipping back (fBrakeTime < 0.0 // the size of the brake demand decides whether to skip the reaction time, so the brake-only part // (on a descent a heavy train needs its brake built up at once, the gravity does not help it slow) @@ -8335,6 +8546,17 @@ void TController::control_braking_force() { cue_action(driver_hint::brakingforcedecrease, (mvOccupied->BrakeDelayFlag > bdelay_G ? mvOccupied->BrakeDelay[0] : mvOccupied->BrakeDelay[2]) / 3.0 * 0.5); // Ra: tymczasowo, bo przeżyna S1 } + // uphill, the locomotive brake acts at once while the train brake of a long train takes many seconds to apply: + // put it on as the train comes to a stand, and at once if the train has started to roll back + if( ( mvOccupied->LocalBrake != TLocalBrake::ManualBrake ) + && ( mvOccupied->LocalBrakePosA < 1.0 ) + && ( ( uphill_stop_hold() && ( std::abs( velocity ) < 3.0 ) + // a train that has slowed down short of where it is to stop and is to pull up further does not get it + && ( VelDesired <= std::abs( velocity ) + 0.5 ) + && ( ActualProximityDist - uphill_stopping_distance( std::abs( velocity ), fAccGravity ) <= stopping_margin() ) ) + || ( ( BrakeSystem == TBrakeSystem::Pneumatic ) && ( fAccGravity < EU07_AI_UPHILLGRAVITY ) && ( velocity < -0.1 ) && ( AccDesired <= 0.0 ) ) ) ) { + cue_action( driver_hint::independentbrakeapply ); + } // stop-gap measure to ensure cars actually brake to stop even when above calculactions go awry // instead of releasing the brakes and creeping into obstacle at 1-2 km/h if( is_car() && VelDesired == 0.0 && velocity > VelDesired && ActualProximityDist <= fMinProximityDist && mvOccupied->LocalBrakePosA < 0.01 ) { @@ -8405,7 +8627,10 @@ void TController::control_releaser() { // this rule is for starting off, so only below 1 km/h: at speed, just after an application, it would vent // the control reservoir of a locomotive that may have to brake again before the pipe has refilled it if( mvOccupied->BrakePress > 0.4 - && mvOccupied->Hamulec->GetCRP() > 4.9 + && ( mvOccupied->Hamulec->GetCRP() > 4.9 + // starting uphill the train brake stays applied on purpose, and the locomotive's own share of it has to go + // for the power to come on (asynchronous drives and the pressure switch cut the power while it is applied) + || bUphillStart ) && mvOccupied->Vel < 1.0 ) { actuate = true; } diff --git a/vehicle/Driver.h b/vehicle/Driver.h index 38b4c9e28..512d4b8cf 100644 --- a/vehicle/Driver.h +++ b/vehicle/Driver.h @@ -24,6 +24,7 @@ auto const EU07_AI_NOACCELERATION = -0.05; auto const EU07_AI_BRAKINGTESTACCELERATION = -0.06; auto const EU07_AI_NOMOVEMENT = 0.05; // standstill velocity threshold auto const EU07_AI_MOVEMENT = 1.0; // deliberate movement velocity threshold +auto const EU07_AI_UPHILLGRAVITY = -0.025; // [m/s2] about 2.5 per mille up: the gradient that rolls a standing train back auto const EU07_AI_SPEEDLIMITEXTENDSBEYONDSCANRANGE = 10000.0; enum TOrders @@ -312,6 +313,9 @@ private: return mvOccupied->Vel * sign( iDirection * mvOccupied->V ); } double brake_increase_margin() const; + bool uphill_stop_hold() const; + bool uphill_brake_committed( double const Velocity ) const; + void control_uphill_start(); std::pair train_proximity_margins( bool const Passengerstop ) const; void update_timers( double const dt ); @@ -323,6 +327,7 @@ private: void scan_obstacles( double const Range ); void control_wheelslip(); void control_pantographs(); + void control_pantographs_setup( int const Setup ); void control_horns( double const Timedelta ); void control_security_system( double const Timedelta ); void control_handles(); @@ -347,6 +352,11 @@ private: void pick_optimal_speed( double const Range ); void adjust_desired_speed_for_obstacles(); void adjust_desired_speed_for_limits(); + void set_velocity_for_uncoupling(); + bool increase_train_brake(); + void hold_train_coming_to_stand_uphill(); + void adjust_desired_speed_for_final_approach( double const Vel ); + void adjust_desired_speed_for_braking_curve( double const Vel ); void adjust_desired_speed_for_target_speed( double const Range ); void adjust_desired_speed_for_current_speed(); void adjust_desired_speed_for_braking_test(); @@ -408,6 +418,8 @@ private: double fShortfall = 0.0; // how far the train fell short of the braking demand at the last check [m/s2] double fShortfallTime = 0.0; // when that was checked int iShortfallGrowth = 0; // how many checks in a row the shortfall has grown + bool bUphillStart = false; // starting uphill: the train brake holds the train until the power does + double fUphillStartTime = 0.0; // when the uphill start began double fAccDesiredGravity = 0.0; // część AccDesired odjęta na spadku jako kompensacja pochylenia; AbsAccS zawiera ją już sam double VelforDriver = -1.0; // prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości szlaku?) double VelSignal = 0.0; // ograniczenie prędkości z kompilacji znaków i sygnałów // normalnie na początku ma stać, no chyba że jedzie diff --git a/vehicle/DynObj.cpp b/vehicle/DynObj.cpp index 2da371e86..6499772d5 100644 --- a/vehicle/DynObj.cpp +++ b/vehicle/DynObj.cpp @@ -15,6 +15,8 @@ http://mozilla.org/MPL/2.0/. #include "stdafx.h" #include "vehicle/DynObj.h" +#include "vehicle/lightsprogrammer.h" + #include "simulation/simulation.h" #include "rendering/lightarray.h" #include "vehicle/Camera.h" @@ -29,6 +31,7 @@ http://mozilla.org/MPL/2.0/. #include "audio/sound.h" #include "model/MdlMngr.h" #include "model/Model3d.h" +#include "vehicle/doorwings.h" #include "rendering/renderer.h" #include "application/uitranscripts.h" #include "input/messaging.h" @@ -584,20 +587,52 @@ void TDynamicObject::update_slottedlevers() { } } +namespace { + +// the position of the door the animated wing belongs to: its shift or angle from closed +float door_position( TMoverParameters const &Mover, TAnim const *Animation ) { + + return Mover.Doors.instances[ ( + door_wings::on_right_side( Animation->iNumber ) ? + side::right : + side::left ) ].position; +} + +// the wing in the main model, and its namesake in the low poly interior; either can be missing +std::array wing_parts( TAnim const *Animation ) { + + return { Animation->smAnimated, Animation->smInterior }; +} + +// folding door: the smaller wing turns, the larger wing (its child) the other way, the step (child of that) under it +void fold_wing( TSubModel *Wing, door_wings::fold_angles const &Angles ) { + + if( Wing == nullptr ) { return; } + // skrzydło mniejsze + Wing->SetRotate( float3( 0, 0, 1 ), Angles.smaller ); + // skrzydło większe + auto *larger { Wing->ChildGet() }; + if( larger == nullptr ) { return; } + larger->SetRotate( float3( 0, 0, 1 ), Angles.larger ); + // podnóżek? + auto *step { larger->ChildGet() }; + if( step == nullptr ) { return; } + step->SetRotate( float3( 0, 1, 0 ), Angles.step ); +} + +} // namespace + // animacja drzwi - przesuw void TDynamicObject::UpdateDoorTranslate(TAnim *pAnim) { + if( pAnim->smAnimated == nullptr ) { return; } - auto const &door { MoverParameters->Doors.instances[ ( - ( pAnim->iNumber & 1 ) == 0 ? - side::right : - side::left ) ] }; - - pAnim->smAnimated->SetTranslate( - glm::vec3{ - 0.0, - 0.0, - door.position } ); + auto const shift { door_wings::slide( door_position( *MoverParameters, pAnim ) ) }; + for( auto *wing : wing_parts( pAnim ) ) { + if( wing != nullptr ) { + wing->SetTranslate( shift ); + } + } }; // animacja drzwi - obrót @@ -605,14 +640,12 @@ void TDynamicObject::UpdateDoorRotate(TAnim *pAnim) { if( pAnim->smAnimated == nullptr ) { return; } - auto const &door { MoverParameters->Doors.instances[ ( - ( pAnim->iNumber & 1 ) == 0 ? - side::right : - side::left ) ] }; - - pAnim->smAnimated->SetRotate( - float3(1, 0, 0), - door.position ); + auto const angle { door_position( *MoverParameters, pAnim ) }; + for( auto *wing : wing_parts( pAnim ) ) { + if( wing != nullptr ) { + wing->SetRotate( float3( 1, 0, 0 ), angle ); + } + } }; // animacja drzwi - obrót @@ -620,31 +653,10 @@ void TDynamicObject::UpdateDoorFold(TAnim *pAnim) { if( pAnim->smAnimated == nullptr ) { return; } - auto const &door { MoverParameters->Doors.instances[ ( - ( pAnim->iNumber & 1 ) == 0 ? - side::right : - side::left ) ] }; - - // skrzydło mniejsze - pAnim->smAnimated->SetRotate( - float3(0, 0, 1), - door.position); - - // skrzydło większe - auto *sm = pAnim->smAnimated->ChildGet(); - if( sm == nullptr ) { return; } - - sm->SetRotate( - float3(0, 0, 1), - -door.position - door.position); - - // podnóżek? - sm = sm->ChildGet(); - if( sm == nullptr ) { return; } - - sm->SetRotate( - float3(0, 1, 0), - door.position); + auto const angles { door_wings::fold( door_position( *MoverParameters, pAnim ) ) }; + for( auto *wing : wing_parts( pAnim ) ) { + fold_wing( wing, angles ); + } }; // animacja drzwi - odskokprzesuw @@ -652,20 +664,12 @@ void TDynamicObject::UpdateDoorPlug(TAnim *pAnim) { if( pAnim->smAnimated == nullptr ) { return; } - auto const &door { MoverParameters->Doors.instances[ ( - ( pAnim->iNumber & 1 ) == 0 ? - side::right : - side::left ) ] }; - - pAnim->smAnimated->SetTranslate( - glm::vec3{ - std::min( - door.position * 2.f, - MoverParameters->Doors.range_out ), - 0.0, - std::max( - 0.f, - door.position - MoverParameters->Doors.range_out * 0.5f ) } ); + auto const shift { door_wings::plug( door_position( *MoverParameters, pAnim ), MoverParameters->Doors.range_out ) }; + for( auto *wing : wing_parts( pAnim ) ) { + if( wing != nullptr ) { + wing->SetTranslate( shift ); + } + } } void TDynamicObject::UpdatePant(TAnim *pAnim) @@ -1741,7 +1745,8 @@ TDynamicObject::couple( int const Side ) { if( false == TestFlag( MoverParameters->Couplers[ Side ].CouplingFlag, coupling::control ) ) { // ukrotnionko if( (coupler.AllowedFlag & othercoupler.AllowedFlag & coupling::control) == coupling::control - && coupler.control_type == othercoupler.control_type ) { + && coupler.control_type == othercoupler.control_type + && ( MoverParameters->CompatibleCoupling( Side, *othervehicleparams, neighbour.vehicle_end, coupler.CouplingFlag | coupling::control ) & coupling::control ) != 0 ) { if( MoverParameters->Attach( Side, neighbour.vehicle_end, othervehicleparams, @@ -2445,6 +2450,8 @@ TDynamicObject::Init(std::string Name, // nazwa pojazdu, np. "EU07-424" for( auto const &nameprefix : nameprefixes ) { init_sections( mdLowPolyInt, nameprefix, MoverParameters->CompartmentLights.start_type == start_t::manual ); } + // the inside of the door wings, if the interior has them + init_interior_doors(); } // destination sign if( mdModel ) { @@ -2589,6 +2596,26 @@ TDynamicObject::init_sections( TModel3d const *Model, std::string const &Namepre return sectioncount; } +// a door wing of the main model is seen from the outside, lit as the exterior. its namesake in the low poly interior, +// if the model has one, follows its moves and is lit with the interior, by its compartment section if it's in one +void +TDynamicObject::init_interior_doors() { + + if( mdLowPolyInt == nullptr ) { return; } + + for( auto &animation : pAnimations ) { + // the door animation is only set up for a wing found in the main model + if( false == door_wings::is_wing( animation.iFlags ) ) { continue; } + if( ( animation.yUpdate == nullptr ) || ( animation.smAnimated == nullptr ) ) { continue; } + + auto *interiorwing { mdLowPolyInt->GetFromName( animation.smAnimated->pName ) }; + if( ( interiorwing == nullptr ) || ( interiorwing == animation.smAnimated ) ) { continue; } + + interiorwing->WillBeAnimated(); + animation.smInterior = interiorwing; + } +} + bool TDynamicObject::init_destination( TModel3d *Model ) { @@ -7254,7 +7281,8 @@ void TDynamicObject::RadioStop() if( Mechanik ) { // o ile ktoś go prowadzi if( MoverParameters->SecuritySystem.radiostop_available() - && MoverParameters->Radio ) { + && MoverParameters->Radio + && MoverParameters->RadioFuse ) { // jeśli pojazd ma RadioStop i jest on aktywny // HACK cast until math types unification glm::dvec3 pos = static_cast(vPosition); @@ -7346,26 +7374,22 @@ void TDynamicObject::SetLights() { auto const isfrontcaboccupied { MoverParameters->CabOccupied * DirectionGet() >= 0 }; int const automaticmarkers { MoverParameters->CabActive == 0 && MoverParameters->InactiveCabFlag & activation::redmarkers ? light::redmarker_left + light::redmarker_right : 0 }; - int const front { ( isfrontcaboccupied ? end::front : end::rear ) }; - int const rear { 1 - front }; auto const lightpos { MoverParameters->LightsPos - 1 }; - auto const frontlights { automaticmarkers > 0 ? automaticmarkers : MoverParameters->Lights[ front ][ lightpos ] }; - auto const rearlights { automaticmarkers > 0 ? automaticmarkers : MoverParameters->Lights[ rear ][ lightpos ] }; + std::array const cablights { + automaticmarkers > 0 ? automaticmarkers : MoverParameters->Lights[ end::front ][ lightpos ], + automaticmarkers > 0 ? automaticmarkers : MoverParameters->Lights[ end::rear ][ lightpos ] }; + // the custom position keeps the lights lit at coupled ends as well + auto const ignorecouplings { MoverParameters->LightsPos == 18 }; auto *vehicle { GetFirstDynamic( MoverParameters->CabOccupied >= 0 ? end::front : end::rear, coupling::control ) }; while( vehicle != nullptr ) { // set lights on given side if there's no coupling with another vehicle, turn them off otherwise - auto const *frontvehicle{(isfrontcaboccupied ? vehicle->Prev(coupling::coupler) : vehicle->Next(coupling::coupler))}; - auto const *rearvehicle{(isfrontcaboccupied ? vehicle->Next(coupling::coupler) : vehicle->Prev(coupling::coupler))}; - - if (MoverParameters->LightsPos == 18) - { - frontvehicle = nullptr; - rearvehicle = nullptr; - } - - vehicle->RaLightsSet( - frontvehicle == nullptr ? frontlights : 0, - rearvehicle == nullptr ? rearlights : 0 ); + auto const iscoupled { [ vehicle, ignorecouplings ]( end const Side ) { + return false == ignorecouplings + && ( vehicle->MoverParameters->Couplers[ Side ].CouplingFlag & coupling::coupler ) != 0 + && vehicle->MoverParameters->Neighbours[ Side ].vehicle != nullptr; } }; + auto const lights { lights_programmer::vehicle_lights( + cablights, isfrontcaboccupied, vehicle->iDirection, { iscoupled( end::front ), iscoupled( end::rear ) } ) }; + vehicle->RaLightsSet( lights.head, lights.rear ); vehicle = isfrontcaboccupied ? vehicle->Next(coupling::control) : vehicle->Prev(coupling::control); } }; @@ -7407,9 +7431,7 @@ void TDynamicObject::RaLightsSet(int head, int rear) bool tRight = MoverParameters->iLights[vehicleend] & (light::auxiliary_right | light::headlight_right); // a tu z prawej if (Controller == Humandriver) { - int ¤tDimPos = MoverParameters->modernDimmerPosition; - auto &dimmerPositions = MoverParameters->dimPositions; - TMoverParameters::dimPosition dps = dimmerPositions[currentDimPos]; + auto const dps{MoverParameters->currentDimPosition()}; // domyślnie HighBeamLights = false; @@ -7471,9 +7493,7 @@ void TDynamicObject::SetLightDimmings() if (Controller == Humandriver) { - int ¤tDimPos = MoverParameters->modernDimmerPosition; - auto &dimmerPositions = MoverParameters->dimPositions; - TMoverParameters::dimPosition dps = dimmerPositions[currentDimPos]; + auto const dps{MoverParameters->currentDimPosition()}; // domyślnie HighBeamLights = false; diff --git a/vehicle/DynObj.h b/vehicle/DynObj.h index 9df2d93b6..bfd477c4f 100644 --- a/vehicle/DynObj.h +++ b/vehicle/DynObj.h @@ -157,6 +157,9 @@ public: float fMaxDist; // do jakiej odległości wykonywana jest animacja NOTE: square of actual distance float fSpeed; // parametr szybkości animacji int iNumber; // numer kolejny obiektu + // door wings only: the submodel of the same name in the low poly interior, if it has one, posed along with + // smAnimated, so the inside of the door can be part of the interior and lit with it + TSubModel *smInterior { nullptr }; TUpdate yUpdate; // metoda TDynamicObject aktualizująca animację /* @@ -704,6 +707,8 @@ private: float Load, std::string LoadType, bool Reversed, std::string); int init_sections( TModel3d const *Model, std::string const &Nameprefix, bool const Overrideselfillum ); bool init_destination( TModel3d *Model ); + // pairs the animated door wings with their namesakes in the low poly interior + void init_interior_doors(); void create_controller( std::string const Type, bool const Trainset ); void AttachNext(TDynamicObject *Object, int iType = 1); bool UpdateForce(double dt); diff --git a/vehicle/Gauge.cpp b/vehicle/Gauge.cpp index e952da6fa..dca3781ae 100644 --- a/vehicle/Gauge.cpp +++ b/vehicle/Gauge.cpp @@ -16,6 +16,7 @@ http://mozilla.org/MPL/2.0/. #include "stdafx.h" #include "vehicle/Gauge.h" #include "vehicle/gaugepositions.h" +#include "vehicle/gaugeduplicates.h" #include "utilities/parser.h" #include "model/Model3d.h" #include "vehicle/DynObj.h" @@ -109,6 +110,14 @@ void TGauge::Load( cParser &Parser, TDynamicObject const *Owner, double const mu endvalue = -1; bool interpolatescale { false }; + // the control as defined so far in this cab, which a definition marked as its duplicate adds a copy to + // rather than replacing it (eu07/maszyna#527) + std::optional original; + if( gauge_duplicates::adds_copy( true, m_sourcemodel, Owner->mdKabina, Owner->mdLowPolyInt ) ) { + original = *this; + } + scratch_data scratchpad; + Parser.getTokens(); if( Parser.peek() != "{" ) { // old fixed size config @@ -150,7 +159,6 @@ void TGauge::Load( cParser &Parser, TDynamicObject const *Owner, double const mu } // new, variable length section { - scratch_data scratchpad; while( true == Load_mapping( Parser, scratchpad ) ) { // all work done by while() } @@ -198,17 +206,20 @@ void TGauge::Load( cParser &Parser, TDynamicObject const *Owner, double const mu endscale *= static_cast(mul); } TSubModel *submodel { nullptr }; + m_sourcemodel = nullptr; std::array sources { Owner->mdKabina, Owner->mdLowPolyInt }; for( auto const *source : sources ) { if( source != nullptr && ( submodel = source->GetFromName( submodelname ) ) != nullptr ) { // got what we wanted, bail out + m_sourcemodel = source; break; } // there's a possibility the default submodel was named with _off suffix if( source != nullptr && ( submodel = source->GetFromName( submodelname + "_off" ) ) != nullptr ) { // got what we wanted, bail out + m_sourcemodel = source; break; } } @@ -238,6 +249,14 @@ void TGauge::Load( cParser &Parser, TDynamicObject const *Owner, double const mu Init( submodel, submodelon, type, scale, offset, friction, 0, endvalue, endscale, interpolatescale ); + if( scratchpad.duplicate && original ) { + // a duplicate submodel of the control already defined: the control stays as it was, with one more copy + // animated along with it. the duplicate's own sounds, if any, are left out so the control isn't heard twice + auto duplicate { MirrorCopy() }; + *this = std::move( *original ); + m_mirrors.emplace_back( std::move( duplicate ) ); + } + // return md2 != nullptr; // true, gdy podany model zewnętrzny, a w kabinie nie było }; @@ -248,7 +267,12 @@ TGauge::Load_mapping( cParser &Input, TGauge::scratch_data &Scratchpad ) { auto const key { Input.getToken( true, "\n\r\t ,;" ) }; if( true == key.empty() || key == "}" ) { return false; } // if not block end then the key is followed by assigned value or sub-block - if( key == "type:" ) { + if( key == "duplicate:" ) { + // the definition is another submodel of the control defined before it, rather than its replacement + auto const duplicate { Input.getToken( true, "\n\r\t ,;" ) }; + Scratchpad.duplicate = gauge_duplicates::is_duplicate( duplicate ); + } + else if( key == "type:" ) { using enum TGaugeType; auto const gaugetype { Input.getToken( true, "\n\r\t ,;" ) }; m_type = gaugetype == "push" ? push : @@ -257,6 +281,7 @@ TGauge::Load_mapping( cParser &Input, TGauge::scratch_data &Scratchpad ) { gaugetype == "delayed" ? push_delayed : gaugetype == "pushtoggle" ? pushtoggle : toggle; // "toggle" and default + m_typedeclared = true; } else if( key == "soundinc:" ) { m_soundfxincrease.deserialize( Input, sound_type::single ); @@ -402,6 +427,22 @@ void TGauge::Update( bool const Power ) { else { m_soundfxoff.play(); } } m_state = state; + UpdateVisibility(); + // update submodel animations + UpdateAnimation( SubModel ); + UpdateAnimation( SubModelOn ); + // the copies follow the control's value and state, each with its own animation + for( auto &mirror : m_mirrors ) { + mirror.m_value = m_value; + mirror.m_targetvalue = m_targetvalue; + mirror.m_state = m_state; + mirror.UpdateVisibility(); + mirror.UpdateAnimation( mirror.SubModel ); + mirror.UpdateAnimation( mirror.SubModelOn ); + } +}; + +void TGauge::UpdateVisibility() const { // toggle submodel visibility only if the active state submodel is present, // keep the default model always visible otherwise if( SubModelOn != nullptr ) { @@ -410,10 +451,26 @@ void TGauge::Update( bool const Power ) { SubModel->iVisible = !m_state; } } - // update submodel animations - UpdateAnimation( SubModel ); - UpdateAnimation( SubModelOn ); -}; +} + +TGauge TGauge::MirrorCopy() const { + + TGauge mirror; + mirror.SubModel = SubModel; + mirror.SubModelOn = SubModelOn; + mirror.m_animation = m_animation; + mirror.m_friction = m_friction; + mirror.m_targetvalue = m_targetvalue; + mirror.m_value = m_value; + mirror.m_offset = m_offset; + mirror.m_scale = m_scale; + mirror.m_endscale = m_endscale; + mirror.m_endvalue = m_endvalue; + mirror.m_interpolatescale = m_interpolatescale; + mirror.m_state = m_state; + mirror.m_sourcemodel = m_sourcemodel; + return mirror; +} void TGauge::AssignFloat(float *fValue) { diff --git a/vehicle/Gauge.h b/vehicle/Gauge.h index b79f8de8d..9612baefd 100644 --- a/vehicle/Gauge.h +++ b/vehicle/Gauge.h @@ -56,9 +56,15 @@ public: void AssignBool(bool *bValue); void UpdateValue(); void AssignState( bool const *State ); + // copies of the control animated along with it, from its definitions marked duplicate: yes + std::vector const &mirrors() const { + return m_mirrors; } // returns offset of submodel associated with the button from the model centre glm::vec3 model_offset() const; TGaugeType type() const; + // whether the definition of the control declared its type, rather than left it at the default + bool type_declared() const { + return m_typedeclared; } inline bool is_push() const { return ( static_cast( type() ) & static_cast( TGaugeType::push ) ) != 0; } @@ -78,6 +84,7 @@ private: // types struct scratch_data { std::optional< std::array > soundproofing; + bool duplicate { false }; // the definition is a duplicate submodel of the control defined before std::vector scaletable; // as read, in the units of the config }; // methods @@ -90,10 +97,17 @@ private: GetScaledValue() const; void UpdateAnimation( TSubModel *Submodel ) const; + // shows the default or the active state submodel as the state says + void + UpdateVisibility() const; + // the copy of this control's submodels and animation, without its sounds and bindings + TGauge + MirrorCopy() const; // members TGaugeAnimation m_animation { TGaugeAnimation::gt_Unknown }; // typ ruchu TGaugeType m_type { TGaugeType::toggle }; // switch type + bool m_typedeclared { false }; // the type was given with type: in the definition float m_friction { 0.f }; // hamowanie przy zliżaniu się do zadanej wartości float m_targetvalue { 0.f }; // wartość docelowa float m_value { 0.f }; // wartość obecna @@ -104,7 +118,7 @@ private: bool m_interpolatescale { false }; std::vector m_scaletable; // optional non-uniform scale, sorted by value; replaces scale and offset - char m_datatype; // typ zmiennej parametru: f-float, d-double, i-int + char m_datatype { '\0' }; // typ zmiennej parametru: f-float, d-double, i-int, b-bool; none until one is assigned union { // wskaźnik na parametr pokazywany przez animację float *fData; @@ -121,6 +135,8 @@ private: sound_source m_soundfxincrease { m_soundtemplate }; // sound associated with increasing control's value sound_source m_soundfxdecrease { m_soundtemplate }; // sound associated with decreasing control's value std::map m_soundfxvalues; // sounds associated with specific values + TModel3d const *m_sourcemodel { nullptr }; // the 3d model the submodel was found in by Load() + std::vector m_mirrors; // duplicate submodels of the control (duplicate: yes), animated along with it }; diff --git a/vehicle/Train.cpp b/vehicle/Train.cpp index a89135961..fb42c85fa 100644 --- a/vehicle/Train.cpp +++ b/vehicle/Train.cpp @@ -16,6 +16,7 @@ http://mozilla.org/MPL/2.0/. #include "vehicle/Train.h" #include "vehicle/horn.h" #include "vehicle/linebreaker.h" +#include "vehicle/holdcoillever.h" #include "vehicle/mainctrlact.h" #include "utilities/Globals.h" @@ -61,6 +62,11 @@ void control_mapper::insert(TGauge const &Gauge, std::string const &Label) { m_controlnames.try_emplace(Gauge.SubModelOn, Label); } + // the duplicate submodels of a control (duplicate: yes) work the control as well (eu07/maszyna#527) + for (auto const &mirror : Gauge.mirrors()) + { + insert(mirror, Label); + } m_names.emplace(Label); } @@ -339,6 +345,12 @@ TTrain::commandhandler_map const TTrain::m_commandhandlers = { {user_command::linebreakertoggle, &TTrain::OnCommand_linebreakertoggle}, {user_command::linebreakeropen, &TTrain::OnCommand_linebreakeropen}, {user_command::linebreakerclose, &TTrain::OnCommand_linebreakerclose}, + {user_command::linebreakertoggleb, &TTrain::OnCommand_linebreakertoggleremote}, + {user_command::linebreakeropenb, &TTrain::OnCommand_linebreakeropenremote}, + {user_command::linebreakercloseb, &TTrain::OnCommand_linebreakercloseremote}, + {user_command::linebreakertogglec, &TTrain::OnCommand_linebreakertoggleremote}, + {user_command::linebreakeropenc, &TTrain::OnCommand_linebreakeropenremote}, + {user_command::linebreakerclosec, &TTrain::OnCommand_linebreakercloseremote}, {user_command::fuelpumptoggle, &TTrain::OnCommand_fuelpumptoggle}, {user_command::fuelpumpenable, &TTrain::OnCommand_fuelpumpenable}, {user_command::fuelpumpdisable, &TTrain::OnCommand_fuelpumpdisable}, @@ -487,6 +499,9 @@ TTrain::commandhandler_map const TTrain::m_commandhandlers = { {user_command::radiovolumeincrease, &TTrain::OnCommand_radiovolumeincrease}, {user_command::radiovolumedecrease, &TTrain::OnCommand_radiovolumedecrease}, {user_command::radiovolumeset, &TTrain::OnCommand_radiovolumeset}, + {user_command::radiofusetoggle, &TTrain::OnCommand_radiofusetoggle}, + {user_command::radiofuseenable, &TTrain::OnCommand_radiofuseenable}, + {user_command::radiofusedisable, &TTrain::OnCommand_radiofusedisable}, {user_command::cabchangeforward, &TTrain::OnCommand_cabchangeforward}, {user_command::cabchangebackward, &TTrain::OnCommand_cabchangebackward}, {user_command::generictoggle0, &TTrain::OnCommand_generictoggle}, @@ -718,7 +733,7 @@ std::shared_ptr TTrain::GetTrainState(dictionary_source const dict->insert("pant_compressor", mvPantographUnit->PantCompFlag); dict->insert("lights_front", mvOccupied->iLights[end::front]); dict->insert("lights_rear", mvOccupied->iLights[end::rear]); - dict->insert("off_from_dimmer", mvOccupied->dimPositions[mvOccupied->modernDimmerPosition].isOff); + dict->insert("off_from_dimmer", mvOccupied->currentDimPosition().isOff); dict->insert("lights_compartments", mvOccupied->CompartmentLights.is_active || mvOccupied->CompartmentLights.is_disabled); if (Dynamic()->Mechanik) { @@ -787,6 +802,7 @@ std::shared_ptr TTrain::GetTrainState(dictionary_source const } } dict->insert("radio", mvOccupied->Radio); + dict->insert("radio_fuse", mvOccupied->RadioFuse); dict->insert("radio_channel", RadioChannel()); dict->insert("radio_volume", m_radiovolume); dict->insert("door_lock", mvOccupied->Doors.lock_enabled); @@ -2237,7 +2253,9 @@ void TTrain::OnCommand_wheelspinbrakeactivate(TTrain *Train, command_data const // visual feedback Train->ggAntiSlipButton.UpdateValue(1.0, Train->dsbPneumaticSwitch); - if (Train->mvOccupied->BrakeHandle == TBrakeHandle::St113 && Train->mvControlled->EpFuse == true) + // the EP fuse is the cab car's (Ctrl+Z switches mvOccupied's), checked by SwitchEPBrake with the rest of + // the control's supply + if (Train->mvOccupied->BrakeHandle == TBrakeHandle::St113) { Train->mvOccupied->SwitchEPBrake(1); } @@ -3648,6 +3666,15 @@ void TTrain::OnCommand_pantographcompressoractivate(TTrain *Train, command_data } } +namespace +{ +// whether the cab's main_off_bt is the bistable lever of the line breaker's hold coil (eu07/maszyna#364) +bool is_hold_coil_lever(TGauge const &Button) +{ + return Button.SubModel != nullptr && hold_coil_lever::is_bistable(Button.type_declared(), Button.type() == TGaugeType::toggle); +} +} // namespace + void TTrain::OnCommand_linebreakertoggle(TTrain *Train, command_data const &Command) { @@ -3661,6 +3688,11 @@ void TTrain::OnCommand_linebreakertoggle(TTrain *Train, command_data const &Comm { case linebreaker::toggle::close: // ...to close the circuit + if (is_hold_coil_lever(Train->ggMainOffButton) && hold_coil_lever::cuts_off(Train->ggMainOffButton.GetDesiredValue())) + { + // the one key works both controls: the hold coil lever goes back on first, or the line breaker couldn't close + Train->ggMainOffButton.UpdateValue(0.0, Train->dsbSwitch); + } // NOTE: bit of a dirty shortcut here OnCommand_linebreakerclose(Train, Command); break; @@ -3702,7 +3734,18 @@ void TTrain::OnCommand_linebreakeropen(TTrain *Train, command_data const &Comman if (Command.action == GLFW_PRESS) { // visual feedback - if (Train->ggMainOffButton.SubModel != nullptr) + if (is_hold_coil_lever(Train->ggMainOffButton)) + { + // the bistable lever goes over to its other position and stays there + auto const position{hold_coil_lever::operated(Train->ggMainOffButton.GetDesiredValue())}; + Train->ggMainOffButton.UpdateValue(position, Train->dsbSwitch); + if (false == hold_coil_lever::cuts_off(position)) + { + // the hold coil is fed again, which by itself doesn't close the line breaker + return; + } + } + else if (Train->ggMainOffButton.SubModel != nullptr) { Train->ggMainOffButton.UpdateValue(1.0, Train->dsbSwitch); } @@ -3726,9 +3769,21 @@ void TTrain::OnCommand_linebreakeropen(TTrain *Train, command_data const &Comman return; } // already in the desired state - if (true == Train->mvControlled->MainSwitch(false)) + if (true == Train->mvControlled->MainSwitch(false, Train->mvControlled->MainSwitchRange())) { Train->m_linebreakerstate = 0; + if (Train->mvControlled->MainSwitchRange() != range_t::local) + { + // the engines of the vehicles in multiple stopped along: their two-state switches go off too, left on + // they'd start them again after the delay + for (auto &controls : Train->m_remotelinebreakers) + { + if (controls.main_switch.SubModel != nullptr && controls.main_switch.type() == TGaugeType::toggle) + { + controls.main_switch.UpdateValue(0.0); + } + } + } } } else if (Command.action == GLFW_RELEASE) @@ -3740,8 +3795,9 @@ void TTrain::OnCommand_linebreakeropen(TTrain *Train, command_data const &Comman { Train->ggMainOnButton.UpdateValue(0.0, Train->dsbSwitch); } - if (Train->ggMainOffButton.SubModel != nullptr) + if (Train->ggMainOffButton.SubModel != nullptr && false == is_hold_coil_lever(Train->ggMainOffButton)) { + // (the bistable hold coil lever stays where it was put) Train->ggMainOffButton.UpdateValue(0.0, Train->dsbSwitch); } // and the two-state switch too, for good measure @@ -3801,13 +3857,157 @@ void TTrain::OnCommand_linebreakerclose(TTrain *Train, command_data const &Comma if (Train->m_linebreakerstate == 2 && Train->mvControlled->EngineType == TEngineType::ElectricSeriesMotor) { // try to finalize state change of the line breaker, set the state based on the outcome - Train->m_linebreakerstate = Train->mvControlled->MainSwitch(true) ? 1 : 0; + Train->m_linebreakerstate = Train->mvControlled->MainSwitch(true, Train->mvControlled->MainSwitchRange()) ? 1 : 0; } // on button release reset the closing timer Train->fMainRelayTimer = 0.0f; } } +namespace +{ + +// which of the switches of the other vehicles in multiple a command works: 0 the second vehicle's, 1 the third one's +std::size_t remote_linebreaker_index(user_command const Command) +{ + using enum user_command; + return (Command == linebreakertogglec || Command == linebreakeropenc || Command == linebreakerclosec) ? 1 : 0; +} + +// the impulse switches of another vehicle's line breaker spring back when let go, whichever way they were pressed +void release_remote_linebreaker(TTrain::remote_linebreaker &Controls, std::optional &Sound) +{ + if (Controls.on_button.SubModel != nullptr) + { + Controls.on_button.UpdateValue(0.0, Sound); + } + if (Controls.off_button.SubModel != nullptr) + { + Controls.off_button.UpdateValue(0.0, Sound); + } + if (Controls.main_switch.SubModel != nullptr && Controls.main_switch.type() != TGaugeType::toggle) + { + Controls.main_switch.UpdateValue(0.5, Sound); + } + Controls.held_without_switch = false; +} + +} // namespace + +TMoverParameters *TTrain::remote_engine(std::size_t const Index) const +{ + return engine_start::engine(*mvOccupied, *mvControlled, static_cast(Index) + 2); +} + +void TTrain::OnCommand_linebreakertoggleremote(TTrain *Train, command_data const &Command) +{ + auto const index{remote_linebreaker_index(Command.command)}; + auto &controls{Train->m_remotelinebreakers[index]}; + + if (Command.action == GLFW_PRESS) + { + // a two-state switch goes the other way than it stands, an impulse one the other way than the engine is + bool close{false}; + if (controls.main_switch.SubModel != nullptr && controls.main_switch.type() == TGaugeType::toggle) + { + close = controls.main_switch.GetDesiredValue() < 0.5; + } + else + { + auto const *engine{Train->remote_engine(index)}; + close = engine == nullptr || false == engine_start::remote_switch::is_running(*engine); + } + if (close) + { + OnCommand_linebreakercloseremote(Train, Command); + } + else + { + OnCommand_linebreakeropenremote(Train, Command); + } + } + else if (Command.action == GLFW_RELEASE) + { + if (controls.on_button.SubModel != nullptr || controls.main_switch.type() != TGaugeType::toggle) + { + // only impulse switches react to release events + release_remote_linebreaker(controls, Train->dsbSwitch); + } + controls.held_without_switch = false; + } +} + +void TTrain::OnCommand_linebreakeropenremote(TTrain *Train, command_data const &Command) +{ + auto const index{remote_linebreaker_index(Command.command)}; + auto &controls{Train->m_remotelinebreakers[index]}; + + if (Command.action == GLFW_PRESS) + { + // visual feedback + if (controls.off_button.SubModel != nullptr) + { + controls.off_button.UpdateValue(1.0, Train->dsbSwitch); + } + else if (controls.main_switch.SubModel != nullptr) + { + controls.main_switch.UpdateValue(0.0, Train->dsbSwitch); + } + controls.held_without_switch = false; + if (auto *engine{Train->remote_engine(index)}; engine != nullptr) + { + engine_start::remote_switch::open(*engine); + } + } + else if (Command.action == GLFW_RELEASE) + { + release_remote_linebreaker(controls, Train->dsbSwitch); + } +} + +void TTrain::OnCommand_linebreakercloseremote(TTrain *Train, command_data const &Command) +{ + auto const index{remote_linebreaker_index(Command.command)}; + auto &controls{Train->m_remotelinebreakers[index]}; + + if (Command.action == GLFW_PRESS) + { + // visual feedback; the line breaker closes in the train update, once the switch was held long enough + if (controls.on_button.SubModel != nullptr) + { + controls.on_button.UpdateValue(1.0, Train->dsbSwitch); + } + else if (controls.main_switch.SubModel != nullptr) + { + controls.main_switch.UpdateValue(1.0, Train->dsbSwitch); + } + else + { + // no switch in the cab, the command alone holds it + controls.held_without_switch = true; + } + } + else if (Command.action == GLFW_RELEASE) + { + release_remote_linebreaker(controls, Train->dsbSwitch); + } +} + +void TTrain::update_remote_linebreakers(double const Deltatime) +{ + for (std::size_t index = 0; index < m_remotelinebreakers.size(); ++index) + { + auto &controls{m_remotelinebreakers[index]}; + auto *engine{remote_engine(index)}; + auto const closeheld{controls.held_without_switch || (controls.main_switch.SubModel != nullptr && controls.main_switch.GetDesiredValue() > 0.95) || + (controls.on_button.SubModel != nullptr && controls.on_button.GetDesiredValue() > 0.95)}; + auto const openheld{controls.off_button.SubModel != nullptr && controls.off_button.GetDesiredValue() > 0.95}; + // as with the cab's own switch, an electric locomotive's impulse switch closes the line breaker when let go + auto const closesonrelease{engine != nullptr && controls.on_button.SubModel != nullptr && engine->EngineType == TEngineType::ElectricSeriesMotor}; + controls.state.update(engine, closeheld, openheld, Deltatime, closesonrelease); + } +} + void TTrain::OnCommand_fuelpumptoggle(TTrain *Train, command_data const &Command) { @@ -5161,6 +5361,39 @@ void TTrain::OnCommand_universalrelayreset(TTrain *Train, command_data const &Co } } +// the cab interior light set by the light preset just selected, if the preset sets one (eu07/maszyna#529). +// the cab light switch (cablight_sw:) is bound to the light state and follows it by itself +void TTrain::set_cab_light_from_lights_preset() +{ + auto const cablight{mvOccupied->LightsPresetCabLight(mvOccupied->LightsPos)}; + if (false == cablight.has_value()) + { + return; + } + auto const set{[&cablight](TCab &Cab) { + Cab.bLight = cablight->light; + Cab.bLightDim = cablight->dim; + }}; + if (false == DynamicObject->JointCabs) + { + // vehicles with separate cabs get separate lighting switch states + set(Cabine[iCabn]); + } + else + { + // joint virtual cabs share lighting switch states + for (auto &cab : Cabine) + { + set(cab); + } + } + // the dimmer switch is driven by commands only, move it along + if (ggCabLightDimButton.SubModel != nullptr) + { + ggCabLightDimButton.UpdateValue(cablight->dim ? 1.f : 0.f); + } +} + void TTrain::OnCommand_lightspresetactivatenext(TTrain *Train, command_data const &Command) { @@ -5182,6 +5415,7 @@ void TTrain::OnCommand_lightspresetactivatenext(TTrain *Train, command_data cons Train->mvOccupied->LightsPos = false == restartcycle ? Train->mvOccupied->LightsPos + 1 : 1; // wrap mode Train->Dynamic()->SetLights(); + Train->set_cab_light_from_lights_preset(); // visual feedback if (Train->ggLightsButton.SubModel != nullptr) { @@ -5219,6 +5453,7 @@ void TTrain::OnCommand_lightspresetactivateprevious(TTrain *Train, command_data Train->mvOccupied->LightsPos = false == restartcycle ? Train->mvOccupied->LightsPos - 1 : Train->mvOccupied->LightsPosNo; // wrap mode Train->Dynamic()->SetLights(); + Train->set_cab_light_from_lights_preset(); // visual feedback if (Train->ggLightsButton.SubModel != nullptr) { @@ -5905,14 +6140,9 @@ void TTrain::OnCommand_modernlightdimmerincrease(TTrain *Train, command_data con if (Command.action == GLFW_PRESS) { // update modern dimmer state - - auto &dimPos = Train->mvOccupied->modernDimmerPosition; - if (auto dimCount = Train->mvOccupied->dimPositions.size(); dimPos + 1 < dimCount) - dimPos++; - else if (Train->mvOccupied->modernDimmerCanCycle) - dimPos = 0; // return to 0 - else - return; // już na minimum i nie można cyklicznie + if (false == Train->mvOccupied->stepDimmerPosition(1)) + return; // już na maksimum i nie można cyklicznie + auto const dimPos = Train->mvOccupied->modernDimmerPosition; // update lightning // Train->Dynamic()->SetLights(); Train->Dynamic()->SetLightDimmings(); @@ -5929,18 +6159,9 @@ void TTrain::OnCommand_modernlightdimmerdecrease(TTrain *Train, command_data con if (Command.action == GLFW_PRESS) { - auto &dimPos = Train->mvOccupied->modernDimmerPosition; - auto dimCount = Train->mvOccupied->dimPositions.size(); - - if (dimCount == 0) - return; - - if (dimPos > 0) - dimPos--; - else if (Train->mvOccupied->modernDimmerCanCycle) - dimPos = static_cast(dimCount - 1); // ostatnia pozycja - else + if (false == Train->mvOccupied->stepDimmerPosition(-1)) return; // już na minimum i nie można cyklicznie + auto const dimPos = Train->mvOccupied->modernDimmerPosition; // Train->Dynamic()->SetLights(); Train->Dynamic()->SetLightDimmings(); @@ -6181,7 +6402,7 @@ void TTrain::OnCommand_headlightsdimenable(TTrain *Train, command_data const &Co Train->DynamicObject->DimHeadlights = true; */ - Train->DynamicObject->MoverParameters->modernDimmerPosition = 1; // ustawiamy modern dimmer na flage przyciemnienia + Train->DynamicObject->MoverParameters->modernDimmerPosition = Train->DynamicObject->MoverParameters->clampDimmerPosition(1); // ustawiamy modern dimmer na flage przyciemnienia Train->DynamicObject->SetLightDimmings(); } } @@ -8047,41 +8268,101 @@ void TTrain::OnCommand_radiotoggle(TTrain *Train, command_data const &Command) // NOTE: works without the switch in the 3d model too, to allow system reset after receiving radio-stop signal // only reacting to press, so the sound can loop uninterrupted - if (false == Train->mvOccupied->Radio) - { - // turn on - OnCommand_radioenable(Train, Command); - } - else - { - // turn off - OnCommand_radiodisable(Train, Command); - } + // NOTE: flips the state directly rather than through radioenable/radiodisable, so it doesn't move the radioon_sw:/radiooff_sw: buttons + Train->mvOccupied->Radio = (false == Train->mvOccupied->Radio); } void TTrain::OnCommand_radioenable(TTrain *Train, command_data const &Command) { - if (Command.action != GLFW_PRESS) - { - return; - } - - if (false == Train->mvOccupied->Radio) + if (Command.action == GLFW_PRESS) { Train->mvOccupied->Radio = true; + // visual feedback + if (Train->m_controlmapper.contains("radioon_sw:")) + { + Train->ggRadioOnButton.UpdateValue(1.0f, Train->dsbSwitch); + } + } + else if (Command.action == GLFW_RELEASE) + { + if (Train->m_controlmapper.contains("radioon_sw:")) + { + Train->ggRadioOnButton.UpdateValue(0.0f, Train->dsbSwitch); + } } } void TTrain::OnCommand_radiodisable(TTrain *Train, command_data const &Command) +{ + if (Command.action == GLFW_PRESS) + { + Train->mvOccupied->Radio = false; + // visual feedback + if (Train->m_controlmapper.contains("radiooff_sw:")) + { + Train->ggRadioOffButton.UpdateValue(1.0f, Train->dsbSwitch); + } + } + else if (Command.action == GLFW_RELEASE) + { + if (Train->m_controlmapper.contains("radiooff_sw:")) + { + Train->ggRadioOffButton.UpdateValue(0.0f, Train->dsbSwitch); + } + } +} + +// the cut-off in the radio's power supply (eu07/maszyna#438); opening it works like switching the radio off, the +// radio-stop flag included +void TTrain::OnCommand_radiofusetoggle(TTrain *Train, command_data const &Command) { if (Command.action != GLFW_PRESS) { return; } - if (Train->mvOccupied->Radio) + // NOTE: flips the state directly rather than through radiofuseenable/radiofusedisable, so it doesn't move the + // radiofuseon_sw:/radiofuseoff_sw: buttons + Train->mvOccupied->RadioFuse = (false == Train->mvOccupied->RadioFuse); +} + +void TTrain::OnCommand_radiofuseenable(TTrain *Train, command_data const &Command) +{ + if (Command.action == GLFW_PRESS) { - Train->mvOccupied->Radio = false; + Train->mvOccupied->RadioFuse = true; + // visual feedback + if (Train->m_controlmapper.contains("radiofuseon_sw:")) + { + Train->ggRadioFuseOnButton.UpdateValue(1.0f, Train->dsbSwitch); + } + } + else if (Command.action == GLFW_RELEASE) + { + if (Train->m_controlmapper.contains("radiofuseon_sw:")) + { + Train->ggRadioFuseOnButton.UpdateValue(0.0f, Train->dsbSwitch); + } + } +} + +void TTrain::OnCommand_radiofusedisable(TTrain *Train, command_data const &Command) +{ + if (Command.action == GLFW_PRESS) + { + Train->mvOccupied->RadioFuse = false; + // visual feedback + if (Train->m_controlmapper.contains("radiofuseoff_sw:")) + { + Train->ggRadioFuseOffButton.UpdateValue(1.0f, Train->dsbSwitch); + } + } + else if (Command.action == GLFW_RELEASE) + { + if (Train->m_controlmapper.contains("radiofuseoff_sw:")) + { + Train->ggRadioFuseOffButton.UpdateValue(0.0f, Train->dsbSwitch); + } } } @@ -8418,6 +8699,20 @@ bool TTrain::Update(double const Deltatime) // because the state of the line breaker isn't changed to match, we need to do it here manually m_linebreakerstate = 0; } + if (is_hold_coil_lever(ggMainOffButton) && hold_coil_lever::cuts_off(ggMainOffButton.GetDesiredValue())) + { + if (true == mvControlled->Mains) + { + // the line breaker was closed with the hold coil lever off, by the AI or through the control cable: + // put the lever back on to match, like the line breaker state above + ggMainOffButton.UpdateValue(0.0); + } + else if (m_linebreakerstate == 2) + { + // the hold coil was cut off while the closing button was held, the line breaker won't close on its release + m_linebreakerstate = 0; + } + } if ((ggMainButton.SubModel != nullptr && ggMainButton.GetDesiredValue() > 0.95) || ggMainOnButton.SubModel != nullptr && ggMainOnButton.GetDesiredValue() > 0.95 || @@ -8450,8 +8745,10 @@ bool TTrain::Update(double const Deltatime) if (m_linebreakerstate == 2 && (ggMainOnButton.SubModel == nullptr || mvControlled->EngineType != TEngineType::ElectricSeriesMotor)) { // try to finalize state change of the line breaker, set the state based on the outcome - m_linebreakerstate = mvControlled->MainSwitch(true) ? 1 : 0; + m_linebreakerstate = mvControlled->MainSwitch(true, mvControlled->MainSwitchRange()) ? 1 : 0; } + // the switches of the other vehicles in multiple + update_remote_linebreakers(Deltatime); // door permits for (auto idx = 0; idx < 2; ++idx) { @@ -9107,9 +9404,9 @@ bool TTrain::Update(double const Deltatime) // KURS90 btLampkaMaxSila.Turn(abs(mvControlled->Im) >= 350); btLampkaPrzekrMaxSila.Turn(abs(mvControlled->Im) >= 450); - btLampkaRadio.Turn(mvOccupied->Radio); + btLampkaRadio.Turn(mvOccupied->Radio && mvOccupied->RadioFuse); btLampkaRadioMessage.Turn(radio_message_played); - btLampkaRadioStop.Turn(mvOccupied->Radio && mvOccupied->RadioStopFlag); + btLampkaRadioStop.Turn(mvOccupied->Radio && mvOccupied->RadioFuse && mvOccupied->RadioStopFlag); btLampkaHamulecReczny.Turn(mvOccupied->ManualBrakePos > 0); // NBMX wrzesien 2003 - drzwi oraz sygnał odjazdu if (DynamicObject->Mechanik != nullptr) @@ -9560,6 +9857,12 @@ bool TTrain::Update(double const Deltatime) ggMainOffButton.Update(); ggMainOnButton.Update(); ggMainButton.Update(); + for (auto &remotelinebreaker : m_remotelinebreakers) + { + remotelinebreaker.main_switch.Update(); + remotelinebreaker.on_button.Update(); + remotelinebreaker.off_button.Update(); + } ggSecurityResetButton.Update(); ggSHPResetButton.Update(); ggReleaserButton.Update(); @@ -9585,6 +9888,10 @@ bool TTrain::Update(double const Deltatime) ggRadioVolumeSelector.Update(); ggRadioVolumePrevious.Update(); ggRadioVolumeNext.Update(); + ggRadioOnButton.Update(); + ggRadioOffButton.Update(); + ggRadioFuseOnButton.Update(); + ggRadioFuseOffButton.Update(); ggDepartureSignalButton.Update(); /* ggPantFrontButton.Update(); @@ -11053,6 +11360,13 @@ void TTrain::clear_cab_controls() ggMaxCurrentCtrl.Clear(); ggMainOffButton.Clear(); ggMainOnButton.Clear(); + for (auto &remotelinebreaker : m_remotelinebreakers) + { + remotelinebreaker.main_switch.Clear(); + remotelinebreaker.on_button.Clear(); + remotelinebreaker.off_button.Clear(); + remotelinebreaker.held_without_switch = false; + } ggSecurityResetButton.Clear(); ggSHPResetButton.Clear(); ggReleaserButton.Clear(); @@ -11125,6 +11439,10 @@ void TTrain::clear_cab_controls() ggRadioVolumeSelector.Clear(); ggRadioVolumePrevious.Clear(); ggRadioVolumeNext.Clear(); + ggRadioOnButton.Clear(); + ggRadioOffButton.Clear(); + ggRadioFuseOnButton.Clear(); + ggRadioFuseOffButton.Clear(); ggDoorLeftPermitButton.Clear(); ggDoorRightPermitButton.Clear(); ggDoorPermitPresetButton.Clear(); @@ -11284,6 +11602,7 @@ void TTrain::clear_cab_controls() ggLeftEndLightButton.Clear(); ggRightEndLightButton.Clear(); ggLightsButton.Clear(); + ggCompressorListButton.Clear(); // hunter-230112 ggRearLeftLightButton.Clear(); ggRearRightLightButton.Clear(); @@ -11305,6 +11624,22 @@ void TTrain::set_cab_controls(int const Cab) { // instead of single main button there can be on/off pair ggMainButton.PutValue(ggMainButton.type() == TGaugeType::push ? 0.5f : m_linebreakerstate > 0 ? 1.f : 0.f); } + // line breakers of the other vehicles in multiple + for (std::size_t index = 0; index < m_remotelinebreakers.size(); ++index) + { + auto &mainswitch{m_remotelinebreakers[index].main_switch}; + if (mainswitch.SubModel == nullptr) + { + continue; + } + if (mainswitch.type() == TGaugeType::push) + { + mainswitch.PutValue(0.5f); + continue; + } + auto const *engine{remote_engine(index)}; + mainswitch.PutValue(engine != nullptr && engine_start::remote_switch::is_running(*engine) ? 1.f : 0.f); + } if (ggModernLightDimSw.SubModel != nullptr) { @@ -11797,6 +12132,12 @@ bool TTrain::initialize_gauge(cParser &Parser, std::string const &Label, int con {"maxcurrent_sw:", ggMaxCurrentCtrl}, {"main_off_bt:", ggMainOffButton}, {"main_on_bt:", ggMainOnButton}, + {"mainb_sw:", m_remotelinebreakers[0].main_switch}, + {"mainb_off_bt:", m_remotelinebreakers[0].off_button}, + {"mainb_on_bt:", m_remotelinebreakers[0].on_button}, + {"mainc_sw:", m_remotelinebreakers[1].main_switch}, + {"mainc_off_bt:", m_remotelinebreakers[1].off_button}, + {"mainc_on_bt:", m_remotelinebreakers[1].on_button}, {"security_reset_bt:", ggSecurityResetButton}, {"shp_reset_bt:", ggSHPResetButton}, {"releaser_bt:", ggReleaserButton}, @@ -11869,6 +12210,10 @@ bool TTrain::initialize_gauge(cParser &Parser, std::string const &Label, int con {"radiovolume_sw:", ggRadioVolumeSelector}, {"radiovolumeprev_sw:", ggRadioVolumePrevious}, {"radiovolumenext_sw:", ggRadioVolumeNext}, + {"radioon_sw:", ggRadioOnButton}, + {"radiooff_sw:", ggRadioOffButton}, + {"radiofuseon_sw:", ggRadioFuseOnButton}, + {"radiofuseoff_sw:", ggRadioFuseOffButton}, /* { "pantfront_sw:", ggPantFrontButton }, { "pantrear_sw:", ggPantRearButton }, @@ -12026,6 +12371,7 @@ bool TTrain::initialize_gauge(cParser &Parser, std::string const &Label, int con {"pantfrontoff_sw:", &mvPantographUnit->Pantographs[end::front].valve.is_disabled}, {"pantrearoff_sw:", &mvPantographUnit->Pantographs[end::rear].valve.is_disabled}, {"radio_sw:", &mvOccupied->Radio}, + {"radiofuse_sw:", &mvOccupied->RadioFuse}, {"cablight_sw:", &Cabine[iCabn].bLight}, {"springbraketoggle_bt:", &mvOccupied->SpringBrake.Activate}, {"couplingdisconnect_sw:", &m_couplingdisconnect}, diff --git a/vehicle/Train.h b/vehicle/Train.h index e664c231a..dd077e366 100644 --- a/vehicle/Train.h +++ b/vehicle/Train.h @@ -14,6 +14,7 @@ http://mozilla.org/MPL/2.0/. #include "vehicle/Driver.h" #include "vehicle/Button.h" #include "vehicle/Gauge.h" +#include "vehicle/enginestart.h" #include "audio/sound.h" #include "scripting/PyInt.h" #include "input/command.h" @@ -189,6 +190,8 @@ class TTrain { // sets cabin controls based on current state of the vehicle // NOTE: we can get rid of this function once we have per-cab persistent state void set_cab_controls( int const Cab ); + // sets the cab interior light as the selected light preset says, if it says anything (eu07/maszyna#529) + void set_cab_light_from_lights_preset(); // initializes a gauge matching provided label. returns: true if the label was found, false otherwise bool initialize_gauge(cParser &Parser, std::string const &Label, int const Cabindex); // initializes a button matching provided label. returns: true if the label was found, false otherwise @@ -214,6 +217,10 @@ class TTrain { void change_pantograph_selection( int const Change ); // helper, common part of pantograh valves state update methods void update_pantograph_valves(); + // the Index-th other vehicle in multiple whose engine the cab starts with its own switches (0: mainb_*, 1: mainc_*) + TMoverParameters *remote_engine( std::size_t const Index ) const; + // the switches starting the engines of the other vehicles in multiple, for Deltatime seconds + void update_remote_linebreakers( double const Deltatime ); // update function subroutines void update_sounds( double const Deltatime ); void update_sounds_runningnoise( sound_source &Sound ); @@ -338,6 +345,9 @@ class TTrain { static void OnCommand_linebreakertoggle( TTrain *Train, command_data const &Command ); static void OnCommand_linebreakeropen( TTrain *Train, command_data const &Command ); static void OnCommand_linebreakerclose( TTrain *Train, command_data const &Command ); + static void OnCommand_linebreakertoggleremote( TTrain *Train, command_data const &Command ); + static void OnCommand_linebreakeropenremote( TTrain *Train, command_data const &Command ); + static void OnCommand_linebreakercloseremote( TTrain *Train, command_data const &Command ); static void OnCommand_fuelpumptoggle( TTrain *Train, command_data const &Command ); static void OnCommand_fuelpumpenable( TTrain *Train, command_data const &Command ); static void OnCommand_fuelpumpdisable( TTrain *Train, command_data const &Command ); @@ -489,6 +499,9 @@ class TTrain { static void OnCommand_radiovolumeincrease(TTrain *Train, command_data const &Command); static void OnCommand_radiovolumedecrease(TTrain *Train, command_data const &Command); static void OnCommand_radiovolumeset(TTrain *Train, command_data const &Command); + static void OnCommand_radiofusetoggle(TTrain *Train, command_data const &Command); + static void OnCommand_radiofuseenable(TTrain *Train, command_data const &Command); + static void OnCommand_radiofusedisable(TTrain *Train, command_data const &Command); static void OnCommand_cabchangeforward( TTrain *Train, command_data const &Command ); static void OnCommand_cabchangebackward( TTrain *Train, command_data const &Command ); static void OnCommand_generictoggle( TTrain *Train, command_data const &Command ); @@ -570,6 +583,15 @@ public: // reszta może by?publiczna TGauge ggMainOffButton; TGauge ggMainOnButton; TGauge ggMainButton; // EZT + // the line breaker / engine start switches of the second and the third vehicle in multiple (mainb_*, mainc_*) + struct remote_linebreaker { + TGauge main_switch; // mainb_sw: + TGauge on_button; // mainb_on_bt: + TGauge off_button; // mainb_off_bt: + bool held_without_switch{ false }; // closed by a command, in a cab without a switch for it + engine_start::remote_switch state; + }; + std::array m_remotelinebreakers; TGauge ggSecurityResetButton; TGauge ggSHPResetButton; TGauge ggReleaserButton; @@ -595,6 +617,10 @@ public: // reszta może by?publiczna TGauge ggRadioVolumeSelector; TGauge ggRadioVolumePrevious; TGauge ggRadioVolumeNext; + TGauge ggRadioOnButton; + TGauge ggRadioOffButton; + TGauge ggRadioFuseOnButton; + TGauge ggRadioFuseOffButton; TGauge ggUpperLightButton; TGauge ggLeftLightButton; TGauge ggRightLightButton; diff --git a/vehicle/doorwings.h b/vehicle/doorwings.h new file mode 100644 index 000000000..07286aac8 --- /dev/null +++ b/vehicle/doorwings.h @@ -0,0 +1,52 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +#include + +#include + +// the poses of the animated door wings of a vehicle, for the door position of the mover. a wing is posed alike +// in the main model and, when the low poly interior has a submodel of the same name, in the interior as well +namespace door_wings { + +// whether the animation with the given flags (TAnim::iFlags, the kind of animation in bits 4-7) moves a door wing +inline bool is_wing(int const Flags) { + return (Flags & 0xF0) == 0x10; +} + +// odd numbered wings (door1, door3...) are on the left side of the vehicle, even numbered on the right +inline bool on_right_side(int const Number) { + return (Number & 1) == 0; +} + +// sliding door (type 1): shifted along the vehicle +inline glm::vec3 slide(float const Position) { + return {0.f, 0.f, Position}; +} + +// plug door (type 4): pushed out first, up to Rangeout, then slid along the vehicle +inline glm::vec3 plug(float const Position, float const Rangeout) { + return {std::min(Position * 2.f, Rangeout), 0.f, std::max(0.f, Position - Rangeout * 0.5f)}; +} + +// folding door (type 3): the angles of the smaller wing, of the larger wing (its child) and of the step (the +// child of the larger wing) +struct fold_angles { + float smaller; + float larger; + float step; +}; + +inline fold_angles fold(float const Position) { + return {Position, -Position - Position, Position}; +} + +} // namespace door_wings diff --git a/vehicle/enginestart.cpp b/vehicle/enginestart.cpp new file mode 100644 index 000000000..feb4445ce --- /dev/null +++ b/vehicle/enginestart.cpp @@ -0,0 +1,109 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#include "stdafx.h" +#include "vehicle/enginestart.h" + +#include "McZapkie/MOVER.h" +#include "utilities/utilities.h" + +namespace engine_start { + +namespace { + +// whether the vehicle has an engine the cab can start, the same test the tachometers of the vehicles in multiple make +bool has_engine(TMoverParameters const &Vehicle) { + return Vehicle.Power > 0.01; +} + +// walks from Start through its coupler Side along the control cable, and returns the Number-th vehicle with an engine +// other than Skipped it meets; Number is lowered by the ones it met when it doesn't get that far +TMoverParameters *find_along(TMoverParameters const &Start, int const Side, TMoverParameters const &Skipped, int &Number) { + auto const *vehicle{&Start}; + auto side{Side}; + // a train can't loop back on itself, the limit only guards against a broken chain of couplers + for (auto steps = 0; steps < 1000; ++steps) { + auto const &coupler{vehicle->Couplers[side]}; + if (coupler.Connected == nullptr || false == TestFlag(coupler.CouplingFlag, coupling::control)) { + return nullptr; + } + // onwards through the other end of the next vehicle, whichever way round it stands + side = 1 - coupler.ConnectedNr; + vehicle = coupler.Connected; + if (vehicle == &Skipped || false == has_engine(*vehicle)) { + continue; + } + --Number; + if (Number == 0) { + return coupler.Connected; + } + } + return nullptr; +} + +} // namespace + +TMoverParameters *engine(TMoverParameters const &Occupied, TMoverParameters &Controlled, int Number) { + if (Number < 1) { + return nullptr; + } + if (Number == 1) { + return &Controlled; + } + // the cab's own vehicle is the first one + auto others{Number - 1}; + // behind the cab is the rear end of a vehicle driven from its front cab, and the other way round + int const behind{Occupied.CabOccupied < 0 ? end::front : end::rear}; + if (auto *found{find_along(Occupied, behind, Controlled, others)}; found != nullptr) { + return found; + } + return find_along(Occupied, 1 - behind, Controlled, others); +} + +void remote_switch::update(TMoverParameters *Engine, bool const Closeheld, bool const Openheld, double const Deltatime, bool const Closesonrelease) { + if (Engine != m_engine) { + // another vehicle under the switch, after a change in the train + m_engine = Engine; + m_heldtime = 0.0; + m_ready = false; + } + if (Engine == nullptr) { + return; + } + if (Openheld || is_running(*Engine)) { + // the switch opening the circuit is held down, or there's nothing left to start + m_heldtime = 0.0; + m_ready = false; + return; + } + if (Closeheld && Engine->MainSwitchCheck()) { + m_heldtime += Deltatime; + } + if (m_heldtime > Engine->InitialCtrlDelay) { + m_ready = true; + } + if (m_ready && false == (Closesonrelease && Closeheld)) { + Engine->MainSwitch(true, range_t::local); + m_ready = false; + m_heldtime = 0.0; + } + if (false == Closeheld) { + m_heldtime = 0.0; + } +} + +bool remote_switch::open(TMoverParameters &Engine) { + return Engine.MainSwitch(false, range_t::local); +} + +bool remote_switch::is_running(TMoverParameters const &Engine) { + return Engine.Mains || Engine.dizel_startup; +} + +} // namespace engine_start diff --git a/vehicle/enginestart.h b/vehicle/enginestart.h new file mode 100644 index 000000000..77b6a2d93 --- /dev/null +++ b/vehicle/enginestart.h @@ -0,0 +1,46 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +class TMoverParameters; + +// starting the engines (closing the line breakers) of the vehicles in multiple from the cab (eu07/maszyna#80). in +// vehicles like the ST43, the SP32 or the SN61 every engine of the train has its own switches in the cab: main_* work +// the vehicle the cab controls (TTrain::mvControlled: the cab's own vehicle, on an EMU its motor car), mainb_* the +// second one and mainc_* the third one under its control. Engine:JointEngineStart=No in the .fiz of the controlled +// vehicle (on an EMU the motor car's, not the one of the car with the cab) keeps main_* to that vehicle alone +// (TMoverParameters::MainSwitchRange()); by default it works all of them, as before. +namespace engine_start { + +// the Number-th vehicle with an engine under the cab's control: 1 is Controlled, the cab's own; then the others +// connected through the control cable, those behind the cab of Occupied first, the nearest first, then those in front +// of it. nullptr when there are fewer of them +TMoverParameters *engine(TMoverParameters const &Occupied, TMoverParameters &Controlled, int Number); + +// the switch starting the engine of another vehicle in multiple. like the cab's own switch, it has to be held closed +// for the vehicle's InitialCtrlDelay, with the vehicle ready for it, before the engine starts (the line breaker closes) +class remote_switch { +public: + // one step of Deltatime seconds of the switch of Engine, with the switch held closed (Closeheld) or open (Openheld). + // with Closesonrelease, the line breaker closes when the switch is let go after the delay, as the impulse switch + // of an electric locomotive with series motors does + void update(TMoverParameters *Engine, bool Closeheld, bool Openheld, double Deltatime, bool Closesonrelease); + // opens the line breaker / stops the engine of Engine, the vehicle alone; returns whether it was running + static bool open(TMoverParameters &Engine); + // whether the line breaker of Engine is closed or its engine starting or running + static bool is_running(TMoverParameters const &Engine); + +private: + TMoverParameters const *m_engine{nullptr}; // the vehicle the switch worked the last step + double m_heldtime{0.0}; // how long the switch is held closed with the vehicle ready to start + bool m_ready{false}; // held long enough, the line breaker closes now or when the switch is let go +}; + +} // namespace engine_start diff --git a/vehicle/gaugeduplicates.h b/vehicle/gaugeduplicates.h new file mode 100644 index 000000000..3a20c9306 --- /dev/null +++ b/vehicle/gaugeduplicates.h @@ -0,0 +1,30 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +#include + +// cab controls with more than one submodel (eu07/maszyna#527): a definition of a control in the .mmd marked +// "duplicate: yes" adds a copy of the control already defined in the cab, instead of replacing it +namespace gauge_duplicates { + +// whether the value of the duplicate: key marks the definition as a duplicate +inline bool is_duplicate(std::string_view const Value) { + return Value == "yes" || Value == "true" || Value == "1"; +} + +// whether a definition adds a copy to the control rather than replacing it: it is marked as a duplicate, and the +// control is already loaded from one of the 3d models of the cab being loaded (Cab, Lowpoly). a control left over +// from another cab, or not loaded at all (Loadedfrom null), has nothing in this cab to add the copy to +template bool adds_copy(bool const Duplicate, Model_ const *Loadedfrom, Model_ const *Cab, Model_ const *Lowpoly) { + return Duplicate && Loadedfrom != nullptr && (Loadedfrom == Cab || Loadedfrom == Lowpoly); +} + +} // namespace gauge_duplicates diff --git a/vehicle/holdcoillever.h b/vehicle/holdcoillever.h new file mode 100644 index 000000000..005bccbd5 --- /dev/null +++ b/vehicle/holdcoillever.h @@ -0,0 +1,34 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +// the lever of the line breaker's hold coil (eu07/maszyna#364), as on the ET22 and the EP09: the cab's main_off_bt +// control declared with "type: toggle" stays in the position it's put in. Position 0 keeps the hold coil fed, so the +// line breaker can be closed; position 1 cuts the coil off, which opens the line breaker and keeps it from closing +// until the lever is put back. Without the declared type main_off_bt stays the push button it always was, which +// opens the line breaker and springs back. +namespace hold_coil_lever { + +// whether the main_off_bt control is the bistable lever, from the type its definition declares, if it declares one +inline bool is_bistable(bool const Typedeclared, bool const Toggletype) { + return Typedeclared && Toggletype; +} + +// whether the lever in the given position cuts off the hold coil +inline bool cuts_off(float const Position) { + return Position > 0.5f; +} + +// the position the lever goes to when it's operated: the other one +inline float operated(float const Position) { + return cuts_off(Position) ? 0.f : 1.f; +} + +} // namespace hold_coil_lever diff --git a/vehicle/lightsprogrammer.h b/vehicle/lightsprogrammer.h new file mode 100644 index 000000000..9ae8c2ab0 --- /dev/null +++ b/vehicle/lightsprogrammer.h @@ -0,0 +1,41 @@ +/* +This Source Code Form is subject to the +terms of the Mozilla Public License, v. +2.0. If a copy of the MPL was not +distributed with this file, You can +obtain one at +http://mozilla.org/MPL/2.0/. +*/ + +#pragma once + +#include + +#include "McZapkie/MOVER.h" + +// the lights the light preset selector (programmer) of the occupied cab gives one vehicle of the consist +namespace lights_programmer { + +// the lights for the vehicle's two ends, in the terms of TDynamicObject::RaLightsSet(): head is the end +// towards the head of the consist (TDynamicObject::Prev()), rear the end towards its tail (Next()) +struct consist_lights { + int head; + int rear; +}; + +// Cablights: the selector's lights for the occupied cab's front and back (Lights[end::front / end::rear]). +// Cabfacinghead: the occupied cab faces the head of the consist. +// Direction: the vehicle's iDirection, 1 when its end::front is towards the head of the consist. +// Coupled: whether another vehicle is coupled at the vehicle's end::front / end::rear; an end with a coupled +// vehicle stays dark +inline consist_lights vehicle_lights(std::array const &Cablights, bool const Cabfacinghead, int const Direction, std::array const &Coupled) { + auto const headlights{Cablights[Cabfacinghead ? end::front : end::rear]}; + auto const rearlights{Cablights[Cabfacinghead ? end::rear : end::front]}; + // the head lights go to the vehicle's end towards the head of the consist whichever way the cab faces, + // so the coupling which keeps them dark is the one at that same end (eu07/maszyna#395) + auto const headend{Direction > 0 ? end::front : end::rear}; + auto const rearend{Direction > 0 ? end::rear : end::front}; + return {Coupled[headend] ? 0 : headlights, Coupled[rearend] ? 0 : rearlights}; +} + +} // namespace lights_programmer diff --git a/vehicle/smoke.cpp b/vehicle/smoke.cpp index b6e923222..f5f64bef0 100644 --- a/vehicle/smoke.cpp +++ b/vehicle/smoke.cpp @@ -34,7 +34,7 @@ double engine_load(TMoverParameters const &Mover) { } // namespace float vehicle_spawn_count(TMoverParameters const &Mover, bool const Ontracks, spawn_rate const &Rate, double const Timedelta) { - if (false == Ontracks) { + if (false == Ontracks || Mover.dizel_FiringCountdown > 0.0) { return 0.f; } // the steady rate of the source, the way a source of the scenery spawns... diff --git a/vehicle/smoke.h b/vehicle/smoke.h index e9dac2622..dbcc131ae 100644 --- a/vehicle/smoke.h +++ b/vehicle/smoke.h @@ -25,6 +25,7 @@ struct spawn_rate { // number of particles the smoke source of a vehicle has to spawn after Timedelta seconds: the steady rate of the // source, plus a share which grows with the work of its engine. a vehicle taken off the tracks (Ontracks false: gone through a portal, or waiting in the pool of the road // traffic) puffs no more, the particles it already let out fade away as usual +// an engine the starter turns but which hasn't fired yet (TMoverParameters::dizel_FiringCountdown) lets out no smoke either float vehicle_spawn_count(TMoverParameters const &Mover, bool Ontracks, spawn_rate const &Rate, double Timedelta); } // namespace smoke diff --git a/vr/openvr_imp.cpp b/vr/openvr_imp.cpp index 15467d006..b3af171b2 100644 --- a/vr/openvr_imp.cpp +++ b/vr/openvr_imp.cpp @@ -495,6 +495,18 @@ std::unordered_map vr_openvr::m_buttonb { "main_on_bt:",{ user_command::linebreakerclose, user_command::none } }, + { "mainb_off_bt:", { + user_command::linebreakeropenb, + user_command::none } }, + { "mainb_on_bt:", { + user_command::linebreakercloseb, + user_command::none } }, + { "mainc_off_bt:", { + user_command::linebreakeropenc, + user_command::none } }, + { "mainc_on_bt:", { + user_command::linebreakerclosec, + user_command::none } }, { "security_reset_bt:", { user_command::alerteracknowledge, user_command::none } }, @@ -660,6 +672,12 @@ std::unordered_map vr_openvr::m_buttonb { "main_sw:", { user_command::linebreakertoggle, user_command::none } }, + { "mainb_sw:", { + user_command::linebreakertoggleb, + user_command::none } }, + { "mainc_sw:", { + user_command::linebreakertogglec, + user_command::none } }, { "radio_sw:", { user_command::radiotoggle, user_command::none } }, @@ -669,6 +687,15 @@ std::unordered_map vr_openvr::m_buttonb { "radiooff_sw:", { user_command::radiodisable, user_command::none } }, + { "radiofuse_sw:", { + user_command::radiofusetoggle, + user_command::none } }, + { "radiofuseon_sw:", { + user_command::radiofuseenable, + user_command::none } }, + { "radiofuseoff_sw:", { + user_command::radiofusedisable, + user_command::none } }, { "radiochannel_sw:", { user_command::radiochannelincrease, user_command::radiochanneldecrease } },