18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-22 02:05:01 +01:00

refactor(sonar): reduce enum qualification with using enum (cpp:S6177)

Applied only where no unqualified name in the block could be captured by
the introduced enumerators.
This commit is contained in:
jerrrrycho
2026-10-10 16:49:01 +02:00
parent e524d38128
commit 34c0c8182d
14 changed files with 887 additions and 846 deletions

View File

@@ -2173,11 +2173,12 @@ void TMoverParameters::WaterHeaterCheck(double const /*Timestep*/)
// fuel pump status update
void TMoverParameters::FuelPumpCheck(double const /*Timestep*/)
{
using enum start_t;
FuelPump.is_active = true == (Power24vIsAvailable || Power110vIsAvailable) && false == FuelPump.is_disabled &&
(FuelPump.is_active || (FuelPump.start_type == start_t::manual ? FuelPump.is_enabled :
FuelPump.start_type == start_t::automatic ? dizel_startup || Mains :
FuelPump.start_type == start_t::manualwithautofallback ? FuelPump.is_enabled || dizel_startup || Mains :
(FuelPump.is_active || (FuelPump.start_type == manual ? FuelPump.is_enabled :
FuelPump.start_type == automatic ? dizel_startup || Mains :
FuelPump.start_type == manualwithautofallback ? FuelPump.is_enabled || dizel_startup || Mains :
false)); // shouldn't ever get this far but, eh
}
@@ -2272,12 +2273,13 @@ void TMoverParameters::MotorBlowersCheck(double const Timestep)
void TMoverParameters::PantographsCheck(double const /*Timestep*/)
{
using enum start_t;
{
auto &valve{PantsValve};
auto const lowvoltagepower{valve.solenoid ? Power24vIsAvailable || Power110vIsAvailable : true};
auto const autostart{valve.start_type == start_t::automatic || valve.start_type == start_t::manualwithautofallback};
auto const manualcontrol{valve.start_type == start_t::manual || valve.start_type == start_t::manualwithautofallback};
auto const autostart{valve.start_type == automatic || valve.start_type == manualwithautofallback};
auto const manualcontrol{valve.start_type == manual || valve.start_type == manualwithautofallback};
PantsValve.is_active = (valve.spring ? lowvoltagepower : true) // spring actuator needs power to maintain non-default state
&& (manualcontrol && lowvoltagepower ? false == valve.is_disabled : true) // needs power to change state
@@ -2292,8 +2294,8 @@ void TMoverParameters::PantographsCheck(double const /*Timestep*/)
auto &valve{pantograph.valve};
auto const lowvoltagepower{valve.solenoid ? Power24vIsAvailable || Power110vIsAvailable : true};
auto const autostart{valve.start_type == start_t::automatic || valve.start_type == start_t::manualwithautofallback};
auto const manualcontrol{valve.start_type == start_t::manual || valve.start_type == start_t::manualwithautofallback};
auto const autostart{valve.start_type == automatic || valve.start_type == manualwithautofallback};
auto const manualcontrol{valve.start_type == manual || valve.start_type == manualwithautofallback};
valve.is_active = (valve.spring ? lowvoltagepower : true) // spring actuator needs power to maintain non-default state
&& (manualcontrol && lowvoltagepower ? false == valve.is_disabled : true) // needs power to change state, without it just pass through
@@ -3128,6 +3130,7 @@ void TMoverParameters::SecuritySystemCheck(double dt)
// *************************************************************************************************
bool TMoverParameters::BatterySwitch(bool State, range_t const Notify)
{
using enum range_t;
auto const initialstate{Battery};
// Ra: ukrotnienie załączania baterii jest jakąś fikcją...
@@ -3137,10 +3140,10 @@ bool TMoverParameters::BatterySwitch(bool State, range_t const Notify)
}
// switching batteries does not require activation
if (Notify != range_t::local)
if (Notify != local)
{
SendCtrlToNext("BatterySwitch", State ? 1 : 0, 1, Notify == range_t::unit ? coupling::control | coupling::permanent : coupling::control);
SendCtrlToNext("BatterySwitch", State ? 1 : 0, -1, Notify == range_t::unit ? coupling::control | coupling::permanent : coupling::control);
SendCtrlToNext("BatterySwitch", State ? 1 : 0, 1, Notify == unit ? coupling::control | coupling::permanent : coupling::control);
SendCtrlToNext("BatterySwitch", State ? 1 : 0, -1, Notify == unit ? coupling::control | coupling::permanent : coupling::control);
}
return Battery != initialstate;
@@ -3634,6 +3637,7 @@ void TMoverParameters::MainSwitch_(bool const State)
bool TMoverParameters::MainSwitchCheck() const
{
using enum TEngineType;
// prevent the switch from working if there's no power
// TODO: consider whether it makes sense for diesel engines and such
@@ -3641,15 +3645,15 @@ bool TMoverParameters::MainSwitchCheck() const
switch (EngineType)
{
case TEngineType::DieselElectric:
case TEngineType::DieselEngine:
case TEngineType::Dumb:
case DieselElectric:
case DieselEngine:
case Dumb:
{
powerisavailable = Power24vIsAvailable;
break;
}
case TEngineType::ElectricSeriesMotor:
case TEngineType::ElectricInductionMotor:
case ElectricSeriesMotor:
case ElectricInductionMotor:
{
// TODO: check whether we can simplify this check and skip the outer EngineType switch
powerisavailable = EnginePowerSourceVoltage() > 0.5 * EnginePowerSource.MaxVoltage;
@@ -3661,7 +3665,7 @@ bool TMoverParameters::MainSwitchCheck() const
}
}
return powerisavailable && (ScndCtrlPos == 0 || EngineType == TEngineType::ElectricInductionMotor) && MainsInitTimeCountdown <= 0.0 &&
return powerisavailable && (ScndCtrlPos == 0 || EngineType == ElectricInductionMotor) && MainsInitTimeCountdown <= 0.0 &&
(ConvOvldFlag == false || ConverterOverloadRelayOffWhenMainIsOff) && true == GroundRelay && true == NoVoltRelay && true == OvervoltageRelay && LastSwitchingTime > CtrlDelay &&
(HasCamshaft ? IsMainCtrlActualNoPowerPos() :
LineBreakerClosesOnlyAtNoPowerPos ? IsMainCtrlNoPowerPos() :
@@ -7147,40 +7151,41 @@ bool TMoverParameters::OperatePantographsValve(operation_t const State, range_t
switch (State)
{
case operation_t::none:
using enum operation_t;
case none:
{
valve.is_enabled = false;
valve.is_disabled = false;
break;
}
case operation_t::enable:
case enable:
{
valve.is_enabled = true;
valve.is_disabled = false;
break;
}
case operation_t::disable:
case disable:
{
valve.is_enabled = false;
valve.is_disabled = true;
break;
}
case operation_t::enable_on:
case enable_on:
{
valve.is_enabled = true;
break;
}
case operation_t::enable_off:
case enable_off:
{
valve.is_enabled = false;
break;
}
case operation_t::disable_on:
case disable_on:
{
valve.is_disabled = true;
break;
}
case operation_t::disable_off:
case disable_off:
{
valve.is_disabled = false;
break;
@@ -7206,40 +7211,41 @@ bool TMoverParameters::OperatePantographValve(end const End, operation_t const S
switch (State)
{
case operation_t::none:
using enum operation_t;
case none:
{
valve.is_enabled = false;
valve.is_disabled = false;
break;
}
case operation_t::enable:
case enable:
{
valve.is_enabled = true;
valve.is_disabled = false;
break;
}
case operation_t::disable:
case disable:
{
valve.is_enabled = false;
valve.is_disabled = true;
break;
}
case operation_t::enable_on:
case enable_on:
{
valve.is_enabled = true;
break;
}
case operation_t::enable_off:
case enable_off:
{
valve.is_enabled = false;
break;
}
case operation_t::disable_on:
case disable_on:
{
valve.is_disabled = true;
break;
}
case operation_t::disable_off:
case disable_off:
{
valve.is_disabled = false;
break;
@@ -9517,42 +9523,43 @@ bool TMoverParameters::readCompressorList(std::string const &Input)
// *************************************************************************************************
void TMoverParameters::BrakeValveDecode(std::string const &Valve)
{
using enum TBrakeValve;
std::map<std::string, TBrakeValve> valvetypes{{"W", TBrakeValve::W},
{"W_Lu_L", TBrakeValve::W_Lu_L},
{"W_Lu_XR", TBrakeValve::W_Lu_XR},
{"W_Lu_VI", TBrakeValve::W_Lu_VI},
{"K", TBrakeValve::K},
{"Kg", TBrakeValve::Kg},
{"Kp", TBrakeValve::Kp},
{"Kss", TBrakeValve::Kss},
{"Kkg", TBrakeValve::Kkg},
{"Kkp", TBrakeValve::Kkp},
{"Kks", TBrakeValve::Kks},
{"Hikp1", TBrakeValve::Hikp1},
{"Hikss", TBrakeValve::Hikss},
{"Hikg1", TBrakeValve::Hikg1},
{"KE", TBrakeValve::KE},
{"SW", TBrakeValve::SW},
{"EStED", TBrakeValve::EStED},
{"NESt3", TBrakeValve::NESt3},
{"ESt3", TBrakeValve::ESt3},
{"LSt", TBrakeValve::LSt},
{"ESt4", TBrakeValve::ESt4},
{"ESt3AL2", TBrakeValve::ESt3AL2},
{"EP1", TBrakeValve::EP1},
{"EP2", TBrakeValve::EP2},
{"M483", TBrakeValve::M483},
{"CV1_L_TR", TBrakeValve::CV1_L_TR},
{"CV1", TBrakeValve::CV1},
{"CV1_R", TBrakeValve::CV1_R}};
std::map<std::string, TBrakeValve> valvetypes{{"W", W},
{"W_Lu_L", W_Lu_L},
{"W_Lu_XR", W_Lu_XR},
{"W_Lu_VI", W_Lu_VI},
{"K", K},
{"Kg", Kg},
{"Kp", Kp},
{"Kss", Kss},
{"Kkg", Kkg},
{"Kkp", Kkp},
{"Kks", Kks},
{"Hikp1", Hikp1},
{"Hikss", Hikss},
{"Hikg1", Hikg1},
{"KE", KE},
{"SW", SW},
{"EStED", EStED},
{"NESt3", NESt3},
{"ESt3", ESt3},
{"LSt", LSt},
{"ESt4", ESt4},
{"ESt3AL2", ESt3AL2},
{"EP1", EP1},
{"EP2", EP2},
{"M483", M483},
{"CV1_L_TR", CV1_L_TR},
{"CV1", CV1},
{"CV1_R", CV1_R}};
auto lookup = valvetypes.find(Valve);
BrakeValve = lookup != valvetypes.end() ? lookup->second : TBrakeValve::Other;
BrakeValve = lookup != valvetypes.end() ? lookup->second : Other;
if (BrakeValve == TBrakeValve::Other && contains(Valve, "ESt"))
if (BrakeValve == Other && contains(Valve, "ESt"))
{
BrakeValve = TBrakeValve::ESt3;
BrakeValve = ESt3;
}
}
@@ -9561,32 +9568,34 @@ void TMoverParameters::BrakeValveDecode(std::string const &Valve)
// *************************************************************************************************
void TMoverParameters::BrakeSubsystemDecode()
{
BrakeSubsystem = TBrakeSubSystem::ss_None;
using enum TBrakeSubSystem;
BrakeSubsystem = ss_None;
switch (BrakeValve)
{
case TBrakeValve::W:
case TBrakeValve::W_Lu_L:
case TBrakeValve::W_Lu_VI:
case TBrakeValve::W_Lu_XR:
BrakeSubsystem = TBrakeSubSystem::ss_W;
using enum TBrakeValve;
case W:
case W_Lu_L:
case W_Lu_VI:
case W_Lu_XR:
BrakeSubsystem = ss_W;
break;
case TBrakeValve::ESt3:
case TBrakeValve::ESt3AL2:
case TBrakeValve::ESt4:
case TBrakeValve::EP2:
case TBrakeValve::EP1:
BrakeSubsystem = TBrakeSubSystem::ss_ESt;
case ESt3:
case ESt3AL2:
case ESt4:
case EP2:
case EP1:
BrakeSubsystem = ss_ESt;
break;
case TBrakeValve::KE:
BrakeSubsystem = TBrakeSubSystem::ss_KE;
case KE:
BrakeSubsystem = ss_KE;
break;
case TBrakeValve::CV1:
case TBrakeValve::CV1_L_TR:
BrakeSubsystem = TBrakeSubSystem::ss_Dako;
case CV1:
case CV1_L_TR:
BrakeSubsystem = ss_Dako;
break;
case TBrakeValve::LSt:
case TBrakeValve::EStED:
BrakeSubsystem = TBrakeSubSystem::ss_LSt;
case LSt:
case EStED:
BrakeSubsystem = ss_LSt;
break;
default:
break;
@@ -10702,12 +10711,14 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line)
{
{
std::map<std::string, TBrakeSystem> brakesystems{{"Pneumatic", TBrakeSystem::Pneumatic}, {"ElectroPneumatic", TBrakeSystem::ElectroPneumatic}};
using enum TBrakeSystem;
std::map<std::string, TBrakeSystem> brakesystems{{"Pneumatic", Pneumatic}, {"ElectroPneumatic", ElectroPneumatic}};
auto lookup = brakesystems.find(extract_value("BrakeSystem", line));
BrakeSystem = lookup != brakesystems.end() ? lookup->second : TBrakeSystem::Individual;
BrakeSystem = lookup != brakesystems.end() ? lookup->second : Individual;
}
if (BrakeSystem != TBrakeSystem::Individual)
{
using enum TBrakeHandle;
extract_value(BrakeCtrlPosNo, "BCPN", line, "");
for (int idx = 0; idx < 4; ++idx)
@@ -10742,11 +10753,11 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line)
// brakehandle
{
std::map<std::string, TBrakeHandle> brakehandles{
{"FV4a", TBrakeHandle::FV4a}, {"test", TBrakeHandle::testH}, {"D2", TBrakeHandle::D2}, {"MHZ_EN57", TBrakeHandle::MHZ_EN57}, {"MHZ_K5P", TBrakeHandle::MHZ_K5P},
{"MHZ_K8P", TBrakeHandle::MHZ_K8P}, {"MHZ_6P", TBrakeHandle::MHZ_6P}, {"M394", TBrakeHandle::M394}, {"Knorr", TBrakeHandle::Knorr}, {"Westinghouse", TBrakeHandle::West},
{"FVel6", TBrakeHandle::FVel6}, {"FVE408", TBrakeHandle::FVE408}, {"St113", TBrakeHandle::St113}};
{"FV4a", FV4a}, {"test", testH}, {"D2", D2}, {"MHZ_EN57", MHZ_EN57}, {"MHZ_K5P", MHZ_K5P},
{"MHZ_K8P", MHZ_K8P}, {"MHZ_6P", MHZ_6P}, {"M394", M394}, {"Knorr", Knorr}, {"Westinghouse", West},
{"FVel6", FVel6}, {"FVE408", FVE408}, {"St113", St113}};
auto lookup = brakehandles.find(extract_value("BrakeHandle", line));
BrakeHandle = lookup != brakehandles.end() ? lookup->second : TBrakeHandle::NoHandle;
BrakeHandle = lookup != brakehandles.end() ? lookup->second : NoHandle;
}
extract_value(Handle_AutomaticOverload, "HAO", line, "");
extract_value(Handle_ManualOverload, "HMO", line, "");
@@ -10756,9 +10767,9 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line)
extract_value(Handle_OverloadPressureDecrease, "OPD", line, "");
// brakelochandle
{
std::map<std::string, TBrakeHandle> locbrakehandles{{"FD1", TBrakeHandle::FD1}, {"Knorr", TBrakeHandle::Knorr}, {"Westinghouse", TBrakeHandle::West}};
std::map<std::string, TBrakeHandle> locbrakehandles{{"FD1", FD1}, {"Knorr", Knorr}, {"Westinghouse", West}};
auto lookup = locbrakehandles.find(extract_value("LocBrakeHandle", line));
BrakeLocHandle = lookup != locbrakehandles.end() ? lookup->second : TBrakeHandle::NoHandle;
BrakeLocHandle = lookup != locbrakehandles.end() ? lookup->second : NoHandle;
}
// mbpm
@@ -10798,9 +10809,10 @@ void TMoverParameters::LoadFIZ_Cntrl(std::string const &line)
// localbrake
{
std::map<std::string, TLocalBrake> localbrakes{{"ManualBrake", TLocalBrake::ManualBrake}, {"PneumaticBrake", TLocalBrake::PneumaticBrake}, {"HydraulicBrake", TLocalBrake::HydraulicBrake}};
using enum TLocalBrake;
std::map<std::string, TLocalBrake> localbrakes{{"ManualBrake", ManualBrake}, {"PneumaticBrake", PneumaticBrake}, {"HydraulicBrake", HydraulicBrake}};
auto lookup = localbrakes.find(extract_value("LocalBrake", line));
LocalBrake = lookup != localbrakes.end() ? lookup->second : TLocalBrake::NoBrake;
LocalBrake = lookup != localbrakes.end() ? lookup->second : NoBrake;
}
// mbrake
extract_value(MBrake, "ManualBrake", line, "");
@@ -11658,39 +11670,42 @@ void TMoverParameters::LoadFIZ_PowerParamsDecode(TPowerParameters &Powerparamete
TPowerType TMoverParameters::LoadFIZ_PowerDecode(std::string const &Powertype) const
{
using enum TPowerType;
std::map<std::string, TPowerType> powertypes{
{"BioPower", TPowerType::BioPower}, {"MechPower", TPowerType::MechPower}, {"ElectricPower", TPowerType::ElectricPower}, {"SteamPower", TPowerType::SteamPower}};
{"BioPower", BioPower}, {"MechPower", MechPower}, {"ElectricPower", ElectricPower}, {"SteamPower", SteamPower}};
auto lookup = powertypes.find(Powertype);
return lookup != powertypes.end() ? lookup->second : TPowerType::NoPower;
return lookup != powertypes.end() ? lookup->second : NoPower;
}
TPowerSource TMoverParameters::LoadFIZ_SourceDecode(std::string const &Source) const
{
using enum TPowerSource;
std::map<std::string, TPowerSource> powersources{{"Transducer", TPowerSource::Transducer}, {"Generator", TPowerSource::Generator},
{"Accu", TPowerSource::Accumulator}, // legacy compatibility leftover. TODO: check if we can get rid of it
{"Accumulator", TPowerSource::Accumulator}, {"CurrentCollector", TPowerSource::CurrentCollector},
{"PowerCable", TPowerSource::PowerCable}, {"Heater", TPowerSource::Heater},
{"Internal", TPowerSource::InternalSource}, {"Main", TPowerSource::Main}};
std::map<std::string, TPowerSource> powersources{{"Transducer", Transducer}, {"Generator", Generator},
{"Accu", Accumulator}, // legacy compatibility leftover. TODO: check if we can get rid of it
{"Accumulator", Accumulator}, {"CurrentCollector", CurrentCollector},
{"PowerCable", PowerCable}, {"Heater", Heater},
{"Internal", InternalSource}, {"Main", Main}};
auto lookup = powersources.find(Source);
return lookup != powersources.end() ? lookup->second : TPowerSource::NotDefined;
return lookup != powersources.end() ? lookup->second : NotDefined;
}
TEngineType TMoverParameters::LoadFIZ_EngineDecode(std::string const &Engine) const
{
using enum TEngineType;
std::map<std::string, TEngineType> enginetypes{{"ElectricSeriesMotor", TEngineType::ElectricSeriesMotor},
{"DieselEngine", TEngineType::DieselEngine},
{"SteamEngine", TEngineType::SteamEngine},
{"WheelsDriven", TEngineType::WheelsDriven},
{"Dumb", TEngineType::Dumb},
{"DieselElectric", TEngineType::DieselElectric},
{"DumbDE", TEngineType::DieselElectric},
{"ElectricInductionMotor", TEngineType::ElectricInductionMotor},
{"Main", TEngineType::Main}};
std::map<std::string, TEngineType> enginetypes{{"ElectricSeriesMotor", ElectricSeriesMotor},
{"DieselEngine", DieselEngine},
{"SteamEngine", SteamEngine},
{"WheelsDriven", WheelsDriven},
{"Dumb", Dumb},
{"DieselElectric", DieselElectric},
{"DumbDE", DieselElectric},
{"ElectricInductionMotor", ElectricInductionMotor},
{"Main", Main}};
auto lookup = enginetypes.find(Engine);
return lookup != enginetypes.end() ? lookup->second : TEngineType::None;
return lookup != enginetypes.end() ? lookup->second : None;
}
// *************************************************************************************************
@@ -11844,35 +11859,36 @@ bool TMoverParameters::CheckLocomotiveParameters(bool ReadyFlag, int /*Dir*/)
switch (BrakeHandle)
{
case TBrakeHandle::FV4a:
using enum TBrakeHandle;
case FV4a:
Handle = std::make_shared<TFV4aM>();
break;
case TBrakeHandle::MHZ_EN57:
case TBrakeHandle::MHZ_K8P:
case MHZ_EN57:
case MHZ_K8P:
Handle = std::make_shared<TMHZ_EN57>();
break;
case TBrakeHandle::FVel6:
case FVel6:
Handle = std::make_shared<TFVel6>();
break;
case TBrakeHandle::FVE408:
case FVE408:
Handle = std::make_shared<TFVE408>();
break;
case TBrakeHandle::testH:
case testH:
Handle = std::make_shared<Ttest>();
break;
case TBrakeHandle::M394:
case M394:
Handle = std::make_shared<TM394>();
break;
case TBrakeHandle::Knorr:
case Knorr:
Handle = std::make_shared<TH14K1>();
break;
case TBrakeHandle::St113:
case St113:
Handle = std::make_shared<TSt113>();
break;
case TBrakeHandle::MHZ_K5P:
case MHZ_K5P:
Handle = std::make_shared<TMHZ_K5P>();
break;
case TBrakeHandle::MHZ_6P:
case MHZ_6P:
Handle = std::make_shared<TMHZ_6P>();
break;
default:

View File

@@ -233,13 +233,14 @@ sound_source::deserialize_mapping( cParser &Input ) {
m_crossfaderange = std::clamp( m_crossfaderange, 0, 100 );
}
else if( key == "placement:" ) {
using enum sound_placement;
auto const value { Input.getToken<std::string>( true, "\n\r\t ,;" ) };
std::map<std::string, sound_placement> const placements {
{ "internal", sound_placement::internal },
{ "engine", sound_placement::engine },
{ "external", sound_placement::external },
{ "custom", sound_placement::custom },
{ "general", sound_placement::general } };
{ "internal", internal },
{ "engine", engine },
{ "external", external },
{ "custom", custom },
{ "general", general } };
auto lookup{ placements.find( value ) };
if( lookup != placements.end() ) {
m_placement = lookup->second;

View File

@@ -22,276 +22,277 @@ driverkeyboard_input::init() {
void
driverkeyboard_input::default_bindings() {
using enum user_command;
m_bindingsetups = {
{ user_command::aidriverenable, {GLFW_KEY_Q | keymodifier::shift, ""} },
{ user_command::aidriverdisable, {GLFW_KEY_Q, ""} },
{ aidriverenable, {GLFW_KEY_Q | keymodifier::shift, ""} },
{ aidriverdisable, {GLFW_KEY_Q, ""} },
// jointcontrollerset,
{ user_command::mastercontrollerincrease, {GLFW_KEY_KP_ADD, ""} },
{ user_command::mastercontrollerincreasefast, {GLFW_KEY_KP_ADD | keymodifier::shift, ""} },
{ user_command::mastercontrollerdecrease, {GLFW_KEY_KP_SUBTRACT, ""} },
{ user_command::mastercontrollerdecreasefast, {GLFW_KEY_KP_SUBTRACT | keymodifier::shift, ""} },
{ mastercontrollerincrease, {GLFW_KEY_KP_ADD, ""} },
{ mastercontrollerincreasefast, {GLFW_KEY_KP_ADD | keymodifier::shift, ""} },
{ mastercontrollerdecrease, {GLFW_KEY_KP_SUBTRACT, ""} },
{ mastercontrollerdecreasefast, {GLFW_KEY_KP_SUBTRACT | keymodifier::shift, ""} },
// mastercontrollerset,
{ user_command::dynamicbrakecontrollerincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} },
{ user_command::dynamicbrakecontrollerdecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} },
{ dynamicbrakecontrollerincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} },
{ dynamicbrakecontrollerdecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} },
// mastercontrollerset,
{ user_command::dynamicbrakecontrollerincreasefast, {GLFW_KEY_KP_3 | keymodifier::control | keymodifier::shift, ""} },
{ user_command::dynamicbrakecontrollerdecreasefast, {GLFW_KEY_KP_9 | keymodifier::control | keymodifier::shift, ""} },
{ dynamicbrakecontrollerincreasefast, {GLFW_KEY_KP_3 | keymodifier::control | keymodifier::shift, ""} },
{ dynamicbrakecontrollerdecreasefast, {GLFW_KEY_KP_9 | keymodifier::control | keymodifier::shift, ""} },
{ user_command::secondcontrollerincrease, {GLFW_KEY_KP_DIVIDE, ""} },
{ user_command::secondcontrollerincreasefast, {GLFW_KEY_KP_DIVIDE | keymodifier::shift, ""} },
{ user_command::secondcontrollerdecrease, {GLFW_KEY_KP_MULTIPLY, ""} },
{ user_command::secondcontrollerdecreasefast, {GLFW_KEY_KP_MULTIPLY | keymodifier::shift, ""} },
{ secondcontrollerincrease, {GLFW_KEY_KP_DIVIDE, ""} },
{ secondcontrollerincreasefast, {GLFW_KEY_KP_DIVIDE | keymodifier::shift, ""} },
{ secondcontrollerdecrease, {GLFW_KEY_KP_MULTIPLY, ""} },
{ secondcontrollerdecreasefast, {GLFW_KEY_KP_MULTIPLY | keymodifier::shift, ""} },
// secondcontrollerset,
{ user_command::mucurrentindicatorothersourceactivate, {GLFW_KEY_Z | keymodifier::shift, ""} },
{ user_command::independentbrakeincrease, {GLFW_KEY_KP_1, ""} },
{ user_command::independentbrakeincreasefast, {GLFW_KEY_KP_1 | keymodifier::shift, ""} },
{ user_command::independentbrakedecrease, {GLFW_KEY_KP_7, ""} },
{ user_command::independentbrakedecreasefast, {GLFW_KEY_KP_7 | keymodifier::shift, ""} },
{ mucurrentindicatorothersourceactivate, {GLFW_KEY_Z | keymodifier::shift, ""} },
{ independentbrakeincrease, {GLFW_KEY_KP_1, ""} },
{ independentbrakeincreasefast, {GLFW_KEY_KP_1 | keymodifier::shift, ""} },
{ independentbrakedecrease, {GLFW_KEY_KP_7, ""} },
{ independentbrakedecreasefast, {GLFW_KEY_KP_7 | keymodifier::shift, ""} },
// independentbrakeset,
{ user_command::independentbrakebailoff, {GLFW_KEY_KP_4, ""} },
{ independentbrakebailoff, {GLFW_KEY_KP_4, ""} },
// universalbrakebutton1,
// universalbrakebutton2,
// universalbrakebutton3,
{ user_command::trainbrakeincrease, {GLFW_KEY_KP_3, ""} },
{ user_command::trainbrakedecrease, {GLFW_KEY_KP_9, ""} },
{ trainbrakeincrease, {GLFW_KEY_KP_3, ""} },
{ trainbrakedecrease, {GLFW_KEY_KP_9, ""} },
// trainbrakeset,
{ user_command::trainbrakecharging, {GLFW_KEY_KP_DECIMAL, ""} },
{ user_command::trainbrakerelease, {GLFW_KEY_KP_6, ""} },
{ user_command::trainbrakefirstservice, {GLFW_KEY_KP_8, ""} },
{ user_command::trainbrakeservice, {GLFW_KEY_KP_5, ""} },
{ user_command::trainbrakefullservice, {GLFW_KEY_KP_2, ""} },
{ user_command::trainbrakehandleoff, {GLFW_KEY_KP_5 | keymodifier::control, ""} },
{ user_command::trainbrakeemergency, {GLFW_KEY_KP_0, ""} },
{ user_command::trainbrakebasepressureincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} },
{ user_command::trainbrakebasepressuredecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} },
{ user_command::trainbrakebasepressurereset, {GLFW_KEY_KP_6 | keymodifier::control, ""} },
{ user_command::trainbrakeoperationtoggle, {GLFW_KEY_KP_4 | keymodifier::control, ""} },
{ user_command::manualbrakeincrease, {GLFW_KEY_KP_1 | keymodifier::control, ""} },
{ user_command::manualbrakedecrease, {GLFW_KEY_KP_7 | keymodifier::control, ""} },
{ user_command::alarmchaintoggle, {GLFW_KEY_B | keymodifier::shift | keymodifier::control, ""} },
{ trainbrakecharging, {GLFW_KEY_KP_DECIMAL, ""} },
{ trainbrakerelease, {GLFW_KEY_KP_6, ""} },
{ trainbrakefirstservice, {GLFW_KEY_KP_8, ""} },
{ trainbrakeservice, {GLFW_KEY_KP_5, ""} },
{ trainbrakefullservice, {GLFW_KEY_KP_2, ""} },
{ trainbrakehandleoff, {GLFW_KEY_KP_5 | keymodifier::control, ""} },
{ trainbrakeemergency, {GLFW_KEY_KP_0, ""} },
{ trainbrakebasepressureincrease, {GLFW_KEY_KP_3 | keymodifier::control, ""} },
{ trainbrakebasepressuredecrease, {GLFW_KEY_KP_9 | keymodifier::control, ""} },
{ trainbrakebasepressurereset, {GLFW_KEY_KP_6 | keymodifier::control, ""} },
{ trainbrakeoperationtoggle, {GLFW_KEY_KP_4 | keymodifier::control, ""} },
{ manualbrakeincrease, {GLFW_KEY_KP_1 | keymodifier::control, ""} },
{ manualbrakedecrease, {GLFW_KEY_KP_7 | keymodifier::control, ""} },
{ alarmchaintoggle, {GLFW_KEY_B | keymodifier::shift | keymodifier::control, ""} },
// alarmchainenable,
// alarmchaindisable,
{ user_command::wheelspinbrakeactivate, {GLFW_KEY_KP_ENTER, ""} },
{ user_command::sandboxactivate, {GLFW_KEY_S | keymodifier::shift, ""} },
{ wheelspinbrakeactivate, {GLFW_KEY_KP_ENTER, ""} },
{ sandboxactivate, {GLFW_KEY_S | keymodifier::shift, ""} },
// autosandboxtoggle,
// autosandboxactivate,
// autosandboxdeactivate,
{ user_command::reverserincrease, {GLFW_KEY_D, ""} },
{ user_command::reverserdecrease, {GLFW_KEY_R, ""} },
{ reverserincrease, {GLFW_KEY_D, ""} },
{ reverserdecrease, {GLFW_KEY_R, ""} },
// reverserforwardhigh,
// reverserforward,
// reverserneutral,
// reverserbackward,
{ user_command::waterpumpbreakertoggle, {GLFW_KEY_W | keymodifier::control, ""} },
{ waterpumpbreakertoggle, {GLFW_KEY_W | keymodifier::control, ""} },
// waterpumpbreakerclose,
// waterpumpbreakeropen,
{ user_command::waterpumptoggle, {GLFW_KEY_W, ""} },
{ waterpumptoggle, {GLFW_KEY_W, ""} },
// waterpumpenable,
// waterpumpdisable,
{ user_command::waterheaterbreakertoggle, {GLFW_KEY_W | keymodifier::control | keymodifier::shift, ""} },
{ waterheaterbreakertoggle, {GLFW_KEY_W | keymodifier::control | keymodifier::shift, ""} },
// waterheaterbreakerclose,
// waterheaterbreakeropen,
{ user_command::waterheatertoggle, {GLFW_KEY_W | keymodifier::shift, ""} },
{ waterheatertoggle, {GLFW_KEY_W | keymodifier::shift, ""} },
// waterheaterenable,
// waterheaterdisable,
{ user_command::watercircuitslinktoggle, {GLFW_KEY_H | keymodifier::shift, ""} },
{ watercircuitslinktoggle, {GLFW_KEY_H | keymodifier::shift, ""} },
// watercircuitslinkenable,
// watercircuitslinkdisable,
{ user_command::fuelpumptoggle, {GLFW_KEY_F, ""} },
{ fuelpumptoggle, {GLFW_KEY_F, ""} },
// fuelpumpenable,
// fuelpumpdisable,
{ user_command::oilpumptoggle, {GLFW_KEY_F | keymodifier::shift, ""} },
{ oilpumptoggle, {GLFW_KEY_F | keymodifier::shift, ""} },
// oilpumpenable,
// oilpumpdisable,
{ user_command::linebreakertoggle, {GLFW_KEY_M, ""} },
{ linebreakertoggle, {GLFW_KEY_M, ""} },
// linebreakeropen,
// linebreakerclose,
{ user_command::convertertoggle, {GLFW_KEY_X, ""} },
{ convertertoggle, {GLFW_KEY_X, ""} },
// converterenable,
// converterdisable,
{ user_command::convertertogglelocal, {GLFW_KEY_X | keymodifier::shift, ""} },
{ user_command::converteroverloadrelayreset, {GLFW_KEY_N | keymodifier::control, ""} },
{ user_command::compressortoggle, {GLFW_KEY_C, ""} },
{ convertertogglelocal, {GLFW_KEY_X | keymodifier::shift, ""} },
{ converteroverloadrelayreset, {GLFW_KEY_N | keymodifier::control, ""} },
{ compressortoggle, {GLFW_KEY_C, ""} },
// compressorenable,
// compressordisable,
{ user_command::compressortogglelocal, {GLFW_KEY_C | keymodifier::shift, ""} },
{ compressortogglelocal, {GLFW_KEY_C | keymodifier::shift, ""} },
// compressorpresetactivatenext,
// compressorpresetactivateprevious,
// compressorpresetactivatedefault,
{ user_command::motoroverloadrelaythresholdtoggle, {GLFW_KEY_F | keymodifier::control, ""} },
{ motoroverloadrelaythresholdtoggle, {GLFW_KEY_F | keymodifier::control, ""} },
// motoroverloadrelaythresholdsetlow,
// motoroverloadrelaythresholdsethigh,
{ user_command::motoroverloadrelayreset, {GLFW_KEY_N, ""} },
{ motoroverloadrelayreset, {GLFW_KEY_N, ""} },
// universalrelayreset1,
// universalrelayreset2,
// universalrelayreset3,
{ user_command::notchingrelaytoggle, {GLFW_KEY_G, ""} },
{ user_command::epbrakecontroltoggle, {GLFW_KEY_Z | keymodifier::control, ""} },
{ notchingrelaytoggle, {GLFW_KEY_G, ""} },
{ epbrakecontroltoggle, {GLFW_KEY_Z | keymodifier::control, ""} },
// epbrakecontrolenable
// epbrakecontroldisable
{ user_command::trainbrakeoperationmodeincrease, {GLFW_KEY_KP_2 | keymodifier::control, ""} },
{ user_command::trainbrakeoperationmodedecrease, {GLFW_KEY_KP_8 | keymodifier::control, ""} },
{ user_command::brakeactingspeedincrease, {GLFW_KEY_B | keymodifier::shift, ""} },
{ user_command::brakeactingspeeddecrease, {GLFW_KEY_B, ""} },
{ trainbrakeoperationmodeincrease, {GLFW_KEY_KP_2 | keymodifier::control, ""} },
{ trainbrakeoperationmodedecrease, {GLFW_KEY_KP_8 | keymodifier::control, ""} },
{ brakeactingspeedincrease, {GLFW_KEY_B | keymodifier::shift, ""} },
{ brakeactingspeeddecrease, {GLFW_KEY_B, ""} },
// brakeactingspeedsetcargo,
// brakeactingspeedsetpassenger,
// brakeactingspeedsetrapid,
{ user_command::brakeloadcompensationincrease, {GLFW_KEY_H | keymodifier::shift | keymodifier::control, ""} },
{ user_command::brakeloadcompensationdecrease, {GLFW_KEY_H | keymodifier::control, ""} },
{ user_command::mubrakingindicatortoggle, {GLFW_KEY_L | keymodifier::shift, ""} },
{ user_command::alerteracknowledge, {GLFW_KEY_SPACE, ""} },
{ user_command::hornlowactivate, {GLFW_KEY_A, ""} },
{ user_command::hornhighactivate, {GLFW_KEY_S, ""} },
{ user_command::whistleactivate, {GLFW_KEY_Z, ""} },
{ user_command::radiotoggle, {GLFW_KEY_R | keymodifier::control, ""} },
{ brakeloadcompensationincrease, {GLFW_KEY_H | keymodifier::shift | keymodifier::control, ""} },
{ brakeloadcompensationdecrease, {GLFW_KEY_H | keymodifier::control, ""} },
{ mubrakingindicatortoggle, {GLFW_KEY_L | keymodifier::shift, ""} },
{ alerteracknowledge, {GLFW_KEY_SPACE, ""} },
{ hornlowactivate, {GLFW_KEY_A, ""} },
{ hornhighactivate, {GLFW_KEY_S, ""} },
{ whistleactivate, {GLFW_KEY_Z, ""} },
{ radiotoggle, {GLFW_KEY_R | keymodifier::control, ""} },
// radioenable
// radiodisable
{ user_command::radiochannelincrease, {GLFW_KEY_EQUAL, ""} },
{ user_command::radiochanneldecrease, {GLFW_KEY_MINUS, ""} },
{ radiochannelincrease, {GLFW_KEY_EQUAL, ""} },
{ radiochanneldecrease, {GLFW_KEY_MINUS, ""} },
// radiochannelset
{ user_command::radiostopsend, {GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control, ""} },
{ radiostopsend, {GLFW_KEY_PAUSE | keymodifier::shift | keymodifier::control, ""} },
// radiostopenable
// radiostopdisable
{ user_command::radiostoptest, {GLFW_KEY_R | keymodifier::shift | keymodifier::control, ""} },
{ user_command::radiocall3send, {GLFW_KEY_BACKSPACE, ""} },
{ radiostoptest, {GLFW_KEY_R | keymodifier::shift | keymodifier::control, ""} },
{ radiocall3send, {GLFW_KEY_BACKSPACE, ""} },
// radiovolumeincrease,
// radiovolumedecrease,
// radiovolumeset,
{ user_command::cabchangeforward, {GLFW_KEY_HOME, ""} },
{ user_command::cabchangebackward, {GLFW_KEY_END, ""} },
{ cabchangeforward, {GLFW_KEY_HOME, ""} },
{ cabchangebackward, {GLFW_KEY_END, ""} },
// viewturn,
// movehorizontal,
// movehorizontalfast,
// movevertical,
// moveverticalfast,
{ user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
{ user_command::nearestcarcouplingincrease, {GLFW_KEY_INSERT, ""} },
{ user_command::nearestcarcouplingdisconnect, {GLFW_KEY_DELETE, ""} },
{ user_command::nearestcarcoupleradapterattach, {GLFW_KEY_INSERT | keymodifier::control, ""} },
{ user_command::nearestcarcoupleradapterremove, {GLFW_KEY_DELETE | keymodifier::control, ""} },
{ user_command::occupiedcarcouplingdisconnect, {GLFW_KEY_DELETE | keymodifier::shift, ""} },
{ user_command::doortoggleleft, {GLFW_KEY_COMMA, ""} },
{ user_command::doortoggleright, {GLFW_KEY_PERIOD, ""} },
{ user_command::doorpermitleft, {GLFW_KEY_COMMA | keymodifier::shift, ""} },
{ user_command::doorpermitright, {GLFW_KEY_PERIOD | keymodifier::shift, ""} },
{ user_command::doorpermitpresetactivatenext, {GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control, ""} },
{ user_command::doorpermitpresetactivateprevious, {GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control, ""} },
{ moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
{ nearestcarcouplingincrease, {GLFW_KEY_INSERT, ""} },
{ nearestcarcouplingdisconnect, {GLFW_KEY_DELETE, ""} },
{ nearestcarcoupleradapterattach, {GLFW_KEY_INSERT | keymodifier::control, ""} },
{ nearestcarcoupleradapterremove, {GLFW_KEY_DELETE | keymodifier::control, ""} },
{ occupiedcarcouplingdisconnect, {GLFW_KEY_DELETE | keymodifier::shift, ""} },
{ doortoggleleft, {GLFW_KEY_COMMA, ""} },
{ doortoggleright, {GLFW_KEY_PERIOD, ""} },
{ doorpermitleft, {GLFW_KEY_COMMA | keymodifier::shift, ""} },
{ doorpermitright, {GLFW_KEY_PERIOD | keymodifier::shift, ""} },
{ doorpermitpresetactivatenext, {GLFW_KEY_PERIOD | keymodifier::shift | keymodifier::control, ""} },
{ doorpermitpresetactivateprevious, {GLFW_KEY_COMMA | keymodifier::shift | keymodifier::control, ""} },
// dooropenleft,
// dooropenright,
{ user_command::dooropenall, {GLFW_KEY_SLASH | keymodifier::shift, ""} },
{ dooropenall, {GLFW_KEY_SLASH | keymodifier::shift, ""} },
// doorcloseleft,
// doorcloseright,
{ user_command::doorcloseall, {GLFW_KEY_SLASH | keymodifier::control, ""} },
{ doorcloseall, {GLFW_KEY_SLASH | keymodifier::control, ""} },
// doorsteptoggle,
{ user_command::doormodetoggle, {GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control, ""} },
{ doormodetoggle, {GLFW_KEY_SLASH | keymodifier::shift | keymodifier::control, ""} },
// mirrorstoggle,
{ user_command::departureannounce, {GLFW_KEY_SLASH, ""} },
{ user_command::doorlocktoggle, {GLFW_KEY_S | keymodifier::control, ""} },
{ user_command::pantographcompressorvalvetoggle, {GLFW_KEY_V | keymodifier::control, ""} },
{ departureannounce, {GLFW_KEY_SLASH, ""} },
{ doorlocktoggle, {GLFW_KEY_S | keymodifier::control, ""} },
{ pantographcompressorvalvetoggle, {GLFW_KEY_V | keymodifier::control, ""} },
// pantographcompressorvalveenable,
// pantographcompressorvalvedisable,
{ user_command::pantographcompressoractivate, {GLFW_KEY_V | keymodifier::shift, ""} },
{ user_command::pantographtogglefront, {GLFW_KEY_P, ""} },
{ user_command::pantographtogglerear, {GLFW_KEY_O, ""} },
{ pantographcompressoractivate, {GLFW_KEY_V | keymodifier::shift, ""} },
{ pantographtogglefront, {GLFW_KEY_P, ""} },
{ pantographtogglerear, {GLFW_KEY_O, ""} },
// pantographraisefront,
// pantographraiserear,
// pantographlowerfront,
// pantographlowerrear,
{ user_command::pantographlowerall, {GLFW_KEY_P | keymodifier::control, ""} },
{ user_command::pantographselectnext, {GLFW_KEY_P | keymodifier::shift, ""} },
{ user_command::pantographselectprevious, {GLFW_KEY_O | keymodifier::shift, ""} },
{ user_command::pantographtoggleselected, {GLFW_KEY_O | keymodifier::shift | keymodifier::control, ""} },
{ pantographlowerall, {GLFW_KEY_P | keymodifier::control, ""} },
{ pantographselectnext, {GLFW_KEY_P | keymodifier::shift, ""} },
{ pantographselectprevious, {GLFW_KEY_O | keymodifier::shift, ""} },
{ pantographtoggleselected, {GLFW_KEY_O | keymodifier::shift | keymodifier::control, ""} },
// pantographraiseselected,
// pantographlowerselected,
// pantographvalvesupdate,
// pantographvalvesoff,
{ user_command::heatingtoggle, {GLFW_KEY_H, ""} },
{ heatingtoggle, {GLFW_KEY_H, ""} },
// heatingenable,
// heatingdisable,
{ user_command::lightspresetactivatenext, {GLFW_KEY_T | keymodifier::shift, ""} },
{ user_command::lightspresetactivateprevious, {GLFW_KEY_T, ""} },
{ user_command::headlighttoggleleft, {GLFW_KEY_Y, ""} },
{ lightspresetactivatenext, {GLFW_KEY_T | keymodifier::shift, ""} },
{ lightspresetactivateprevious, {GLFW_KEY_T, ""} },
{ headlighttoggleleft, {GLFW_KEY_Y, ""} },
// headlightenableleft,
// headlightdisableleft,
{ user_command::headlighttoggleright, {GLFW_KEY_I, ""} },
{ headlighttoggleright, {GLFW_KEY_I, ""} },
// headlightenableright,
// headlightdisableright,
{ user_command::headlighttoggleupper, {GLFW_KEY_U, ""} },
{ headlighttoggleupper, {GLFW_KEY_U, ""} },
// headlightenableupper,
// headlightdisableupper,
{ user_command::redmarkertoggleleft, {GLFW_KEY_Y | keymodifier::shift, ""} },
{ redmarkertoggleleft, {GLFW_KEY_Y | keymodifier::shift, ""} },
// redmarkerenableleft,
// redmarkerdisableleft,
{ user_command::redmarkertoggleright, {GLFW_KEY_I | keymodifier::shift, ""} },
{ redmarkertoggleright, {GLFW_KEY_I | keymodifier::shift, ""} },
// redmarkerenableright,
// redmarkerdisableright,
{ user_command::headlighttogglerearleft, {GLFW_KEY_Y | keymodifier::control, ""} },
{ headlighttogglerearleft, {GLFW_KEY_Y | keymodifier::control, ""} },
// headlightenablerearleft
// headlightdisablerearleft
{ user_command::headlighttogglerearright, {GLFW_KEY_I | keymodifier::control, ""} },
{ headlighttogglerearright, {GLFW_KEY_I | keymodifier::control, ""} },
// headlightenablerearright
// headlightdisablerearright
{ user_command::headlighttogglerearupper, {GLFW_KEY_U | keymodifier::control, ""} },
{ headlighttogglerearupper, {GLFW_KEY_U | keymodifier::control, ""} },
// headlightenablerearupper
// headlightdisablerearupper
{ user_command::redmarkertogglerearleft, {GLFW_KEY_Y | keymodifier::control | keymodifier::shift, ""} },
{ redmarkertogglerearleft, {GLFW_KEY_Y | keymodifier::control | keymodifier::shift, ""} },
// redmarkerenablerearleft
// redmarkerdisablerearleft
{ user_command::redmarkertogglerearright, {GLFW_KEY_I | keymodifier::control | keymodifier::shift, ""} },
{ redmarkertogglerearright, {GLFW_KEY_I | keymodifier::control | keymodifier::shift, ""} },
// redmarkerenablerearright
// redmarkerdisablerearright
{ user_command::redmarkerstoggle, {GLFW_KEY_E | keymodifier::shift, ""} },
{ user_command::endsignalstoggle, {GLFW_KEY_E, ""} },
{ user_command::headlightsdimtoggle, {GLFW_KEY_L | keymodifier::control, ""} },
{ redmarkerstoggle, {GLFW_KEY_E | keymodifier::shift, ""} },
{ endsignalstoggle, {GLFW_KEY_E, ""} },
{ headlightsdimtoggle, {GLFW_KEY_L | keymodifier::control, ""} },
// headlightsdimenable,
// headlightsdimdisable,
{ user_command::motorconnectorsopen, {GLFW_KEY_L, ""} },
{ motorconnectorsopen, {GLFW_KEY_L, ""} },
// motorconnectorsclose,
{ user_command::motordisconnect, {GLFW_KEY_E | keymodifier::control, ""} },
{ user_command::interiorlighttoggle, {GLFW_KEY_APOSTROPHE, ""} },
{ motordisconnect, {GLFW_KEY_E | keymodifier::control, ""} },
{ interiorlighttoggle, {GLFW_KEY_APOSTROPHE, ""} },
// interiorlightenable,
// interiorlightdisable,
{ user_command::interiorlightdimtoggle, {GLFW_KEY_APOSTROPHE | keymodifier::control, ""} },
{ interiorlightdimtoggle, {GLFW_KEY_APOSTROPHE | keymodifier::control, ""} },
// interiorlightdimenable,
// interiorlightdimdisable,
// compartmentlightstoggle,
// compartmentlightsenable,
// compartmentlightsdisable,
{ user_command::instrumentlighttoggle, {GLFW_KEY_SEMICOLON, ""} },
{ instrumentlighttoggle, {GLFW_KEY_SEMICOLON, ""} },
// instrumentlightenable,
// instrumentlightdisable,
{ user_command::dashboardlighttoggle, {GLFW_KEY_SEMICOLON | keymodifier::shift, ""} },
{ dashboardlighttoggle, {GLFW_KEY_SEMICOLON | keymodifier::shift, ""} },
// dashboardlightenable
// dashboardlightdisable
{ user_command::timetablelighttoggle, {GLFW_KEY_APOSTROPHE | keymodifier::shift, ""} },
{ timetablelighttoggle, {GLFW_KEY_APOSTROPHE | keymodifier::shift, ""} },
// timetablelightenable
// timetablelightdisable
{ user_command::generictoggle0, {GLFW_KEY_0, ""} },
{ user_command::generictoggle1, {GLFW_KEY_1, ""} },
{ user_command::generictoggle2, {GLFW_KEY_2, ""} },
{ user_command::generictoggle3, {GLFW_KEY_3, ""} },
{ user_command::generictoggle4, {GLFW_KEY_4, ""} },
{ user_command::generictoggle5, {GLFW_KEY_5, ""} },
{ user_command::generictoggle6, {GLFW_KEY_6, ""} },
{ user_command::generictoggle7, {GLFW_KEY_7, ""} },
{ user_command::generictoggle8, {GLFW_KEY_8, ""} },
{ user_command::generictoggle9, {GLFW_KEY_9, ""} },
{ user_command::batterytoggle, {GLFW_KEY_J, ""} },
{ generictoggle0, {GLFW_KEY_0, ""} },
{ generictoggle1, {GLFW_KEY_1, ""} },
{ generictoggle2, {GLFW_KEY_2, ""} },
{ generictoggle3, {GLFW_KEY_3, ""} },
{ generictoggle4, {GLFW_KEY_4, ""} },
{ generictoggle5, {GLFW_KEY_5, ""} },
{ generictoggle6, {GLFW_KEY_6, ""} },
{ generictoggle7, {GLFW_KEY_7, ""} },
{ generictoggle8, {GLFW_KEY_8, ""} },
{ generictoggle9, {GLFW_KEY_9, ""} },
{ batterytoggle, {GLFW_KEY_J, ""} },
// batteryenable,
// batterydisable,
// cabactivationtoggle,
// cabactivationenable,
// cabactivationdisable,
{ user_command::motorblowerstogglefront, {GLFW_KEY_N | keymodifier::shift, ""} },
{ user_command::motorblowerstogglerear, {GLFW_KEY_M | keymodifier::shift, ""} },
{ user_command::motorblowersdisableall, {GLFW_KEY_M | keymodifier::control, ""} },
{ motorblowerstogglefront, {GLFW_KEY_N | keymodifier::shift, ""} },
{ motorblowerstogglerear, {GLFW_KEY_M | keymodifier::shift, ""} },
{ motorblowersdisableall, {GLFW_KEY_M | keymodifier::control, ""} },
// coolingfanstoggle,
// tempomattoggle,
// springbraketoggle,
@@ -317,14 +318,14 @@ driverkeyboard_input::default_bindings() {
// speedcontrolbutton8,
// speedcontrolbutton9,
// admin_timejump,
{ user_command::timejumplarge, {GLFW_KEY_F1 | keymodifier::control, "Big time jump (Debug Mode only)"} },
{ user_command::timejumpsmall, {GLFW_KEY_F1 | keymodifier::shift, "Small time jump (Debug Mode only)"} },
{ timejumplarge, {GLFW_KEY_F1 | keymodifier::control, "Big time jump (Debug Mode only)"} },
{ timejumpsmall, {GLFW_KEY_F1 | keymodifier::shift, "Small time jump (Debug Mode only)"} },
// admin_vehiclemove,
{ user_command::vehiclemoveforwards, {GLFW_KEY_LEFT_BRACKET | keymodifier::control, "Move the train forwards (Debug Mode only)"} },
{ user_command::vehiclemovebackwards, {GLFW_KEY_RIGHT_BRACKET | keymodifier::control, "Move the train backwards (Debug Mode only)"} },
{ user_command::vehicleboost, {GLFW_KEY_TAB | keymodifier::control, "Boost the train (Debug Mode only)"} },
{ user_command::debugtoggle, {GLFW_KEY_F12 | keymodifier::control | keymodifier::shift, "Toggle Debug Mode"} },
{ user_command::pausetoggle, {GLFW_KEY_ESCAPE, "Pause the game"} }
{ vehiclemoveforwards, {GLFW_KEY_LEFT_BRACKET | keymodifier::control, "Move the train forwards (Debug Mode only)"} },
{ vehiclemovebackwards, {GLFW_KEY_RIGHT_BRACKET | keymodifier::control, "Move the train backwards (Debug Mode only)"} },
{ vehicleboost, {GLFW_KEY_TAB | keymodifier::control, "Boost the train (Debug Mode only)"} },
{ debugtoggle, {GLFW_KEY_F12 | keymodifier::control | keymodifier::shift, "Toggle Debug Mode"} },
{ pausetoggle, {GLFW_KEY_ESCAPE, "Pause the game"} }
};
}

File diff suppressed because it is too large Load Diff

View File

@@ -31,25 +31,26 @@ editorkeyboard_input::apply_scheme() {
void
editorkeyboard_input::default_bindings() {
using enum user_command;
if (EditorSettings.movement() == editorSettings::movement_scheme::legacy) {
m_bindingsetups = {
{ user_command::moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ user_command::moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ user_command::moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ user_command::moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ user_command::moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ user_command::movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
{ moveleft, {GLFW_KEY_LEFT, "Move left"} },
{ moveright, {GLFW_KEY_RIGHT, "Move right"} },
{ moveforward, {GLFW_KEY_UP, "Move forwards"} },
{ moveback, {GLFW_KEY_DOWN, "Move backwards"} },
{ moveup, {GLFW_KEY_PAGE_UP, "Move up"} },
{ movedown, {GLFW_KEY_PAGE_DOWN, "Move down"} },
};
}
else {
m_bindingsetups = {
{ user_command::moveleft, {GLFW_KEY_A, "Move left"} },
{ user_command::moveright, {GLFW_KEY_D, "Move right"} },
{ user_command::moveforward, {GLFW_KEY_W, "Move forwards"} },
{ user_command::moveback, {GLFW_KEY_S, "Move backwards"} },
{ user_command::moveup, {GLFW_KEY_E, "Move up"} },
{ user_command::movedown, {GLFW_KEY_Q, "Move down"} },
{ moveleft, {GLFW_KEY_A, "Move left"} },
{ moveright, {GLFW_KEY_D, "Move right"} },
{ moveforward, {GLFW_KEY_W, "Move forwards"} },
{ moveback, {GLFW_KEY_S, "Move backwards"} },
{ moveup, {GLFW_KEY_E, "Move up"} },
{ movedown, {GLFW_KEY_Q, "Move down"} },
};
}
}

View File

@@ -228,12 +228,13 @@ gamepad_input::recall_bindings() {
std::get<0>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) = bindingtype;
// retrieve regular commands associated with the axis and mode
switch( bindingtype ) {
case input_type::value:
case input_type::value_invert: {
using enum gamepad_input::input_type;
case value:
case value_invert: {
bindingtargets.emplace_back( std::ref( std::get<1>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) );
break;
}
case input_type::threestate: {
case threestate: {
bindingtargets.emplace_back( std::ref( std::get<1>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) );
bindingtargets.emplace_back( std::ref( std::get<2>( m_inputaxes[ axisindex ].bindings[ controlmode ] ) ) );
break;
@@ -463,12 +464,13 @@ gamepad_input::process_axes() {
}
// scale passed value according to command type
switch( boundcommand1 ) {
case user_command::viewturn: {
using enum user_command;
case viewturn: {
param *= 10.0 * ( Timer::GetDeltaRenderTime() * 60.0 );
break;
}
case user_command::movehorizontal:
case user_command::movehorizontalfast: {
case movehorizontal:
case movehorizontalfast: {
// these expect value in -1:1 range
break;
}

View File

@@ -328,6 +328,7 @@ keyboard_input::key( int const Key ) const {
void
keyboard_input::bind() {
using enum user_command;
m_bindings.clear();
for( auto const &[setupcommand, setupbinding] : m_bindingsetups ) {
@@ -336,12 +337,12 @@ keyboard_input::bind() {
}
// cache movement key bindings
m_bindingscache.forward = binding( user_command::moveforward );
m_bindingscache.back = binding( user_command::moveback );
m_bindingscache.left = binding( user_command::moveleft );
m_bindingscache.right = binding( user_command::moveright );
m_bindingscache.up = binding( user_command::moveup );
m_bindingscache.down = binding( user_command::movedown );
m_bindingscache.forward = binding( moveforward );
m_bindingscache.back = binding( moveback );
m_bindingscache.left = binding( moveleft );
m_bindingscache.right = binding( moveright );
m_bindingscache.up = binding( moveup );
m_bindingscache.down = binding( movedown );
}
int

View File

@@ -60,23 +60,24 @@ void ui::vehicles_bank::parse_entry(const std::string &line)
void ui::vehicles_bank::parse_category_entry(const std::string &param)
{
using enum ui::vehicle_type;
static std::unordered_map<char, vehicle_type> type_map = {
{ 'e', vehicle_type::electric_loco },
{ 's', vehicle_type::diesel_loco },
{ 'p', vehicle_type::steam_loco },
{ 'a', vehicle_type::railcar },
{ 'z', vehicle_type::emu },
{ 'r', vehicle_type::utility },
{ 'd', vehicle_type::draisine },
{ 't', vehicle_type::tram },
{ 'c', vehicle_type::truck },
{ 'b', vehicle_type::bus },
{ 'o', vehicle_type::car },
{ 'h', vehicle_type::man },
{ 'f', vehicle_type::animal },
{ 'e', electric_loco },
{ 's', diesel_loco },
{ 'p', steam_loco },
{ 'a', railcar },
{ 'z', emu },
{ 'r', utility },
{ 'd', draisine },
{ 't', tram },
{ 'c', truck },
{ 'b', bus },
{ 'o', car },
{ 'h', man },
{ 'f', animal },
};
ctx_type = vehicle_type::unknown;
ctx_type = unknown;
std::istringstream stream(param);
@@ -89,7 +90,7 @@ void ui::vehicles_bank::parse_category_entry(const std::string &param)
if (auto it = type_map.find(tok[0]); it != type_map.end())
ctx_type = it->second;
else if (tok[0] >= 'A' && tok[0] <= 'Z')
ctx_type = vehicle_type::carriage;
ctx_type = carriage;
std::string mini;
std::getline(stream, mini, ',');

View File

@@ -388,17 +388,18 @@ basic_controller::log_error( std::string const &Error, int const Line ) const {
auto
basic_controller::guess_element_type_from_name( std::string const &Name ) const -> basic_element::type_e {
using enum plc::basic_element::type_e;
auto const [nametype, nameindex]{ split_string_and_number( Name ) };
if( nametype == "t" || nametype == "ton" || nametype.find("timer.") == 0 ) {
return basic_element::type_e::timer;
return timer;
}
if( nametype == "c" || nametype.find("counter.") == 0 ) {
return basic_element::type_e::counter;
return counter;
}
return basic_element::type_e::variable;
return variable;
}
} // plc

View File

@@ -27,12 +27,13 @@ enum class comparison_pass {
template <typename Type_>
bool compare( Type_ const Left, Type_ const Right, comparison_operator const Operator ) {
switch( Operator ) {
case comparison_operator::equal: { return Left == Right; }
case comparison_operator::not_equal: { return Left != Right; }
case comparison_operator::lt: { return Left < Right; }
case comparison_operator::gt: { return Left > Right; }
case comparison_operator::lt_eq: { return Left <= Right; }
case comparison_operator::gt_eq: { return Left >= Right; }
using enum comparison_operator;
case equal: { return Left == Right; }
case not_equal: { return Left != Right; }
case lt: { return Left < Right; }
case gt: { return Left > Right; }
case lt_eq: { return Left <= Right; }
case gt_eq: { return Left >= Right; }
default: { return false; }
}
}
@@ -41,12 +42,13 @@ inline
std::string
to_string( comparison_operator const Operator ) {
switch( Operator ) {
case comparison_operator::equal: { return "=="; }
case comparison_operator::not_equal: { return "!="; }
case comparison_operator::lt: { return "<"; }
case comparison_operator::gt: { return ">"; }
case comparison_operator::lt_eq: { return "<="; }
case comparison_operator::gt_eq: { return ">"; }
using enum comparison_operator;
case equal: { return "=="; }
case not_equal: { return "!="; }
case lt: { return "<"; }
case gt: { return ">"; }
case lt_eq: { return "<="; }
case gt_eq: { return ">"; }
default: { return "??"; }
}
}
@@ -54,24 +56,26 @@ to_string( comparison_operator const Operator ) {
inline
comparison_pass
comparison_pass_from_string( std::string const Input ) {
if( Input == "all" ) { return comparison_pass::all; }
else if( Input == "any" ) { return comparison_pass::any; }
else if( Input == "none" ) { return comparison_pass::none; }
using enum comparison_pass;
if( Input == "all" ) { return all; }
else if( Input == "any" ) { return any; }
else if( Input == "none" ) { return none; }
return comparison_pass::all; // legacy default
return all; // legacy default
}
inline
comparison_operator
comparison_operator_from_string( std::string const Input ) {
if( Input == "==" ) { return comparison_operator::equal; }
else if( Input == "!=" ) { return comparison_operator::not_equal; }
else if( Input == "<" ) { return comparison_operator::lt; }
else if( Input == ">" ) { return comparison_operator::gt; }
else if( Input == "<=" ) { return comparison_operator::lt_eq; }
else if( Input == ">=" ) { return comparison_operator::gt_eq; }
using enum comparison_operator;
if( Input == "==" ) { return equal; }
else if( Input == "!=" ) { return not_equal; }
else if( Input == "<" ) { return lt; }
else if( Input == ">" ) { return gt; }
else if( Input == "<=" ) { return lt_eq; }
else if( Input == ">=" ) { return gt_eq; }
return comparison_operator::equal; // legacy default
return equal; // legacy default
}
//---------------------------------------------------------------------------

View File

@@ -240,13 +240,14 @@ TGauge::Load_mapping( cParser &Input, TGauge::scratch_data &Scratchpad ) {
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:" ) {
using enum TGaugeType;
auto const gaugetype { Input.getToken<std::string>( true, "\n\r\t ,;" ) };
m_type = gaugetype == "push" ? TGaugeType::push :
gaugetype == "impulse" ? TGaugeType::push :
gaugetype == "return" ? TGaugeType::push :
gaugetype == "delayed" ? TGaugeType::push_delayed :
gaugetype == "pushtoggle" ? TGaugeType::pushtoggle :
TGaugeType::toggle; // "toggle" and default
m_type = gaugetype == "push" ? push :
gaugetype == "impulse" ? push :
gaugetype == "return" ? push :
gaugetype == "delayed" ? push_delayed :
gaugetype == "pushtoggle" ? pushtoggle :
toggle; // "toggle" and default
}
else if( key == "soundinc:" ) {
m_soundfxincrease.deserialize( Input, sound_type::single );

View File

@@ -1020,9 +1020,10 @@ void TTrain::set_train_brake(double const Position)
void TTrain::zero_charging_train_brake()
{
using enum TBrakeHandle;
if (mvOccupied->BrakeCtrlPos == -1 && DynamicObject->Controller != AIdriver && Global.iFeedbackMode < 3 &&
(mvOccupied->BrakeHandle == TBrakeHandle::FVel6 || mvOccupied->BrakeHandle == TBrakeHandle::MHZ_EN57 || mvOccupied->BrakeHandle == TBrakeHandle::MHZ_K8P))
(mvOccupied->BrakeHandle == FVel6 || mvOccupied->BrakeHandle == MHZ_EN57 || mvOccupied->BrakeHandle == MHZ_K8P))
{
// Odskakiwanie hamulce EP
set_train_brake(0);
@@ -3470,6 +3471,7 @@ void TTrain::OnCommand_pantographlowerselected(TTrain *Train, command_data const
void TTrain::update_pantograph_valves()
{
using enum operation_t;
auto const &presets{mvOccupied->PantsPreset.first};
auto &selection{mvOccupied->PantsPreset.second[cab_to_end()]};
@@ -3479,8 +3481,8 @@ void TTrain::update_pantograph_valves()
// check desired states for both pantographs; value: whether the pantograph should be raised
auto const frontstate{preset & (swapends ? 2 : 1)};
auto const rearstate{preset & (swapends ? 1 : 2)};
mvOccupied->OperatePantographValve(end::front, frontstate ? operation_t::enable : operation_t::disable);
mvOccupied->OperatePantographValve(end::rear, rearstate ? operation_t::enable : operation_t::disable);
mvOccupied->OperatePantographValve(end::front, frontstate ? enable : disable);
mvOccupied->OperatePantographValve(end::rear, rearstate ? enable : disable);
}
void TTrain::change_pantograph_selection(int const Change)
@@ -10219,33 +10221,35 @@ bool TTrain::CabChange(int iDirection)
// wczytywanie pliku z danymi multimedialnymi (dzwieki, kontrolki, kabiny)
bool TTrain::LoadMMediaFile(std::string const &asFileName)
{
using enum sound_placement;
using enum sound_type;
// initialize sounds so potential entries from previous vehicle don't stick around
std::unordered_map<std::string, std::tuple<std::optional<sound_source> &, sound_placement, float, sound_type, int, double>> internalsounds = {
{"ctrl:", {dsbNastawnikJazdy, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"ctrlscnd:", {dsbNastawnikBocz, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"reverserkey:", {dsbReverserKey, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"buzzer:", {dsbBuzzer, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"buzzershp:", {dsbBuzzerShp, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"radiostop:", {m_radiostop, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"slipalarm:", {dsbSlipAlarm, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"distancecounter:", {m_distancecounterclear, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"tachoclock:", {dsbHasler, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"switch:", {dsbSwitch, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"pneumaticswitch:", {dsbPneumaticSwitch, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"airsound:", {rsHiss, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"airsound2:", {rsHissU, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"airsound3:", {rsHissE, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"airsound4:", {rsHissX, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"airsound5:", {rsHissT, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"localbrakesound:", {rsSBHiss, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"localbrakesound2:", {rsSBHissU, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, sound_parameters::amplitude, 100.0}},
{"brakesound:", {rsBrake, sound_placement::internal, -1, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, 100.0}},
{"fadesound:", {rsFadeSound, sound_placement::internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, sound_type::single, 0, 100.0}},
{"runningnoise:", {rsRunningNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"resonancenoise:", {rsResonanceNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"windsound:", {rsWindSound, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"huntingnoise:", {rsHuntingNoise, sound_placement::internal, EU07_SOUND_GLOBALRANGE, sound_type::single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"rainsound:", {m_rainsound, sound_placement::internal, -1, sound_type::single, 0, 100.0}},
{"ctrl:", {dsbNastawnikJazdy, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"ctrlscnd:", {dsbNastawnikBocz, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"reverserkey:", {dsbReverserKey, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"buzzer:", {dsbBuzzer, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"buzzershp:", {dsbBuzzerShp, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"radiostop:", {m_radiostop, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"slipalarm:", {dsbSlipAlarm, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"distancecounter:", {m_distancecounterclear, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"tachoclock:", {dsbHasler, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"switch:", {dsbSwitch, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"pneumaticswitch:", {dsbPneumaticSwitch, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"airsound:", {rsHiss, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"airsound2:", {rsHissU, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"airsound3:", {rsHissE, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"airsound4:", {rsHissX, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"airsound5:", {rsHissT, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"localbrakesound:", {rsSBHiss, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"localbrakesound2:", {rsSBHissU, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, sound_parameters::amplitude, 100.0}},
{"brakesound:", {rsBrake, internal, -1, single, sound_parameters::amplitude | sound_parameters::frequency, 100.0}},
{"fadesound:", {rsFadeSound, internal, EU07_SOUND_CABCONTROLSCUTOFFRANGE, single, 0, 100.0}},
{"runningnoise:", {rsRunningNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"resonancenoise:", {rsResonanceNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"windsound:", {rsWindSound, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"huntingnoise:", {rsHuntingNoise, internal, EU07_SOUND_GLOBALRANGE, single, sound_parameters::amplitude | sound_parameters::frequency, mvOccupied->Vmax}},
{"rainsound:", {m_rainsound, internal, -1, single, 0, 100.0}},
};
for (auto &[soundname, soundsource] : internalsounds)
{
@@ -10292,7 +10296,7 @@ bool TTrain::LoadMMediaFile(std::string const &asFileName)
if (!m_rainsound)
{
sound_source rainsound;
rainsound.deserialize("rainsound_default", sound_type::single);
rainsound.deserialize("rainsound_default", single);
rainsound.owner(DynamicObject);
m_rainsound = rainsound;
}

View File

@@ -18,9 +18,10 @@ void ui::time_panel::render_contents()
if (ImGui::Button(STR_C("Apply")))
{
m_relay.post(user_command::setdatetime, (double)yearday, time * 60.0, 1, 0);
m_relay.post(user_command::setweather, fog, overcast, 1, 0);
m_relay.post(user_command::settemperature, temperature, overcast, 1, 0);
using enum user_command;
m_relay.post(setdatetime, (double)yearday, time * 60.0, 1, 0);
m_relay.post(setweather, fog, overcast, 1, 0);
m_relay.post(settemperature, temperature, overcast, 1, 0);
}
}

View File

@@ -51,48 +51,49 @@ void TMemCell::UpdateValues( std::string const &szNewText, double const fNewValu
TCommandType TMemCell::CommandCheck()
{ // rozpoznanie komendy
using enum TCommandType;
if( szText == "SetVelocity" ) // najpopularniejsze
{
eCommand = TCommandType::cm_SetVelocity;
eCommand = cm_SetVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "ShuntVelocity" ) // w tarczach manewrowych
{
eCommand = TCommandType::cm_ShuntVelocity;
eCommand = cm_ShuntVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "Change_direction" ) // zdarza się
{
eCommand = TCommandType::cm_ChangeDirection;
eCommand = cm_ChangeDirection;
bCommand = true; // do wysłania
}
else if( szText == "OutsideStation" ) // zdarza się
{
eCommand = TCommandType::cm_OutsideStation;
eCommand = cm_OutsideStation;
bCommand = false; // tego nie powinno być w komórce
}
else if( szText.starts_with("PassengerStopPoint:") ) // porównanie początków
{
eCommand = TCommandType::cm_PassengerStopPoint;
eCommand = cm_PassengerStopPoint;
bCommand = false; // tego nie powinno być w komórce
}
else if( szText == "SetProximityVelocity" ) // nie powinno tego być
{
eCommand = TCommandType::cm_SetProximityVelocity;
eCommand = cm_SetProximityVelocity;
bCommand = false; // ta komenda nie jest wysyłana
}
else if( szText == "Emergency_brake" )
{
eCommand = TCommandType::cm_EmergencyBrake;
eCommand = cm_EmergencyBrake;
bCommand = false;
}
else if( szText == "CabSignal" ) {
eCommand = TCommandType::cm_SecuritySystemMagnet;
eCommand = cm_SecuritySystemMagnet;
bCommand = false;
}
else
{
eCommand = TCommandType::cm_Unknown; // ciąg nierozpoznany (nie jest komendą)
eCommand = cm_Unknown; // ciąg nierozpoznany (nie jest komendą)
bCommand = true; // do wysłania
}
return eCommand;
@@ -177,20 +178,22 @@ bool TMemCell::Compare( std::string const &szTestText, double const fTestValue1,
}
switch( Pass ) {
case comparison_pass::all: { return checkfailed == false; }
case comparison_pass::any: { return checkpassed == true; }
case comparison_pass::none: { return checkpassed == false; }
using enum comparison_pass;
case all: { return checkfailed == false; }
case any: { return checkpassed == true; }
case none: { return checkpassed == false; }
default: { return false; }
}
};
bool TMemCell::IsVelocity() const
{ // sprawdzenie, czy event odczytu tej komórki ma być do skanowania, czy do kolejkowania
if (eCommand == TCommandType::cm_SetVelocity)
using enum TCommandType;
if (eCommand == cm_SetVelocity)
return true;
if (eCommand == TCommandType::cm_ShuntVelocity)
if (eCommand == cm_ShuntVelocity)
return true;
return eCommand == TCommandType::cm_SetProximityVelocity;
return eCommand == cm_SetProximityVelocity;
};
void TMemCell::StopCommandSent()