mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 23:55:00 +01:00
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
706 lines
28 KiB
C++
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
|
|
}
|
|
}
|