eu07/maszyna
17
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-10-17 03:59:19 +02:00
Code Issues 150 Wiki Activity

Fix/sonar maintainability rebased (#209)

Browse Source 
* refactor(sonar): use override instead of redundant virtual (cpp:S3471)

* refactor(sonar): remove empty statements, one declaration per statement (cpp:S1116, cpp:S1659)

* refactor(sonar): drop redundant lambda return types (cpp:S3574)

* refactor(sonar): prefer using over typedef (cpp:S5416)

* refactor(sonar): use =default for trivial special members (cpp:S3490)

* refactor(sonar): use nullptr literal (cpp:S4962)

* refactor(sonar): remove redundant access specifiers (cpp:S3539)

* refactor(sonar): remove redundant casts (cpp:S1905)

* refactor(sonar): use std::scoped_lock instead of std::lock_guard (cpp:S5997)

* refactor(sonar): construct elements in place with emplace_back (cpp:S6003)

* refactor(sonar): make narrowing conversions explicit (cpp:S5276)

* refactor(sonar): mark unused parameters (cpp:S1172)

Unused names are commented out; parameters used only on some platforms
are marked [[maybe_unused]].

* refactor(sonar): declare non-mutating member functions const (cpp:S5817)

Virtual functions are left untouched so overrides keep matching.

* refactor(sonar): merge collapsible nested if statements (cpp:S1066)

Comments that preceded the inner if are kept above the merged statement.

* refactor(sonar): scope single-use variables in if init-statements (cpp:S6004)

* fix(sonar): give polymorphic base classes virtual destructors (cpp:S1235)

* refactor(sonar): use try_emplace for map insertion (cpp:S6030)

* refactor(sonar): use auto where the type is spelled out on the right (cpp:S5827)

* refactor(sonar): remove redundant parentheses (cpp:S1110)

* refactor(sonar): document intentionally empty functions (cpp:S1186)

* refactor(sonar): remove dead stores (cpp:S1854)

Side effects (e.g. LISTLINE++) are kept.

* refactor(sonar): remove unused variables, captures and private fields (cpp:S1481, cpp:S1068)

* refactor(sonar): use structured bindings for pair access (cpp:S6005)

* refactor(sonar): use range-based loops and ranges algorithms (cpp:S5566)

* refactor(sonar): split chained assignments (cpp:S1121)

* refactor(sonar): add default cases to switch statements (cpp:S3562)

* refactor(sonar): use std::size for array lengths (cpp:S7127)

* refactor(sonar): use std::ranges algorithms and std::erase(_if) (cpp:S6197)

* refactor(sonar): access static members through the class (cpp:S2209)

* refactor(sonar): add braces around nested if-else (cpp:S5261)

* refactor(sonar): avoid side effects inside typeid operands (cpp:S5279)

* refactor(sonar): drop top-level const from by-value return types (cpp:S5951)

* refactor(sonar): declare variables separately from their type definitions (cpp:S3646)

* refactor(sonar): declare loop counters in the for statement (cpp:S5955)

* refactor(sonar): rely on class template argument deduction (cpp:S6012)

* refactor(sonar): inherit base constructors instead of forwarding them (cpp:S5952)

* refactor(sonar): rename locals that shadow outer declarations (cpp:S1117)

Only local variables and definition parameters are renamed; shadowing
struct fields and enumerators in headers are left for a separate change.

* 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.

* refactor(sonar): mark converting constructors explicit (cpp:S1709)

sound_source and the gl::object conversion operators stay implicit; they
are relied upon by copy-list-initialisation and GL calls.

* refactor(sonar): initialise members in initialiser lists or declarations (cpp:S3230)

* refactor(sonar): make read-only local references and pointers const (cpp:S5350)

* refactor(sonar): take read-only pointer and reference parameters as const (cpp:S995)

TTrain command handlers keep their signature, it is fixed by the handler table.

* refactor(sonar): pass expensive-to-copy parameters by const reference (cpp:S1238)

Signatures declared in files touched by PR 206 (Driver.h, EU07.cpp) and
virtual overrides are left unchanged.

* refactor(sonar): use transparent comparators for string-keyed maps (cpp:S6045)

std::unordered_map instances and map types exposed in headers used by
other modules are left as they are.

* fix(sonar): do not use UI text as a printf format string (cpp:S5281)

Text lines containing '%' would otherwise be interpreted as format
specifiers by ImGui::TextColored.

* refactor(sonar): use std::bind_front for callbacks (cpp:S5995)

* refactor(sonar): drop const_cast on string literals passed to the Python C API (cpp:S859)

* refactor(sonar): take read-only string parameters as std::string_view (cpp:S6009)

The Windows messaging helpers keep std::string, they need c_str().

* refactor(sonar): make read-only global tables const (cpp:S5421)

Mutable global state (flags, timers, singletons) is left as is.

* refactor(sonar): replace single-case switch statements with if (cpp:S1301)

* refactor(sonar): format UUIDs and log timestamps with std::format (cpp:S6494, cpp:S5945)

* refactor(sonar): use std::array for local fixed-size arrays (cpp:S5945)

Arrays that are class members or part of headers are left unchanged.

* fix(sonar): test the bearing damage bit, not bit 0 (cpp:S872)

'DamageFlag & dtrain_bearing > 0' parsed as 'DamageFlag & (dtrain_bearing > 0)',
i.e. DamageFlag & 1, so bearing friction reacted to the wrong damage flag.

* refactor(sonar): assorted small fixes

- empty() instead of size() comparisons (cpp:S1155)
- member initialisers in declaration order (cpp:S3229)
- no redundant c_str() when a std::string is accepted (cpp:S7121)
- contains() on associative containers (cpp:S6171)
- const reference instead of a copying range-for (cpp:S6032)
- starts_with() for prefix checks (cpp:S6178)
- no std::move on temporaries (cpp:S5274)
- has_value() on std::optional (cpp:S7172)
- bool literals for bool members (cpp:S5820)
- inline only on the definition (cpp:S3548)
- explicit base access specifier (cpp:S5965)
- explicit element access instead of dereferencing an array (cpp:S7116)
- rely on the C++20 rewritten operator!= (cpp:S6186)

* refactor(sonar): more small fixes

- std::format instead of iostream manipulators in to_string/to_hex_str (cpp:S6495);
  output verified identical, negative hex values keep the unsigned form
- remove an empty compound statement (cpp:S108)
- drop an always-false unsigned < 0 branch (cpp:S1768)
- explicit lambda capture (cpp:S3608)
- std::make_unique (cpp:S5950)

* chore: strip stray carriage returns left in TTrain constructor comments

* fix: keep quantize() in its own value type

The S5276 change cast the result of the generic quantize<Type_>() to
unsigned int, which truncated float/double callers (shadow angle slider,
editor rotation snapping, AI speed control steps) and broke negative values.

* fix(sonar): use integer loop counters in segment sampling (cpp:S2193)

* refactor(sonar): clean up issues reported on PR 209

- remove locals left unused after the dead-store cleanup (cpp:S1481, cpp:S1854)
- unnamed unused parameter (cpp:S1172)
- single-use declarations moved into if init-statements (cpp:S6004)
- auto for casted initialisers (cpp:S5827)
- const references and pointers where nothing is modified (cpp:S5350)
- rename structured bindings shadowed by inner declarations (cpp:S1117)
This commit is contained in:
jerrrrycho
2026-10-11 13:22:33 +02:00
committed by GitHub
parent c26041f2e7
commit 6263fe539b
162 changed files with 4220 additions and 4598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
world/mtable.cpp
View File

@@ -14,7 +14,7 @@ http://mozilla.org/MPL/2.0/.
#include "utilities/dictionary.h"
#include "utilities/utilities.h"
double TTrainParameters::CheckTrainLatency()
double TTrainParameters::CheckTrainLatency() const
{
if (LastStationLatency > 1.0 || LastStationLatency < 0)
return LastStationLatency; /*spoznienie + lub do przodu - z tolerancja 1 min*/
@@ -22,7 +22,7 @@ double TTrainParameters::CheckTrainLatency()
return 0;
}
double TTrainParameters::WatchMTable(double DistCounter)
double TTrainParameters::WatchMTable(double DistCounter) const
{ // zwraca odleglość do najblizszej stacji z zatrzymaniem
double dist;
@@ -105,7 +105,7 @@ bool TTrainParameters::UpdateMTable( scenario_time const &Time, std::string cons
return UpdateMTable( Time.data().wHour, Time.data().wMinute + Time.data().wSecond * 0.0167, NewName );
}
bool TTrainParameters::UpdateMTable(double hh, double mm, std::string const &NewName)
bool TTrainParameters::UpdateMTable(double hh, double mm, std::string_view NewName)
/*odfajkowanie dojechania do stacji (NewName) i przeliczenie opóźnienia*/
{
bool OK;
@@ -163,7 +163,7 @@ void TTrainParameters::StationIndexInc()
++StationIndex;
}
bool TTrainParameters::IsTimeToGo(double hh, double mm)
bool TTrainParameters::IsTimeToGo(double hh, double mm) const
// sprawdzenie, czy można już odjechać z aktualnego zatrzymania
// StationIndex to numer następnego po dodarciu do aktualnego
{
@@ -205,7 +205,7 @@ TTrainParameters::TTrainParameters(std::string const &NewTrainName)
NewName(NewTrainName);
}
void TTrainParameters::NewName(std::string const &NewTrainName)
void TTrainParameters::NewName(std::string_view NewTrainName)
/*wstępne ustawienie parametrów rozkładu jazdy*/
{
TrainName = NewTrainName;
@@ -217,9 +217,9 @@ void TTrainParameters::NewName(std::string const &NewTrainName)
Direction = 1;
Relation1 = "";
Relation2 = "";
for (int i = 0; i < MaxTTableSize + 1; ++i)
for (auto &tableline : TimeTable)
{
TimeTable[ i ] = TMTableLine();
tableline = TMTableLine();
}
TTVmax = 100; /*wykasowac*/
BrakeRatio = 0;
@@ -227,7 +227,7 @@ void TTrainParameters::NewName(std::string const &NewTrainName)
LocLoad = 0;
}
void TTrainParameters::UpdateVelocity(int StationCount, double vActual)
void TTrainParameters::UpdateVelocity(int /*Stationcount*/, double vActual)
// zapisywanie prędkości maksymalnej do wcześniejszych odcinków
// wywoływane z numerem ostatniego przetworzonego przystanku
{
@@ -235,7 +235,7 @@ void TTrainParameters::UpdateVelocity(int StationCount, double vActual)
// TTVmax:=vActual; {PROWIZORKA!!!}
while (i >= 0 && TimeTable[i].vmax == -1)
{
TimeTable[i].vmax = vActual; // prędkość dojazdu do przystanku i
TimeTable[i].vmax = static_cast<float>(vActual); // prędkość dojazdu do przystanku i
--i; // ewentualnie do poprzedniego też
}
}
@@ -245,7 +245,7 @@ void TTrainParameters::UpdateVelocity(int StationCount, double vActual)
// return false;
//}
bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
bool TTrainParameters::LoadTTfile(std::string const &scnpath, int iPlus, double vmax)
// wczytanie pliku-tabeli z rozkładem przesuniętym o (fPlus); (vMax) nie ma znaczenia
{
std::string lines;
@@ -254,7 +254,7 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
bool EndTable;
double vActual;
int ConversionError = 0;
int conversionerror = 0;
EndTable = false;
if (TrainName == "")
{ // jeśli pusty rozkład
@@ -262,7 +262,6 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
}
else
{
ConversionError = 666;
vActual = -1;
s = scnpath + TrainName + ".txt";
replace_slashes(s);
@@ -278,15 +277,15 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
{
TTVmax = vmax; // Ra 2014-07: zamiast rozkładu można podać Vmax
UpdateVelocity(StationCount, vmax); // ograniczenie do prędkości startowej
ConversionError = 0;
conversionerror = 0;
}
else
ConversionError = -8; /*Ra: ten błąd jest niepotrzebny*/
conversionerror = -8; /*Ra: ten błąd jest niepotrzebny*/
}
else
{ /*analiza rozkładu jazdy*/
ConversionError = 0;
while (fin.good() && !(ConversionError != 0 || EndTable))
conversionerror = 0;
while (fin.good() && !(conversionerror != 0 || EndTable))
{
std::getline(fin, lines); /*wczytanie linii*/
if (contains( lines, "___________________") ) /*linia pozioma górna*/
@@ -354,7 +353,7 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
win1250_to_ascii( Relation1 );
}
else
ConversionError = -5;
conversionerror = -5;
while (fin >> s || !fin.bad())
{
if (s == "Relacja")
@@ -409,10 +408,10 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
if (s == "[")
fin >> s;
else
ConversionError = -4;
conversionerror = -4;
if (false == contains( s,"|") )
{
record->km = atof(s.c_str());
record->km = static_cast<float>(atof(s.c_str()));
fin >> s;
}
if (contains( s,"|_____|")) /*zmiana predkosci szlakowej*/
@@ -439,12 +438,12 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
if (contains( s, hrsd) )
{
record->Ah = atoi( s.substr(0, s.find(hrsd)).c_str()); // godzina przyjazdu
record->Am = atof(s.substr(s.find(hrsd) + 1, s.length()).c_str()); // minuta przyjazdu
record->Am = static_cast<float>(atof(s.substr(s.find(hrsd) + 1, s.length()).c_str())); // minuta przyjazdu
}
else
{
record->Ah = TimeTable[StationCount - 1].Ah; // godzina z poprzedniej pozycji
record->Am = atof(s.c_str()); // bo tylko minuty podane
record->Am = static_cast<float>(atof(s.c_str())); // bo tylko minuty podane
}
}
do
@@ -452,7 +451,7 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
fin >> s;
} while (!(s != "|" || fin.bad()));
if (s != "]")
record->tm = atof(s.c_str());
record->tm = static_cast<float>(atof(s.c_str()));
do
{
fin >> s;
@@ -490,10 +489,10 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
if( entry.front() != 'R' ) {
continue;
}
auto const entrysplit { split_string_and_number( entry ) };
if( entrysplit.first == "R"
&& entrysplit.second <= 10 ) {
auto const radiochannel { entrysplit.second };
auto const [entrytype, entrynumber]{ split_string_and_number( entry ) };
if( entrytype == "R"
&& entrynumber <= 10 ) {
auto const radiochannel { entrynumber };
if( record->radio_channel == -1
|| radiochannel != activeradiochannel ) {
// if the station has more than one radiochannel listed,
@@ -514,12 +513,12 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
if (contains( s, hrsd) )
{
record->Dh = atoi(s.substr(0, s.find(hrsd)).c_str()); // godzina odjazdu
record->Dm = atof(s.substr(s.find(hrsd) + 1, s.length()).c_str()); // minuta odjazdu
record->Dm = static_cast<float>(atof(s.substr(s.find(hrsd) + 1, s.length()).c_str())); // minuta odjazdu
}
else
{
record->Dh = TimeTable[StationCount - 1].Dh; // godzina z poprzedniej pozycji
record->Dm = atof(s.c_str()); // bo tylko minuty podane
record->Dm = static_cast<float>(atof(s.c_str())); // bo tylko minuty podane
}
}
else
@@ -532,7 +531,7 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
fin >> s;
} while (!(s != "|" || fin.bad()));
if (s != "]")
record->tm = atof(s.c_str());
record->tm = static_cast<float>(atof(s.c_str()));
do
{
fin >> s;
@@ -565,20 +564,16 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
fin.close();
}
}
if (ConversionError == 0)
{
if (TimeTable[1].StationName == Relation1) // jeśli nazwa pierwszego zgodna z relacją
if (TimeTable[1].Ah < 0) // a nie podany czas przyjazdu
{ // to mamy zatrzymanie na pierwszym, a nie przelot
TimeTable[1].Ah = TimeTable[1].Dh;
TimeTable[1].Am = TimeTable[1].Dm;
}
// jeśli nazwa pierwszego zgodna z relacją
if (conversionerror == 0 && TimeTable[1].StationName == Relation1 && TimeTable[1].Ah < 0) // a nie podany czas przyjazdu
{ // to mamy zatrzymanie na pierwszym, a nie przelot
TimeTable[1].Ah = TimeTable[1].Dh;
TimeTable[1].Am = TimeTable[1].Dm;
}
//
load_sounds();
// potentially offset table times
auto const timeoffset { static_cast<int>( Global.ScenarioTimeOffset * 60 ) + iPlus };
if( timeoffset != 0 ) // jeżeli jest przesunięcie rozkładu
if( auto const timeoffset { static_cast<int>( Global.ScenarioTimeOffset * 60 ) + iPlus }; timeoffset != 0 ) // jeżeli jest przesunięcie rozkładu
{
long i_end = StationCount + 1;
float adjustedtime; // do zwiększania czasu
@@ -586,19 +581,19 @@ bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
{
if (TimeTable[i].Ah >= 0)
{
adjustedtime = clamp_circular<float>( TimeTable[i].Ah * 60 + TimeTable[i].Am + timeoffset, 24 * 60 ); // nowe minuty
adjustedtime = clamp_circular<float>( static_cast<float>(TimeTable[i].Ah * 60) + TimeTable[i].Am + static_cast<float>(timeoffset), 24 * 60 ); // nowe minuty
TimeTable[i].Am = int(60 * adjustedtime) % 3600 / 60.f;
TimeTable[i].Ah = int(adjustedtime / 60) % 24;
}
if (TimeTable[i].Dh >= 0)
{
adjustedtime = clamp_circular<float>( TimeTable[i].Dh * 60 + TimeTable[i].Dm + timeoffset, 24 * 60 ); // nowe minuty
adjustedtime = clamp_circular<float>( static_cast<float>(TimeTable[i].Dh * 60) + TimeTable[i].Dm + static_cast<float>(timeoffset), 24 * 60 ); // nowe minuty
TimeTable[i].Dm = int(60 * adjustedtime) % 3600 / 60.f;
TimeTable[i].Dh = int(adjustedtime / 60) % 24;
}
}
}
return ConversionError == 0;
return conversionerror == 0;
}
void
@@ -615,26 +610,26 @@ TTrainParameters::load_sounds() {
station.StationName.substr( 0, station.StationName.size() - 3 ) :
station.StationName ) };
auto const lookup {
auto const [filepath, fileextension]{
FileExists(
{ Global.asCurrentSceneryPath + stationname, std::string{ paths::sounds } + "sip/" + stationname },
{ ".ogg", ".flac", ".wav" } ) };
if( lookup.first.empty() ) {
if( filepath.empty() ) {
continue;
}
// wczytanie dźwięku odjazdu w wersji radiowej (słychać tylko w kabinie)
station.name_sound =
sound_source{ sound_placement::engine, EU07_SOUND_CABANNOUNCEMENTCUTOFFRANGE }
.deserialize( lookup.first + lookup.second, sound_type::single );
.deserialize( filepath + fileextension, sound_type::single );
}
}
bool TTrainParameters::DirectionChange()
bool TTrainParameters::DirectionChange() const
// sprawdzenie, czy po zatrzymaniu wykonać kolejne komendy
{
if (StationIndex > 0 && StationIndex < StationCount) // dla ostatniej stacji nie
if (contains( TimeTable[StationIndex].StationWare, '@') )
return true;
// dla ostatniej stacji nie
if (StationIndex > 0 && StationIndex < StationCount && contains( TimeTable[StationIndex].StationWare, '@'))
return true;
return false;
}