18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 23:55:00 +01:00
Files
maszyna/world/mtable.cpp
maj00r d0a3694657 fix(files): data named in another case is found on Linux, folders included
The parser and the loaders lowercase every name they read, while the data
made on Windows has files and folders named in any case (scenery/Braniewo,
textures/siec_trakcyjna_ph/.../STS_*.tga, sounds/sip/Gorki.wav). FileCased
matched the file name only, so a folder in another case wasn't found.

- FileCased walks every part of the path on Linux, the folder listings kept
  by their lowercase and read again once the folder changed; Windows as it was
- FileExists finds the file in any case on Linux, and the variant with names
  and extensions gives back the name as it's on the disk, so textures,
  materials, sounds, station announcements and scripts open that name
- models, sound captions, timetables and nodebank previews open the file
  as it's named on the disk; the texture format is told by the extension in
  any case
2026-11-13 15:41:40 +01:00

706 lines
28 KiB
C++

/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
#include "stdafx.h"
#include "world/mtable.h"
#include "utilities/Globals.h"
#include "simulation/simulationtime.h"
#include "utilities/dictionary.h"
#include "utilities/utilities.h"
double TTrainParameters::CheckTrainLatency() const
{
if (LastStationLatency > 1.0 || LastStationLatency < 0)
return LastStationLatency; /*spoznienie + lub do przodu - z tolerancja 1 min*/
else
return 0;
}
double TTrainParameters::WatchMTable(double DistCounter) const
{ // zwraca odleglość do najblizszej stacji z zatrzymaniem
double dist;
if (Direction == 1)
dist = TimeTable[StationIndex].km - TimeTable[0].km - DistCounter;
else
dist = TimeTable[0].km - TimeTable[StationIndex].km - DistCounter;
return dist;
}
std::string TTrainParameters::NextStop() const
{ // pobranie nazwy następnego miejsca zatrzymania
if (StationIndex <= StationCount)
return NextStationName; // nazwa następnego przystanku;
else
return "[End of route]"; //że niby koniec
}
sound_source
TTrainParameters::next_stop_sound() const {
if( StationIndex > StationCount ) {
return { sound_placement::engine };
}
for( auto stationidx { StationIndex }; stationidx < StationCount + 1; ++stationidx ) {
auto &station{ TimeTable[ stationidx ] };
if( station.Ah == -1 ) {
continue;
}
// specified arrival time means it's a scheduled stop
return station.name_sound;
}
// shouldn't normally get here, unless the timetable is malformed
return { sound_placement::engine };
}
sound_source
TTrainParameters::last_stop_sound() const {
return TimeTable[ StationCount ].name_sound;
}
bool TTrainParameters::IsStop() const
{ // zapytanie, czy zatrzymywać na następnym punkcie rozkładu
if (StationIndex <= StationCount)
return TimeTable[StationIndex].Ah >= 0; //-1 to brak postoju
else
return true; // na ostatnim się zatrzymać zawsze
}
bool TTrainParameters::IsLastStop() const {
return StationIndex >= StationCount;
}
TMTableLine const &TTrainParameters::TimeTableEntryAhead( int Offset ) const
{ // wpis rozkladu Offset pozycji za aktualnym (bez pomijania przelotow);
// poza zakresem 1..StationCount zwraca techniczny wpis zerowy
int const idx { StationIndex + Offset };
if( ( idx < 1 ) || ( idx > StationCount ) )
return TimeTable[0];
return TimeTable[idx];
}
bool TTrainParameters::IsMaintenance() const {
if( StationIndex <= StationCount )
return TimeTable[ StationIndex ].is_maintenance;
else
return false;
}
int TTrainParameters::radio_channel() const {
if( StationIndex <= StationCount )
return TimeTable[ StationIndex ].radio_channel;
else
return -1;
}
// returns: sound file associated with current station, or -1
sound_source TTrainParameters::current_stop_sound() const {
if( StationIndex <= StationCount )
return TimeTable[ StationIndex ].name_sound;
else
return { sound_placement::engine };
}
bool TTrainParameters::UpdateMTable( scenario_time const &Time, std::string const &NewName ) {
return UpdateMTable( Time.data().wHour, Time.data().wMinute + Time.data().wSecond * 0.0167, NewName );
}
bool TTrainParameters::UpdateMTable(double hh, double mm, std::string_view NewName)
/*odfajkowanie dojechania do stacji (NewName) i przeliczenie opóźnienia*/
{
bool OK;
OK = false;
if (StationIndex <= StationCount) // Ra: "<=", bo ostatni przystanek jest traktowany wyjątkowo
{
if (NewName == NextStationName) // jeśli dojechane do następnego
{ // Ra: wywołanie może być powtarzane, jak stoi na W4
if (TimeTable[StationIndex + 1].km - TimeTable[StationIndex].km < 0) // to jest bez sensu
Direction = -1;
else
Direction = 1; // prowizorka bo moze byc zmiana kilometrazu
// ustalenie, czy opóźniony (porównanie z czasem odjazdu)
LastStationLatency =
CompareTime(hh, mm, TimeTable[StationIndex].Dh, TimeTable[StationIndex].Dm);
// inc(StationIndex); //przejście do następnej pozycji StationIndex<=StationCount
// Ra: "<", bo dodaje 1 przy przejściu do następnej stacji
if (StationIndex < StationCount) {
// jeśli nie ostatnia stacja
NextStationName = TimeTable[StationIndex + 1].StationName; // zapamiętanie nazwy
// Ra: nowa prędkość rozkładowa na kolejnym odcinku
TTVmax = TimeTable[StationIndex + 1].vmax;
}
else {
// gdy ostatnia stacja, nie ma następnej stacji
NextStationName = "";
}
OK = true;
}
}
return OK; /*czy jest nastepna stacja*/
}
bool Mtable::TTrainParameters::RewindTimeTable(std::string actualStationName) {
if( actualStationName.compare( 0, 19, "PassengerStopPoint:" ) == 0 ) {
actualStationName = ToLower( actualStationName.substr( 19 ) );
}
for( auto i = 1; i <= StationCount; ++i ) {
// przechodzimy po całej tabelce i sprawdzamy nazwy stacji (bez pierwszej)
if (ToLower(TimeTable[i].StationName) == actualStationName) {
// nazwa stacji zgodna więc ustawiamy na poprzednią, żeby w następnym kroku poprawnie obsłużyć
StationIndex = i;
NextStationName = TimeTable[ i ].StationName;
TTVmax = TimeTable[ i ].vmax;
return true; // znaleźliśmy więc kończymy
}
}
// failed to find a match
return false;
}
void TTrainParameters::StationIndexInc()
{ // przejście do następnej pozycji StationIndex<=StationCount
++StationIndex;
}
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
{
if (StationIndex < 1)
return true; // przed pierwszą jechać
else if (StationIndex < StationCount)
{ // oprócz ostatniego przystanku
if (TimeTable[StationIndex].Ah < 0) // odjazd z poprzedniego
return true; // czas przyjazdu nie był podany - przelot
else
return CompareTime(hh, mm, TimeTable[StationIndex].Dh, TimeTable[StationIndex].Dm) <= 0;
}
else // gdy rozkład się skończył
return false; // dalej nie jechać
}
// returns: difference between specified time and scheduled departure from current stop, in seconds
double TTrainParameters::seconds_until_departure( double const Hour, double const Minute ) const {
if( TimeTable[StationStart].Ah < 0 ) { // passthrough
return 0;
}
return 60.0 * CompareTime(Hour, Minute, TimeTable[StationStart].Dh, TimeTable[StationStart].Dm);
}
std::string TTrainParameters::ShowRelation() const
/*zwraca informację o relacji*/
{
// if (Relation1=TimeTable[1].StationName) and (Relation2=TimeTable[StationCount].StationName)
if (Relation1 != "" && Relation2 != "")
return Relation1 + " - " + Relation2;
else
return "";
}
TTrainParameters::TTrainParameters(std::string const &NewTrainName)
/*wstępne ustawienie parametrów rozkładu jazdy*/
{
NewName(NewTrainName);
}
void TTrainParameters::NewName(std::string_view NewTrainName)
/*wstępne ustawienie parametrów rozkładu jazdy*/
{
TrainName = NewTrainName;
StationCount = 0;
StationIndex = 0;
StationStart = 0;
NextStationName = "nowhere";
LastStationLatency = 0;
Direction = 1;
Relation1 = "";
Relation2 = "";
for (auto &tableline : TimeTable)
{
tableline = TMTableLine();
}
TTVmax = 100; /*wykasowac*/
BrakeRatio = 0;
LocSeries = "";
LocLoad = 0;
}
void TTrainParameters::UpdateVelocity(int /*Stationcount*/, double vActual)
// zapisywanie prędkości maksymalnej do wcześniejszych odcinków
// wywoływane z numerem ostatniego przetworzonego przystanku
{
int i = StationCount;
// TTVmax:=vActual; {PROWIZORKA!!!}
while (i >= 0 && TimeTable[i].vmax == -1)
{
TimeTable[i].vmax = static_cast<float>(vActual); // prędkość dojazdu do przystanku i
--i; // ewentualnie do poprzedniego też
}
}
// bool TTrainParameters::LoadTTfile(std::string scnpath, int iPlus, double vmax)
//{
// return false;
//}
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;
std::string s;
std::ifstream fin;
bool EndTable;
double vActual;
int conversionerror = 0;
EndTable = false;
if (TrainName == "")
{ // jeśli pusty rozkład
// UpdateVelocity(StationCount,vMax); //ograniczenie do prędkości startowej
}
else
{
vActual = -1;
s = scnpath + TrainName + ".txt";
replace_slashes(s);
// Ra 2014-09: ustalić zasady wyznaczenia pierwotnego pliku przy przesuniętych rozkładach
// (kolejny pociąg dostaje numer +2)
fin.open(s.c_str()); // otwieranie pliku
if (false == fin.is_open())
{
// the name of the train comes in lowercase, the file can be named in another case
if (auto const cased{FileCased(s)}; false == cased.empty())
{
fin.clear();
fin.open(cased);
}
}
replace_slashes(s);
if (!fin.is_open())
{ // jeśli nie ma pliku
vmax = atoi(TrainName.c_str()); // nie ma pliku ale jest liczba
if (vmax > 10 && vmax < 200)
{
TTVmax = vmax; // Ra 2014-07: zamiast rozkładu można podać Vmax
UpdateVelocity(StationCount, vmax); // ograniczenie do prędkości startowej
conversionerror = 0;
}
else
conversionerror = -8; /*Ra: ten błąd jest niepotrzebny*/
}
else
{ /*analiza rozkładu jazdy*/
conversionerror = 0;
while (fin.good() && !(conversionerror != 0 || EndTable))
{
std::getline(fin, lines); /*wczytanie linii*/
if (contains( lines, "___________________") ) /*linia pozioma górna*/
{
fin >> s;
if (s == "[") /*lewy pion*/
{
fin >> s;
if (s == "Rodzaj") /*"Rodzaj i numer pociagu"*/
do
{
fin >> s;
} while (!(s == "|") || fin.eof()); /*środkowy pion*/
}
}
else if (lines == "")
{
fin.close();
break;
}
fin >> s; /*nazwa pociągu*/
// if LowerCase(s)<>ExtractFileName(TrainName) then {musi być taka sama, jak nazwa
// pliku}
// ConversionError:=-7 {błąd niezgodności}
TrainName = s; // nadanie nazwy z pliku TXT (bez ścieżki do pliku)
while (fin >> s || fin.bad())
{
if (contains( s,"_______|") )
{
break;
}
if (s == "Kategoria")
{
do
{
fin >> s;
} while (!(s == "|" || fin.bad()));
fin >> TrainCategory;
continue;
}
if (s == "Nazwa")
{
do
{
fin >> s;
} while (!(s == "|" || fin.bad()));
fin >> TrainLabel;
continue;
}
} // while (!(s == "Seria"));
// else
{ /*czytaj naglowek*/
while (fin >> s || !fin.bad())
{
if (s == "[")
break;
} // while (!() || (fin.eof())); /*pierwsza linia z relacją*/
while (fin >> s || !fin.bad())
{
if (s != "|")
break;
} // while (!(() || fin.eof()));
if( s != "|" ) {
Relation1 = s;
win1250_to_ascii( Relation1 );
}
else
conversionerror = -5;
while (fin >> s || !fin.bad())
{
if (s == "Relacja")
break;
} // while (
// !( || (fin.eof()))); /*druga linia z relacją*/
while (fin >> s || !fin.bad())
{
if (s == "|")
break;
} // while (!( || (fin.eof())));
fin >> Relation2;
win1250_to_ascii( Relation2 );
while (fin >> s || !fin.bad())
{
if (s == "Wymagany")
break;
} // while (!();
while (fin >> s || !fin.bad())
{
if (s == "|" || s == "\n")
break;
} // while (!());
fin >> s;
s = s.substr(0, s.find("%"));
BrakeRatio = atof(s.c_str());
while (fin >> s || fin.bad())
{
if (s == "Seria")
break;
} // while (!(s == "Seria"));
do
{
fin >> s;
} while (!(s == "|" || fin.bad()));
fin >> LocSeries;
fin >> LocLoad; // = s2rE(ReadWord(fin));
do
{
fin >> s;
} while (!(contains( s,"[______________" ) || fin.bad()));
auto activeradiochannel{ -1 };
while (!fin.bad() && !EndTable)
{
++StationCount;
do
{
fin >> s;
} while (!(s == "[" || fin.bad()));
TMTableLine *record = &TimeTable[StationCount];
{
if (s == "[")
fin >> s;
else
conversionerror = -4;
if (false == contains( s,"|") )
{
record->km = static_cast<float>(atof(s.c_str()));
fin >> s;
}
if (contains( s,"|_____|")) /*zmiana predkosci szlakowej*/
UpdateVelocity(StationCount, vActual);
else
{
fin >> s;
if (false == contains(s,"|"))
vActual = atof(s.c_str());
}
while (false == contains( s,"|"))
fin >> s;
fin >> record->StationName;
// get rid of non-ascii chars. TODO: run correct version based on locale
win1250_to_ascii( record->StationName );
do
{
fin >> s;
} while (!(s == "1" || s == "2" || fin.bad()));
record->TrackNo = atoi(s.c_str());
fin >> s;
if (s != "|")
{
if (contains( s, hrsd) )
{
record->Ah = atoi( s.substr(0, s.find(hrsd)).c_str()); // godzina 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 = static_cast<float>(atof(s.c_str())); // bo tylko minuty podane
}
}
do
{
fin >> s;
} while (!(s != "|" || fin.bad()));
if (s != "]")
record->tm = static_cast<float>(atof(s.c_str()));
do
{
fin >> s;
} while (!(s == "[" || fin.bad()));
fin >> s;
if (false == contains(s,"|"))
{
/*tu s moze byc miejscem zmiany predkosci szlakowej*/
fin >> s;
}
if (s.find("|_____|") !=
std::string::npos) /*zmiana predkosci szlakowej*/
UpdateVelocity(StationCount, vActual);
else
{
fin >> s;
if (false == contains(s,"|"))
vActual = atof(s.c_str());
}
while (false == contains(s,"|"))
fin >> s;
// stationware. added fix for empty entry
fin >> s;
while( false == ( s == "1"
|| s == "2"
|| fin.bad() ) ) {
record->StationWare += s;
fin >> s;
}
// cache relevant station data
record->is_maintenance = contains(s, "pt");
{
auto const stationware { Split( record->StationWare, ',' ) };
for( auto const &entry : stationware ) {
if( entry.front() != 'R' ) {
continue;
}
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,
// it generally means we should switch to the one we weren't using so far
// TODO: reverse this behaviour (keep the channel used so far) once W28 signs are included in the system
record->radio_channel = radiochannel;
}
}
}
if( record->radio_channel != -1 ) {
activeradiochannel = record->radio_channel;
}
}
record->TrackNo = atoi(s.c_str());
fin >> s;
if (s != "|")
{
if (contains( s, hrsd) )
{
record->Dh = atoi(s.substr(0, s.find(hrsd)).c_str()); // godzina 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 = static_cast<float>(atof(s.c_str())); // bo tylko minuty podane
}
}
else
{
record->Dh = record->Ah; // odjazd o tej samej, co przyjazd (dla ostatniego też)
record->Dm = record->Am; // bo są używane do wyliczenia opóźnienia po dojechaniu
}
do
{
fin >> s;
} while (!(s != "|" || fin.bad()));
if (s != "]")
record->tm = static_cast<float>(atof(s.c_str()));
do
{
fin >> s;
} while (!(contains( s, "[" ) || fin.bad()));
if (false == contains( s, "_|_"))
fin >> s;
if (false == contains( s, "|"))
{
/*tu s moze byc miejscem zmiany predkosci szlakowej*/
fin >> s;
}
if (contains( s, "|_____|") ) /*zmiana predkosci szlakowej*/
UpdateVelocity(StationCount, vActual);
else
{
fin >> s;
if (false == contains( s, "|"))
vActual = atof(s.c_str());
}
while (false == contains( s, "|" ) )
fin >> s;
while (false == contains(s, "]"))
fin >> s;
if (contains( s,"_|_") )
EndTable = true;
} /*timetableline*/
}
}
} /*while eof*/
fin.close();
}
}
// 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
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
for (auto i = 1; i < i_end; ++i) // bez with, bo ciężko się przenosi na C++
{
if (TimeTable[i].Ah >= 0)
{
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>( 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;
}
void
TTrainParameters::load_sounds() {
for( auto stationidx = 1; stationidx < StationCount + 1; ++stationidx ) {
auto &station { TimeTable[ stationidx ] };
if( station.Ah == -1 ) {
continue;
}
// specified arrival time means it's a scheduled stop
auto const stationname { (
station.StationName.ends_with("_po") ?
station.StationName.substr( 0, station.StationName.size() - 3 ) :
station.StationName ) };
auto const [filepath, fileextension]{
FileExists(
{ Global.asCurrentSceneryPath + stationname, std::string{ paths::sounds } + "sip/" + stationname },
{ ".ogg", ".flac", ".wav" } ) };
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( filepath + fileextension, sound_type::single );
}
}
bool TTrainParameters::DirectionChange() const
// sprawdzenie, czy po zatrzymaniu wykonać kolejne komendy
{
// dla ostatniej stacji nie
if (StationIndex > 0 && StationIndex < StationCount && contains( TimeTable[StationIndex].StationWare, '@'))
return true;
return false;
}
void TTrainParameters::serialize( dictionary_source *Output ) const {
Output->insert( "trainnumber", TrainName );
Output->insert( "traincategory", TrainCategory );
Output->insert( "trainname", TrainLabel );
Output->insert( "train_brakingmassratio", BrakeRatio );
Output->insert( "train_enginetype", LocSeries );
Output->insert( "train_engineload", LocLoad );
Output->insert( "train_stationfrom", Relation1 );
Output->insert( "train_stationto", Relation2 );
Output->insert( "train_stationindex", StationIndex );
Output->insert( "train_stationcount", StationCount );
Output->insert( "train_stationstart", StationStart );
if( StationCount > 0 ) {
// timetable stations data, if there's any
for( auto stationidx = 1; stationidx <= StationCount; ++stationidx ) {
auto const stationlabel { "train_station" + std::to_string( stationidx ) + "_" };
auto const &timetableline { TimeTable[ stationidx ] };
Output->insert( stationlabel + "name", Bezogonkow( timetableline.StationName ) );
Output->insert( stationlabel + "fclt", Bezogonkow( timetableline.StationWare ) );
Output->insert( stationlabel + "lctn", timetableline.km );
Output->insert( stationlabel + "vmax", timetableline.vmax );
Output->insert( stationlabel + "ah", timetableline.Ah );
Output->insert( stationlabel + "am", timetableline.Am );
Output->insert( stationlabel + "dh", timetableline.Dh );
Output->insert( stationlabel + "dm", timetableline.Dm );
Output->insert( stationlabel + "tracks", timetableline.TrackNo );
}
}
}
void TMTableTime::UpdateMTableTime(double deltaT)
// dodanie czasu (deltaT) w sekundach, z przeliczeniem godziny
{
mr += deltaT; // dodawanie sekund
while (mr >= 60.0) // przeliczenie sekund do właściwego przedziału
{
mr -= 60.0;
++mm;
}
while (mm > 59) // przeliczenie minut do właściwego przedziału
{
mm -= 60;
++hh;
}
while (hh > 23) // przeliczenie godzin do właściwego przedziału
{
hh -= 24;
++dd; // zwiększenie numeru dnia
}
}