eu07/maszyna
17
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-05 19:29:11 +01:00
Code Issues 150 Wiki Activity

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

Browse Source 
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
Download Patch File Download Diff File Expand all files Collapse all files

256
McZapkie/Mover.cpp
View File

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

11
audio/sound.cpp
View File

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

301
input/driverkeyboardinput.cpp
View File

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

910
input/drivermouseinput.cpp
View File

File diff suppressed because it is too large Load Diff

25
input/editorkeyboardinput.cpp
View File

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

14
input/gamepadinput.cpp
View File

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

13
input/keyboardinput.cpp
View File

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

31
launcher/textures_scanner.cpp
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) 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 = { static std::unordered_map<char, vehicle_type> type_map = {
{ 'e', vehicle_type::electric_loco }, { 'e', electric_loco },
{ 's', vehicle_type::diesel_loco }, { 's', diesel_loco },
{ 'p', vehicle_type::steam_loco }, { 'p', steam_loco },
{ 'a', vehicle_type::railcar }, { 'a', railcar },
{ 'z', vehicle_type::emu }, { 'z', emu },
{ 'r', vehicle_type::utility }, { 'r', utility },
{ 'd', vehicle_type::draisine }, { 'd', draisine },
{ 't', vehicle_type::tram }, { 't', tram },
{ 'c', vehicle_type::truck }, { 'c', truck },
{ 'b', vehicle_type::bus }, { 'b', bus },
{ 'o', vehicle_type::car }, { 'o', car },
{ 'h', vehicle_type::man }, { 'h', man },
{ 'f', vehicle_type::animal }, { 'f', animal },
}; };
ctx_type = vehicle_type::unknown; ctx_type = unknown;
std::istringstream stream(param); 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()) if (auto it = type_map.find(tok[0]); it != type_map.end())
ctx_type = it->second; ctx_type = it->second;
else if (tok[0] >= 'A' && tok[0] <= 'Z') else if (tok[0] >= 'A' && tok[0] <= 'Z')
ctx_type = vehicle_type::carriage; ctx_type = carriage;
std::string mini; std::string mini;
std::getline(stream, mini, ','); std::getline(stream, mini, ',');

7
scripting/ladderlogic.cpp
View File

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

50
utilities/comparison.h
View File

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

13
vehicle/Gauge.cpp
View File

@@ -240,13 +240,14 @@ TGauge::Load_mapping( cParser &Input, TGauge::scratch_data &Scratchpad ) {
if( true == key.empty() || key == "}" ) { return false; } if( true == key.empty() || key == "}" ) { return false; }
// if not block end then the key is followed by assigned value or sub-block // if not block end then the key is followed by assigned value or sub-block
if( key == "type:" ) { if( key == "type:" ) {
using enum TGaugeType;
auto const gaugetype { Input.getToken<std::string>( true, "\n\r\t ,;" ) }; auto const gaugetype { Input.getToken<std::string>( true, "\n\r\t ,;" ) };
m_type = gaugetype == "push" ? TGaugeType::push : m_type = gaugetype == "push" ? push :
gaugetype == "impulse" ? TGaugeType::push : gaugetype == "impulse" ? push :
gaugetype == "return" ? TGaugeType::push : gaugetype == "return" ? push :
gaugetype == "delayed" ? TGaugeType::push_delayed : gaugetype == "delayed" ? push_delayed :
gaugetype == "pushtoggle" ? TGaugeType::pushtoggle : gaugetype == "pushtoggle" ? pushtoggle :
TGaugeType::toggle; // "toggle" and default toggle; // "toggle" and default
} }
else if( key == "soundinc:" ) { else if( key == "soundinc:" ) {
m_soundfxincrease.deserialize( Input, sound_type::single ); m_soundfxincrease.deserialize( Input, sound_type::single );

62
vehicle/Train.cpp
View File

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

7
widgets/time.cpp
View File

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

33
world/MemCell.cpp
View File

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