eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-17 23:39:18 +02:00
Code Issues 121 Wiki Activity

added class members initializations

Browse Source
This commit is contained in:
tmj-fstate
2017-01-27 17:36:08 +01:00
parent 71cd60b543
commit 020016092d
27 changed files with 633 additions and 1137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
AdvSound.cpp
View File

@@ -12,15 +12,6 @@ http://mozilla.org/MPL/2.0/.
#include "Timer.h"
//---------------------------------------------------------------------------
TAdvancedSound::TAdvancedSound()
{
// SoundStart=SoundCommencing=SoundShut= NULL;
State = ss_Off;
fTime = 0;
fStartLength = 0;
fShutLength = 0;
}
TAdvancedSound::~TAdvancedSound()
{ // Ra: stopowanie się sypie
// SoundStart.Stop();

14
AdvSound.h
View File

@@ -26,15 +26,15 @@ class TAdvancedSound
TRealSound SoundStart;
TRealSound SoundCommencing;
TRealSound SoundShut;
TSoundState State;
double fTime;
double fStartLength;
double fShutLength;
double defAM;
double defFM;
TSoundState State = ss_Off;
double fTime = 0.0;
double fStartLength = 0.0;
double fShutLength = 0.0;
double defAM = 0.0;
double defFM = 0.0;
public:
TAdvancedSound();
TAdvancedSound() = default;
~TAdvancedSound();
void Init( std::string const &NameOn, std::string const &Name, std::string const &NameOff, double DistanceAttenuation, vector3 const &pPosition);
void Load(cParser &Parser, vector3 const &pPosition);

8
Console/MWD.cpp
View File

@@ -156,13 +156,13 @@ bool MWDComm::ReadData() // odbieranie danych + odczyta danych analogowych i zap
fAnalog[0] =
(float)((ReadDataBuff[9] << 8) + ReadDataBuff[8]) /
Global::fMWDAnalogCalib[0][3]; // 4095.0f; //max wartosc wynikająca z rozdzielczości
Global::fMWDAnalogCalib[0][2]; // 4095.0f; //max wartosc wynikająca z rozdzielczości
fAnalog[1] =
(float)((ReadDataBuff[11] << 8) + ReadDataBuff[10]) / Global::fMWDAnalogCalib[1][3];
(float)((ReadDataBuff[11] << 8) + ReadDataBuff[10]) / Global::fMWDAnalogCalib[1][2];
fAnalog[2] =
(float)((ReadDataBuff[13] << 8) + ReadDataBuff[12]) / Global::fMWDAnalogCalib[2][3];
(float)((ReadDataBuff[13] << 8) + ReadDataBuff[12]) / Global::fMWDAnalogCalib[2][2];
fAnalog[3] =
(float)((ReadDataBuff[15] << 8) + ReadDataBuff[14]) / Global::fMWDAnalogCalib[3][3];
(float)((ReadDataBuff[15] << 8) + ReadDataBuff[14]) / Global::fMWDAnalogCalib[3][2];
CheckData();
return TRUE;

202
Driver.cpp
View File

@@ -1428,47 +1428,40 @@ void TController::TablePurger()
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
bool primary // czy ma aktywnie prowadzić?
)
TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche, bool primary) :// czy ma aktywnie prowadzić?
AIControllFlag( AI ), pVehicle( NewControll )
{
iEngineActive = 0;
LastUpdatedTime = 0.0;
ElapsedTime = 0.0;
// inicjalizacja zmiennych
Psyche = InitPsyche;
VelDesired = 0.0; // prędkosć początkowa
VelforDriver = -1;
LastReactionTime = 0.0;
HelpMeFlag = false;
// fProximityDist=1; //nie używane
ActualProximityDist = 1;
FirstSemaphorDist = 10000.0;
vCommandLocation.x = 0;
vCommandLocation.y = 0;
vCommandLocation.z = 0;
VelSignal = 0.0; // normalnie na początku ma stać, no chyba że jedzie
VelLimit = -1.0; // brak ograniczenia prędkości
VelNext = 120.0;
VelLimitLast = -1.0; // ostatnie ograniczenie bez ograniczenia
VelSignalLast = -1.0; // ostatni semafor też bez ograniczenia
VelRoad = -1.0; // prędkość drogowa bez ograniczenia
AIControllFlag = AI;
pVehicle = NewControll;
ControllingSet(); // utworzenie połączenia do sterowanego pojazdu
pVehicles[0] = pVehicle->GetFirstDynamic(0); // pierwszy w kierunku jazdy (Np. Pc1)
pVehicles[1] = pVehicle->GetFirstDynamic(1); // ostatni w kierunku jazdy (końcówki)
/*
switch (mvOccupied->CabNo)
{
case -1: SendCtrlBroadcast("CabActivisation",1); break;
case 1: SendCtrlBroadcast("CabActivisation",2); break;
default: AIControllFlag:=False; //na wszelki wypadek
}
*/
iDirection = 0;
iDirectionOrder = mvOccupied->CabNo; // 1=do przodu (w kierunku sprzęgu 0)
VehicleName = mvOccupied->Name;
if( pVehicle != nullptr ) {
pVehicles[ 0 ] = pVehicle->GetFirstDynamic( 0 ); // pierwszy w kierunku jazdy (Np. Pc1)
pVehicles[ 1 ] = pVehicle->GetFirstDynamic( 1 ); // ostatni w kierunku jazdy (końcówki)
}
else {
pVehicles[ 0 ] = nullptr;
pVehicles[ 1 ] = nullptr;
}
if( mvOccupied != nullptr ) {
iDirectionOrder = mvOccupied->CabNo; // 1=do przodu (w kierunku sprzęgu 0)
VehicleName = mvOccupied->Name;
if( mvOccupied->CategoryFlag & 2 ) { // samochody: na podst. http://www.prawko-kwartnik.info/hamowanie.html
// fDriverBraking=0.0065; //mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m]
fDriverBraking = 0.03; // coś nie hamują te samochody zbyt dobrze
fDriverDist = 5.0; // 5m - zachowywany odstęp przed kolizją
fVelPlus = 10.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
fVelMinus = 2.0; // margines prędkości powodujący załączenie napędu
}
else { // pociągi i statki
fDriverBraking = 0.06; // mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m]
fDriverDist = 50.0; // 50m - zachowywany odstęp przed kolizją
fVelPlus = 5.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
fVelMinus = 5.0; // margines prędkości powodujący załączenie napędu
}
// fAccThreshold może podlegać uczeniu się - hamowanie powinno być rejestrowane, a potem analizowane
fAccThreshold =
( mvOccupied->TrainType & dt_EZT ) ? -0.6 : -0.2; // próg opóźnienia dla zadziałania hamulca
}
// TrainParams=NewTrainParams;
// if (TrainParams)
// asNextStop=TrainParams->NextStop();
@@ -1477,111 +1470,32 @@ TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
// OrderCommand="";
// OrderValue=0;
OrdersClear();
MaxVelFlag = false;
MinVelFlag = false; // Ra: to nie jest używane
iDriverFailCount = 0;
Need_TryAgain = false; // true, jeśli druga pozycja w elektryku nie załapała
Need_BrakeRelease = true;
deltalog = 0.05; // 1.0;
if (WriteLogFlag)
{
mkdir("physicslog\\");
LogFile.open(string("physicslog\\" + VehicleName + ".dat").c_str(),
std::ios::in | std::ios::out | std::ios::trunc);
if( true == primary ) {
iDrivigFlags |= movePrimary; // aktywnie prowadzące pojazd
}
SetDriverPsyche(); // na końcu, bo wymaga ustawienia zmiennych
sSpeedTable = new TSpeedPos[iSpeedTableSize];
TableClear();
if( WriteLogFlag ) {
mkdir( "physicslog\\" );
LogFile.open( string( "physicslog\\" + VehicleName + ".dat" ).c_str(),
std::ios::in | std::ios::out | std::ios::trunc );
#if LOGPRESS == 0
LogFile << string(" Time [s] Velocity [m/s] Acceleration [m/ss] Coupler.Dist[m] "
"Coupler.Force[N] TractionForce [kN] FrictionForce [kN] "
"BrakeForce [kN] BrakePress [MPa] PipePress [MPa] "
"MotorCurrent [A] MCP SCP BCP LBP DmgFlag Command CVal1 CVal2")
.c_str()
<< "\r\n";
LogFile << string( " Time [s] Velocity [m/s] Acceleration [m/ss] Coupler.Dist[m] "
"Coupler.Force[N] TractionForce [kN] FrictionForce [kN] "
"BrakeForce [kN] BrakePress [MPa] PipePress [MPa] "
"MotorCurrent [A] MCP SCP BCP LBP DmgFlag Command CVal1 CVal2" )
.c_str()
<< "\r\n";
#endif
#if LOGPRESS == 1
LogFile << string("t\tVel\tAcc\tPP\tVVP\tBP\tBVP\tCVP").c_str() << "\n";
LogFile << string( "t\tVel\tAcc\tPP\tVVP\tBP\tBVP\tCVP" ).c_str() << "\n";
#endif
LogFile.flush();
}
/*
if (WriteLogFlag)
{
assignfile(AILogFile,VehicleName+".txt");
rewrite(AILogFile);
writeln(AILogFile,"AI driver log: started OK");
close(AILogFile);
}
*/
// VelMargin=2; //Controlling->Vmax*0.015;
fWarningDuration = 0.0; // nic do wytrąbienia
WaitingExpireTime = 31.0; // tyle ma czekać, zanim się ruszy
WaitingTime = 0.0;
fMinProximityDist = 30.0; // stawanie między 30 a 60 m przed przeszkodą
fMaxProximityDist = 50.0;
iVehicleCount = -2; // wartość neutralna
// Prepare2press=false; //bez dociskania
eStopReason = stopSleep; // na początku śpi
fLength = 0.0;
fMass = 0.0; //[kg]
eSignNext = NULL; // sygnał zmieniający prędkość, do pokazania na [F2]
sSemNext = NULL; // pierwszy semafor w przebiegu
sSemNextStop = NULL; // pierwszy semafor z sygnałem stój
fShuntVelocity = 40; // domyślna prędkość manewrowa
fStopTime = 0.0; // czas postoju przed dalszą jazdą (np. na przystanku)
iDrivigFlags = moveStopPoint; // podjedź do W4 możliwie blisko
iDrivigFlags |= moveStopHere; // nie podjeżdżaj do semafora, jeśli droga nie jest wolna
iDrivigFlags |= moveStartHorn; // podaj sygnał po podaniu wolnej drogi
if (primary)
iDrivigFlags |= movePrimary; // aktywnie prowadzące pojazd
Ready = false;
if (mvOccupied->CategoryFlag & 2)
{ // samochody: na podst. http://www.prawko-kwartnik.info/hamowanie.html
// fDriverBraking=0.0065; //mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m]
fDriverBraking = 0.03; // coś nie hamują te samochody zbyt dobrze
fDriverDist = 5.0; // 5m - zachowywany odstęp przed kolizją
fVelPlus = 10.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
fVelMinus = 2.0; // margines prędkości powodujący załączenie napędu
}
else
{ // pociągi i statki
fDriverBraking = 0.06; // mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m]
fDriverDist = 50.0; // 50m - zachowywany odstęp przed kolizją
fVelPlus = 5.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
fVelMinus = 5.0; // margines prędkości powodujący załączenie napędu
}
SetDriverPsyche(); // na końcu, bo wymaga ustawienia zmiennych
AccDesired = AccPreferred;
fVelMax = -1; // ustalenie prędkości dla składu
fBrakeTime = 0.0; // po jakim czasie przekręcić hamulec
iVehicles = 0; // na wszelki wypadek
iSpeedTableSize = 16;
sSpeedTable = new TSpeedPos[iSpeedTableSize];
TableClear();
iRadioChannel = 1; // numer aktualnego kanału radiowego
fActionTime = 0.0;
eAction = actSleep;
tsGuardSignal = NULL; // komunikat od kierownika
iGuardRadio = 0; // nie przez radio
iStationStart = 0; // nic?
// fAccThreshold może podlegać uczeniu się - hamowanie powinno być rejestrowane, a potem
// analizowane
fAccThreshold =
(mvOccupied->TrainType & dt_EZT) ? -0.6 : -0.2; // próg opóźnienia dla zadziałania hamulca
fLastStopExpDist = -1.0f;
iRouteWanted = 3; // powiedzmy, że ma jechać prosto (1=w lewo)
iCoupler = 0; // sprzęg; niezerowy gdy ma być podłączanie; samo podłączanie w trybie Connect
// (wcześniej może być np. Prepare_engine)
fOverhead1 = 3000.0; // informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
fOverhead2 = -1.0; // informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i
// ograniczeniem prędkości)
iOverheadZero = 0; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z
// podniesionymi pantografami
iOverheadDown = 0; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z
// podniesionymi pantografami
fAccDesiredAv = 0.0; // uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby
// ograniczyć migotanie
fVoltage = 0.0; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić
// rozruch o losowy czas
};
void TController::CloseLog()
@@ -2594,7 +2508,6 @@ bool TController::IncSpeed()
OK = mvControlling->IncMainCtrl(1);
}
break;
break;
case WheelsDriven:
if (!mvControlling->CabNo)
mvControlling->CabActivisation();
@@ -2748,12 +2661,15 @@ void TController::SpeedSet()
}
break;
case ElectricSeriesMotor:
if ((!mvControlling->StLinFlag) && (!mvControlling->DelayCtrlFlag) &&
(!iDrivigFlags & moveIncSpeed)) // styczniki liniowe rozłączone yBARC
if( ( false == mvControlling->StLinFlag )
&& ( false == mvControlling->DelayCtrlFlag )
&& ( 0 == ( iDrivigFlags & moveIncSpeed ) ) ) // styczniki liniowe rozłączone yBARC
{
// if (iDrivigFlags&moveIncSpeed) {} //jeśli czeka na załączenie liniowych
// else
while (DecSpeed())
while( DecSpeed() )
; // zerowanie napędu
}
else if (Ready || (iDrivigFlags & movePress)) // o ile może jechać
if (fAccGravity < -0.10) // i jedzie pod górę większą niż 10 promil
{ // procedura wjeżdżania na ekstremalne wzniesienia
@@ -2961,7 +2877,7 @@ bool TController::PutCommand(std::string NewCommand, double NewValue1, double Ne
NewCommand = Global::asCurrentSceneryPath + NewCommand + ".wav"; // na razie jeden
if (FileExists(NewCommand))
{ // wczytanie dźwięku odjazdu podawanego bezpośrenido
tsGuardSignal = new TTextSound(NewCommand.c_str(), 30, pVehicle->GetPosition().x,
tsGuardSignal = new TTextSound(NewCommand, 30, pVehicle->GetPosition().x,
pVehicle->GetPosition().y, pVehicle->GetPosition().z,
false);
// rsGuardSignal->Stop();
@@ -2972,7 +2888,7 @@ bool TController::PutCommand(std::string NewCommand, double NewValue1, double Ne
NewCommand = NewCommand.insert(NewCommand.find_last_of("."),"radio"); // wstawienie przed kropkč
if (FileExists(NewCommand))
{ // wczytanie dźwięku odjazdu w wersji radiowej (słychać tylko w kabinie)
tsGuardSignal = new TTextSound(NewCommand.c_str(), -1, pVehicle->GetPosition().x,
tsGuardSignal = new TTextSound(NewCommand, -1, pVehicle->GetPosition().x,
pVehicle->GetPosition().y, pVehicle->GetPosition().z,
false);
iGuardRadio = iRadioChannel;

183
Driver.h
View File

@@ -166,138 +166,133 @@ extern bool WriteLogFlag; // logowanie parametrów fizycznych
class TController
{
private: // obsługa tabelki prędkości (musi mieć możliwość odhaczania stacji w rozkładzie)
TSpeedPos *sSpeedTable; // najbliższe zmiany prędkości
int iSpeedTableSize; // wielkość tabelki
int iFirst; // aktualna pozycja w tabeli (modulo iSpeedTableSize)
int iLast; // ostatnia wypełniona pozycja w tabeli <iFirst (modulo iSpeedTableSize)
int iTableDirection; // kierunek zapełnienia tabelki względem pojazdu z AI
double fLastVel; // prędkość na poprzednio sprawdzonym torze
TTrack *tLast; // ostatni analizowany tor
TEvent *eSignSkip; // można pominąć ten SBL po zatrzymaniu
TSpeedPos *sSemNext; // następny semafor na drodze zależny od trybu jazdy
TSpeedPos *sSemNextStop; // następny semafor na drodze zależny od trybu jazdy i na stój
TSpeedPos *sSpeedTable = nullptr; // najbliższe zmiany prędkości
int iSpeedTableSize = 16; // wielkość tabelki
int iFirst = 0; // aktualna pozycja w tabeli (modulo iSpeedTableSize)
int iLast = 0; // ostatnia wypełniona pozycja w tabeli <iFirst (modulo iSpeedTableSize)
int iTableDirection = 0; // kierunek zapełnienia tabelki względem pojazdu z AI
double fLastVel = 0.0; // prędkość na poprzednio sprawdzonym torze
TTrack *tLast = nullptr; // ostatni analizowany tor
TEvent *eSignSkip = nullptr; // można pominąć ten SBL po zatrzymaniu
TSpeedPos *sSemNext = nullptr; // następny semafor na drodze zależny od trybu jazdy
TSpeedPos *sSemNextStop = nullptr; // następny semafor na drodze zależny od trybu jazdy i na stój
private: // parametry aktualnego składu
double fLength; // długość składu (do wyciągania z ograniczeń)
double fMass; // całkowita masa do liczenia stycznej składowej grawitacji
double fAccGravity; // przyspieszenie składowej stycznej grawitacji
double fLength = 0.0; // długość składu (do wyciągania z ograniczeń)
double fMass = 0.0; // całkowita masa do liczenia stycznej składowej grawitacji
double fAccGravity = 0.0; // przyspieszenie składowej stycznej grawitacji
public:
TEvent *eSignNext; // sygnał zmieniający prędkość, do pokazania na [F2]
TEvent *eSignNext = nullptr; // sygnał zmieniający prędkość, do pokazania na [F2]
std::string asNextStop; // nazwa następnego punktu zatrzymania wg rozkładu
int iStationStart; // numer pierwszej stacji pokazywanej na podglądzie rozkładu
int iStationStart = 0; // numer pierwszej stacji pokazywanej na podglądzie rozkładu
private: // parametry sterowania pojazdem (stan, hamowanie)
double fShuntVelocity; // maksymalna prędkość manewrowania, zależy m.in. od składu
int iVehicles; // ilość pojazdów w składzie
int iEngineActive; // ABu: Czy silnik byl juz zalaczony; Ra: postęp w załączaniu
double fShuntVelocity = 40.0; // maksymalna prędkość manewrowania, zależy m.in. od składu // domyślna prędkość manewrowa
int iVehicles = 0; // ilość pojazdów w składzie
int iEngineActive = 0; // ABu: Czy silnik byl juz zalaczony; Ra: postęp w załączaniu
// vector3 vMechLoc; //pozycja pojazdu do liczenia odległości od semafora (?)
bool Psyche;
int iDrivigFlags; // flagi bitowe ruchu
double fDriverBraking; // po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m]
double fDriverDist; // dopuszczalna odległość podjechania do przeszkody
double fVelMax; // maksymalna prędkość składu (sprawdzany każdy pojazd)
double fBrakeDist; // przybliżona droga hamowania
double fAccThreshold; // próg opóźnienia dla zadziałania hamulca
bool Psyche = false;
int iDrivigFlags = // flagi bitowe ruchu
moveStopPoint | // podjedź do W4 możliwie blisko
moveStopHere | // nie podjeżdżaj do semafora, jeśli droga nie jest wolna
moveStartHorn; // podaj sygnał po podaniu wolnej drogi
double fDriverBraking = 0.0; // po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m]
double fDriverDist = 0.0; // dopuszczalna odległość podjechania do przeszkody
double fVelMax = -1.0; // maksymalna prędkość składu (sprawdzany każdy pojazd)
double fBrakeDist = 0.0; // przybliżona droga hamowania
double fAccThreshold = 0.0; // próg opóźnienia dla zadziałania hamulca
public:
double fLastStopExpDist; // odległość wygasania ostateniego przystanku
double ReactionTime; // czas reakcji Ra: czego i na co? świadomości AI
double fBrakeTime; // wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę
double fLastStopExpDist = -1.0; // odległość wygasania ostateniego przystanku
double ReactionTime = 0.0; // czas reakcji Ra: czego i na co? świadomości AI
double fBrakeTime = 0.0; // wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę
// hamulca
private:
double fReady; // poziom odhamowania wagonów
bool Ready; // ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow
double LastUpdatedTime; // czas od ostatniego logu
double ElapsedTime; // czas od poczatku logu
double deltalog; // przyrost czasu
double LastReactionTime;
double fActionTime; // czas używany przy regulacji prędkości i zamykaniu drzwi
TAction eAction; // aktualny stan
bool HelpMeFlag; // wystawiane True jesli cos niedobrego sie dzieje
double fReady = 0.0; // poziom odhamowania wagonów
bool Ready = false; // ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow
double LastUpdatedTime = 0.0; // czas od ostatniego logu
double ElapsedTime = 0.0; // czas od poczatku logu
double deltalog = 0.05; // przyrost czasu
double LastReactionTime = 0.0;
double fActionTime = 0.0; // czas używany przy regulacji prędkości i zamykaniu drzwi
TAction eAction = actSleep; // aktualny stan
bool HelpMeFlag = false; // wystawiane True jesli cos niedobrego sie dzieje
public:
inline TAction GetAction()
{
return eAction;
}
bool AIControllFlag; // rzeczywisty/wirtualny maszynista
int iRouteWanted; // oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala
bool AIControllFlag = false; // rzeczywisty/wirtualny maszynista
int iRouteWanted = 3; // oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala
// migacz lub czeka na stan zwrotnicy
private:
TDynamicObject *pVehicle; // pojazd w którym siedzi sterujący
TDynamicObject *pVehicle = nullptr; // pojazd w którym siedzi sterujący
TDynamicObject
*pVehicles[2]; // skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane)
TMoverParameters *mvControlling; // jakim pojazdem steruje (może silnikowym w EZT)
TMoverParameters *mvOccupied; // jakim pojazdem hamuje
TTrainParameters *TrainParams; // rozkład jazdy zawsze jest, nawet jeśli pusty
TMoverParameters *mvControlling = nullptr; // jakim pojazdem steruje (może silnikowym w EZT)
TMoverParameters *mvOccupied = nullptr; // jakim pojazdem hamuje
TTrainParameters *TrainParams = nullptr; // rozkład jazdy zawsze jest, nawet jeśli pusty
// int TrainNumber; //numer rozkladowy tego pociagu
// AnsiString OrderCommand; //komenda pobierana z pojazdu
// double OrderValue; //argument komendy
int iRadioChannel; // numer aktualnego kanału radiowego
TTextSound *tsGuardSignal; // komunikat od kierownika
int iGuardRadio; // numer kanału radiowego kierownika (0, gdy nie używa radia)
int iRadioChannel = 1; // numer aktualnego kanału radiowego
TTextSound *tsGuardSignal = nullptr; // komunikat od kierownika
int iGuardRadio = 0; // numer kanału radiowego kierownika (0, gdy nie używa radia)
public:
double AccPreferred; // preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy
// wykryciu kolizji)
double AccDesired; // przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj)
double VelDesired; // predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal
double fAccDesiredAv; // uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby
double AccPreferred = 0.0; // preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy wykryciu kolizji)
double AccDesired = AccPreferred; // przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj)
double VelDesired = 0.0; // predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal
double fAccDesiredAv = 0.0; // uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby
// ograniczyć migotanie
public:
double VelforDriver; // prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości
// szlaku?)
double VelSignal; // ograniczenie prędkości z kompilacji znaków i sygnałów
double VelLimit; // predkość zadawana przez event jednokierunkowego ograniczenia prędkości
double VelforDriver = -1.0; // prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości szlaku?)
double VelSignal = 0.0; // ograniczenie prędkości z kompilacji znaków i sygnałów // normalnie na początku ma stać, no chyba że jedzie
double VelLimit = -1.0; // predkość zadawana przez event jednokierunkowego ograniczenia prędkości // -1: brak ograniczenia prędkości
public:
double VelSignalLast; // prędkość zadana na ostatnim semaforze
double VelSignalNext; // prędkość zadana na następnym semaforze
double VelLimitLast; // prędkość zadana przez ograniczenie
double VelRoad; // aktualna prędkość drogowa (ze znaku W27)
// (PutValues albo komendą)
double VelSignalLast = -1.0; // prędkość zadana na ostatnim semaforze // ostatni semafor też bez ograniczenia
double VelSignalNext = 0.0; // prędkość zadana na następnym semaforze
double VelLimitLast = -1.0; // prędkość zadana przez ograniczenie // ostatnie ograniczenie bez ograniczenia
double VelRoad = -1.0; // aktualna prędkość drogowa (ze znaku W27) (PutValues albo komendą) // prędkość drogowa bez ograniczenia
public:
double VelNext; // prędkość, jaka ma być po przejechaniu długości ProximityDist
double VelNext = 120.0; // prędkość, jaka ma być po przejechaniu długości ProximityDist
private:
double fProximityDist; // odleglosc podawana w SetProximityVelocity(); >0:przeliczać do
// punktu, <0:podana wartość
double FirstSemaphorDist; // odległość do pierwszego znalezionego semafora
double fProximityDist = 0.0; // odleglosc podawana w SetProximityVelocity(); >0:przeliczać do punktu, <0:podana wartość
double FirstSemaphorDist = 10000.0; // odległość do pierwszego znalezionego semafora
public:
double
ActualProximityDist; // odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
ActualProximityDist = 1.0; // odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
private:
vector3 vCommandLocation; // polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego
// odnosi sie komenda
TOrders OrderList[maxorders]; // lista rozkazów
int OrderPos, OrderTop; // rozkaz aktualny oraz wolne miejsce do wstawiania nowych
int OrderPos = 0,
OrderTop = 0; // rozkaz aktualny oraz wolne miejsce do wstawiania nowych
std::ofstream LogFile; // zapis parametrow fizycznych
std::ofstream AILogFile; // log AI
bool MaxVelFlag;
bool MinVelFlag;
int iDirection; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku)
int iVehicleCount; // ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)
int iCoupler; // maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0
// gdy jazda bez łączenia
int iDriverFailCount; // licznik błędów AI
bool Need_TryAgain; // true, jeśli druga pozycja w elektryku nie załapała
bool Need_BrakeRelease;
bool MaxVelFlag = false;
bool MinVelFlag = false; // Ra: to nie jest używane
int iDirection = 0; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iDirectionOrder = 0; //żadany kierunek jazdy (służy do zmiany kierunku)
int iVehicleCount = -2; // wartość neutralna // ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)
int iCoupler = 0; // maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0 gdy jazda bez łączenia
int iDriverFailCount = 0; // licznik błędów AI
bool Need_TryAgain = false; // true, jeśli druga pozycja w elektryku nie załapała
bool Need_BrakeRelease = true;
public:
double fMinProximityDist; // minimalna oległość do przeszkody, jaką należy zachować
double fOverhead1; // informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
double fOverhead2; // informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i
// ograniczeniem prędkości)
int iOverheadZero; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z
// podniesionymi pantografami
int iOverheadDown; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z
// podniesionymi pantografami
double fVoltage; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić
// rozruch o losowy czas
double fMinProximityDist = 30.0; // stawanie między 30 a 60 m przed przeszkodą // minimalna oległość do przeszkody, jaką należy zachować
double fOverhead1 = 3000.0; // informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
double fOverhead2 = -1.0; // informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości)
int iOverheadZero = 0; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami
int iOverheadDown = 0; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami
double fVoltage = 0.0; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas
private:
double fMaxProximityDist; // akceptowalna odległość stanięcia przed przeszkodą
TStopReason eStopReason; // powód zatrzymania przy ustawieniu zerowej prędkości
double fMaxProximityDist = 50.0; // stawanie między 30 a 60 m przed przeszkodą // akceptowalna odległość stanięcia przed przeszkodą
TStopReason eStopReason = stopSleep; // powód zatrzymania przy ustawieniu zerowej prędkości // na początku śpi
std::string VehicleName;
double fVelPlus; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
double fVelMinus; // margines obniżenia prędkości, powodujący załączenie napędu
double fWarningDuration; // ile czasu jeszcze trąbić
double fStopTime; // czas postoju przed dalszą jazdą (np. na przystanku)
double WaitingTime; // zliczany czas oczekiwania do samoistnego ruszenia
double WaitingExpireTime; // maksymlany czas oczekiwania do samoistnego ruszenia
double fVelPlus = 0.0; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
double fVelMinus = 0.0; // margines obniżenia prędkości, powodujący załączenie napędu
double fWarningDuration = 0.0; // ile czasu jeszcze trąbić
double fStopTime = 0.0; // czas postoju przed dalszą jazdą (np. na przystanku)
double WaitingTime = 0.0; // zliczany czas oczekiwania do samoistnego ruszenia
double WaitingExpireTime = 31.0; // tyle ma czekać, zanim się ruszy // maksymlany czas oczekiwania do samoistnego ruszenia
// TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty
private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---//
void SetDriverPsyche();

35
Event.cpp
View File

@@ -24,29 +24,16 @@ http://mozilla.org/MPL/2.0/.
#include "Ground.h"
#include "McZapkie\mctools.h"
TEvent::TEvent(string m)
TEvent::TEvent( std::string const &m ) :
asNodeName( m )
{
// asName=""; //czy nazwa eventu jest niezbędna w tym przypadku? chyba nie
evNext = evNext2 = NULL;
bEnabled = false; // false dla eventów używanych do skanowania sygnałów (nie dodawane do
// kolejki)
asNodeName = m; // nazwa obiektu powiązanego
iQueued = 0; // nie został dodany do kolejki
// bIsHistory=false;
fDelay = 0;
fStartTime = 0; // 0 nie ma sensu
Type = m.empty() ? tp_Unknown :
tp_GetValues; // utworzenie niejawnego odczytu komórki pamięci w torze
for (int i = 0; i < 13; i++)
Params[i].asPointer = NULL;
evJoined = NULL; // nie ma kolejnego z tą samą nazwą, usuwane są wg listy Next2
Activator = NULL;
iFlags = 0;
// event niejawny jest tworzony przed fazą InitEvents, która podmienia nazwę komórki pamięci na
// wskaźnik
// Current->Params[8].asGroundNode=m; //to się ustawi w InitEvents
// Current->Params[9].asMemCell=m->MemCell;
fRandomDelay = 0.0; // standardowo nie będzie dodatkowego losowego opóźnienia
if( false == m.empty() ) {
// utworzenie niejawnego odczytu komórki pamięci w torze
Type = tp_GetValues;
}
for( int i = 0; i < 13; ++i ) {
Params[ i ].asPointer = nullptr;
}
};
TEvent::~TEvent()
@@ -328,8 +315,8 @@ void TEvent::Load(cParser *parser, vector3 *org)
// str = AnsiString(token.c_str());
if (token.substr(0, 19) == "PassengerStopPoint:")
{
if (token.find("#"))
token = token.substr(0, token.find("#") - 1); // obcięcie unikatowości
if (token.find('#') != std::string::npos)
token = token.substr(0, token.find('#') - 1); // obcięcie unikatowości
bEnabled = false; // nie do kolejki (dla SetVelocity też, ale jak jest do toru
// dowiązany)
Params[6].asCommand = cm_PassengerStopPoint;

24
Event.h
View File

@@ -86,22 +86,22 @@ class TEvent // zmienne: ev*
public:
std::string asName;
bool bEnabled; // false gdy ma nie być dodawany do kolejki (skanowanie sygnałów)
int iQueued; // ile razy dodany do kolejki
bool bEnabled = false; // false gdy ma nie być dodawany do kolejki (skanowanie sygnałów)
int iQueued = 0; // ile razy dodany do kolejki
// bool bIsHistory;
TEvent *evNext; // następny w kolejce
TEvent *evNext2;
TEventType Type;
double fStartTime;
double fDelay;
TDynamicObject *Activator;
TEvent *evNext = nullptr; // następny w kolejce
TEvent *evNext2 = nullptr;
TEventType Type = tp_Unknown;
double fStartTime = 0.0;
double fDelay = 0.0;
TDynamicObject *Activator = nullptr;
TParam Params[13]; // McZapkie-070502 //Ra: zamienić to na union/struct
unsigned int iFlags; // zamiast Params[8] z flagami warunku
unsigned int iFlags = 0; // zamiast Params[8] z flagami warunku
std::string asNodeName; // McZapkie-100302 - dodalem zeby zapamietac nazwe toru
TEvent *evJoined; // kolejny event z tą samą nazwą - od wersji 378
double fRandomDelay; // zakres dodatkowego opóźnienia
TEvent *evJoined = nullptr; // kolejny event z tą samą nazwą - od wersji 378
double fRandomDelay = 0.0; // zakres dodatkowego opóźnienia // standardowo nie będzie dodatkowego losowego opóźnienia
public: // metody
TEvent(std::string m = "");
TEvent(std::string const &m = "");
~TEvent();
void Init();
void Load(cParser *parser, vector3 *org);

8
FadeSound.cpp
View File

@@ -16,14 +16,6 @@ http://mozilla.org/MPL/2.0/.
#include "FadeSound.h"
#include "Timer.h"
TFadeSound::TFadeSound()
{
Sound = NULL;
fFade = 0;
dt = 0;
fTime = 0;
}
TFadeSound::~TFadeSound()
{
Free();

9
FadeSound.h
View File

@@ -15,10 +15,11 @@ http://mozilla.org/MPL/2.0/.
class TFadeSound
{
PSound Sound;
float fFade;
float dt, fTime;
TSoundState State;
PSound Sound = nullptr;
float fFade = 0.0f;
float dt = 0.0f,
fTime = 0.0f;
TSoundState State = ss_Off;
public:
TFadeSound();

2
Globals.cpp
View File

@@ -835,7 +835,7 @@ void Global::ConfigParse(cParser &Parser)
Parser.getTokens();
Parser >> token;
int i = stol_def(token, -1); // numer wej�cia
if ((i >= 0) || (i <= 1))
if ((i >= 0) && (i <= 3))
{
Parser.getTokens(3, false);
Parser >> fMWDAnalogCalib[i][0] // max -> 2^16 -1

22
Ground.cpp
View File

@@ -1303,25 +1303,15 @@ BYTE TempConnectionType[ 200 ]; // Ra: sprzêgi w sk³adzie; ujemne, gdy odwrotn
TGround::TGround()
{
// RootNode=NULL;
nRootDynamic = NULL;
QueryRootEvent = NULL;
tmpEvent = NULL;
tmp2Event = NULL;
OldQRE = NULL;
RootEvent = NULL;
iNumNodes = 0;
// pTrain=NULL;
Global::pGround = this;
bInitDone = false; // Ra: żeby nie robiło dwa razy FirstInit
for (int i = 0; i < TP_LAST; i++)
nRootOfType[i] = NULL; // zerowanie tablic wyszukiwania
bDynamicRemove = false; // na razie nic do usunięcia
for( int i = 0; i < TP_LAST; ++i ) {
nRootOfType[ i ] = nullptr; // zerowanie tablic wyszukiwania
}
sTracks = new TNames(); // nazwy torów - na razie tak
/*
::SecureZeroMemory( TempVerts, sizeof( TempVerts ) );
*/
::SecureZeroMemory( TempConnectionType, sizeof( TempConnectionType ) );
::SecureZeroMemory( pRendered, sizeof( pRendered ) );
}
TGround::~TGround()

28
Ground.h
View File

@@ -273,29 +273,37 @@ class TGroundRect : public TSubRect
class TGround
{
vector3 CameraDirection; // zmienna robocza przy renderowaniu
int const *iRange; // tabela widoczności
int const *iRange = nullptr; // tabela widoczności
// TGroundNode *nRootNode; //lista wszystkich węzłów
TGroundNode *nRootDynamic; // lista pojazdów
TGroundNode *nRootDynamic = nullptr; // lista pojazdów
TGroundRect Rects[iNumRects][iNumRects]; // mapa kwadratów kilometrowych
TEvent *RootEvent; // lista zdarzeń
TEvent *QueryRootEvent, *tmpEvent, *tmp2Event, *OldQRE;
TEvent *RootEvent = nullptr; // lista zdarzeń
TEvent *QueryRootEvent = nullptr,
*tmpEvent = nullptr,
*tmp2Event = nullptr,
*OldQRE = nullptr;
TSubRect *pRendered[1500]; // lista renderowanych sektorów
int iNumNodes;
int iNumNodes = 0;
vector3 pOrigin;
vector3 aRotate;
bool bInitDone;
bool bInitDone = false;
TGroundNode *nRootOfType[TP_LAST]; // tablica grupująca obiekty, przyspiesza szukanie
// TGroundNode *nLastOfType[TP_LAST]; //ostatnia
TSubRect srGlobal; // zawiera obiekty globalne (na razie wyzwalacze czasowe)
int hh, mm, srh, srm, ssh, ssm; // ustawienia czasu
int hh = 0,
mm = 0,
srh = 0,
srm = 0,
ssh = 0,
ssm = 0; // ustawienia czasu
// int tracks,tracksfar; //liczniki torów
TNames *sTracks; // posortowane nazwy torów i eventów
TNames *sTracks = nullptr; // posortowane nazwy torów i eventów
private: // metody prywatne
bool EventConditon(TEvent *e);
public:
bool bDynamicRemove; // czy uruchomić procedurę usuwania pojazdów
TDynamicObject *LastDyn; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
bool bDynamicRemove = false; // czy uruchomić procedurę usuwania pojazdów
TDynamicObject *LastDyn = nullptr; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
// TTrain *pTrain;
// double fVDozwolona;
// bool bTrabil;

568
McZapkie/MOVER.h
View File

@@ -283,28 +283,20 @@ struct TTrackShape
struct TTrackParam
{/*parametry odcinka - szerokosc, tarcie statyczne, kategoria, obciazalnosc w t/os, uszkodzenia*/
double Width;
double friction;
int CategoryFlag;
int QualityFlag;
int DamageFlag;
double Width = 0.0;
double friction = 0.0;
int CategoryFlag = 0;
int QualityFlag = 0;
int DamageFlag = 0;
double Velmax; /*dla uzytku maszynisty w ai_driver*/
inline TTrackParam() {
Width, friction, Velmax = 0.0;
CategoryFlag, QualityFlag, DamageFlag = 0;
}
};
struct TTractionParam
{
double TractionVoltage; /*napiecie*/
double TractionFreq; /*czestotliwosc*/
double TractionMaxCurrent; /*obciazalnosc*/
double TractionResistivity; /*rezystancja styku*/
inline TTractionParam() {
TractionVoltage, TractionFreq = 0.0;
TractionMaxCurrent, TractionResistivity = 0.0;
}
double TractionVoltage = 0.0; /*napiecie*/
double TractionFreq = 0.0; /*czestotliwosc*/
double TractionMaxCurrent = 0.0; /*obciazalnosc*/
double TractionResistivity = 0.0; /*rezystancja styku*/
};
/*powyzsze parametry zwiazane sa z torem po ktorym aktualnie pojazd jedzie*/
@@ -321,19 +313,14 @@ typedef double TBrakeDelayTable[4];
struct TBrakePressure
{
double PipePressureVal;
double BrakePressureVal;
double FlowSpeedVal;
TBrakeSystem BrakeType;
inline TBrakePressure() {
BrakeType = Pneumatic;
PipePressureVal, BrakePressureVal, FlowSpeedVal = 0.0;
}
double PipePressureVal = 0.0;
double BrakePressureVal = 0.0;
double FlowSpeedVal = 0.0;
TBrakeSystem BrakeType = Pneumatic;
};
typedef std::map<int,TBrakePressure> TBrakePressureTable;
/*typy napedow*/
enum TEngineTypes { None, Dumb, WheelsDriven, ElectricSeriesMotor, ElectricInductionMotor, DieselEngine, SteamEngine, DieselElectric };
/*postac dostarczanej energii*/
@@ -495,16 +482,16 @@ struct TDEScheme
typedef TDEScheme TDESchemeTable[33]; /*tablica rezystorow rozr.*/
struct TShuntScheme
{
double Umin;
double Umax;
double Pmin;
double Pmax;
double Umin = 0.0;
double Umax = 0.0;
double Pmin = 0.0;
double Pmax = 0.0;
};
typedef TShuntScheme TShuntSchemeTable[33];
struct TMPTRelay
{/*lista przekaznikow bocznikowania*/
double Iup;
double Idown;
double Iup = 0.0;
double Idown = 0.0;
};
typedef TMPTRelay TMPTRelayTable[8];
@@ -549,13 +536,9 @@ struct TSecuritySystem
struct TTransmision
{//liczba zebow przekladni
int NToothM;
int NToothW;
double Ratio;
TTransmision() {
NToothM, NToothW = 0;
Ratio = 1.0;
}
int NToothM = 0;
int NToothW = 0;
double Ratio = 1.0;
};
enum TCouplerType { NoCoupler, Articulated, Bare, Chain, Screw, Automatic };
@@ -588,55 +571,58 @@ class TMoverParameters
{ // Ra: wrapper na kod pascalowy, przejmujący jego funkcje Q: 20160824 - juz nie wrapper a klasa bazowa :)
public:
double dMoveLen;
double dMoveLen = 0.0;
std::string filename;
/*---opis lokomotywy, wagonu itp*/
/*--opis serii--*/
int CategoryFlag; /*1 - pociag, 2 - samochod, 4 - statek, 8 - samolot*/
int CategoryFlag = 1; /*1 - pociag, 2 - samochod, 4 - statek, 8 - samolot*/
/*--sekcja stalych typowych parametrow*/
std::string TypeName; /*nazwa serii/typu*/
//TrainType: string; {typ: EZT/elektrowoz - Winger 040304}
int TrainType; /*Ra: powinno być szybciej niż string*/
TEngineTypes EngineType; /*typ napedu*/
int TrainType = 0; /*Ra: powinno być szybciej niż string*/
TEngineTypes EngineType = None; /*typ napedu*/
TPowerParameters EnginePowerSource; /*zrodlo mocy dla silnikow*/
TPowerParameters SystemPowerSource; /*zrodlo mocy dla systemow sterowania/przetwornic/sprezarek*/
TPowerParameters HeatingPowerSource; /*zrodlo mocy dla ogrzewania*/
TPowerParameters AlterHeatPowerSource; /*alternatywne zrodlo mocy dla ogrzewania*/
TPowerParameters LightPowerSource; /*zrodlo mocy dla oswietlenia*/
TPowerParameters AlterLightPowerSource;/*alternatywne mocy dla oswietlenia*/
double Vmax; double Mass; double Power; /*max. predkosc kontrukcyjna, masa wlasna, moc*/
double Mred; /*Ra: zredukowane masy wirujące; potrzebne do obliczeń hamowania*/
double TotalMass; /*wyliczane przez ComputeMass*/
double HeatingPower; double LightPower; /*moc pobierana na ogrzewanie/oswietlenie*/
double BatteryVoltage; /*Winger - baterie w elektrykach*/
bool Battery; /*Czy sa zalavzone baterie*/
bool EpFuse; /*Czy sa zalavzone baterie*/
bool Signalling; /*Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu*/
bool DoorSignalling; /*Czy jest zalaczona sygnalizacja blokady drzwi*/
bool Radio; /*Czy jest zalaczony radiotelefon*/
double NominalBatteryVoltage; /*Winger - baterie w elektrykach*/
double Vmax = -1.0;
double Mass = 0.0;
double Power = 0.0; /*max. predkosc kontrukcyjna, masa wlasna, moc*/
double Mred = 0.0; /*Ra: zredukowane masy wirujące; potrzebne do obliczeń hamowania*/
double TotalMass = 0.0; /*wyliczane przez ComputeMass*/
double HeatingPower = 0.0;
double LightPower = 0.0; /*moc pobierana na ogrzewanie/oswietlenie*/
double BatteryVoltage = 0.0; /*Winger - baterie w elektrykach*/
bool Battery = false; /*Czy sa zalavzone baterie*/
bool EpFuse = true; /*Czy sa zalavzone baterie*/
bool Signalling = false; /*Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu*/
bool DoorSignalling = false; /*Czy jest zalaczona sygnalizacja blokady drzwi*/
bool Radio = true; /*Czy jest zalaczony radiotelefon*/
double NominalBatteryVoltage = 0.0; /*Winger - baterie w elektrykach*/
TDimension Dim; /*wymiary*/
double Cx; /*wsp. op. aerodyn.*/
double Floor; //poziom podłogi dla ładunków
double WheelDiameter; /*srednica kol napednych*/
double WheelDiameterL; //Ra: srednica kol tocznych przednich
double WheelDiameterT; //Ra: srednica kol tocznych tylnych
double TrackW; /*nominalna szerokosc toru [m]*/
double AxleInertialMoment; /*moment bezwladnosci zestawu kolowego*/
double Cx = 0.0; /*wsp. op. aerodyn.*/
double Floor = 0.96; //poziom podłogi dla ładunków
double WheelDiameter = 1.0; /*srednica kol napednych*/
double WheelDiameterL = 0.9; //Ra: srednica kol tocznych przednich
double WheelDiameterT = 0.9; //Ra: srednica kol tocznych tylnych
double TrackW = 1.435; /*nominalna szerokosc toru [m]*/
double AxleInertialMoment = 0.0; /*moment bezwladnosci zestawu kolowego*/
std::string AxleArangement; /*uklad osi np. Bo'Bo' albo 1'C*/
int NPoweredAxles; /*ilosc osi napednych liczona z powyzszego*/
int NAxles; /*ilosc wszystkich osi j.w.*/
int BearingType; /*lozyska: 0 - slizgowe, 1 - toczne*/
double ADist; double BDist; /*odlegosc osi oraz czopow skretu*/
int NPoweredAxles = 0; /*ilosc osi napednych liczona z powyzszego*/
int NAxles = 0; /*ilosc wszystkich osi j.w.*/
int BearingType = 1; /*lozyska: 0 - slizgowe, 1 - toczne*/
double ADist = 0.0; double BDist = 0.0; /*odlegosc osi oraz czopow skretu*/
/*hamulce:*/
int NBpA; /*ilosc el. ciernych na os: 0 1 2 lub 4*/
int SandCapacity; /*zasobnik piasku [kg]*/
TBrakeSystem BrakeSystem;/*rodzaj hamulca zespolonego*/
TBrakeSubSystem BrakeSubsystem;
TBrakeValve BrakeValve;
TBrakeHandle BrakeHandle;
TBrakeHandle BrakeLocHandle;
double MBPM; /*masa najwiekszego cisnienia*/
int NBpA = 0; /*ilosc el. ciernych na os: 0 1 2 lub 4*/
int SandCapacity = 0; /*zasobnik piasku [kg]*/
TBrakeSystem BrakeSystem = Individual;/*rodzaj hamulca zespolonego*/
TBrakeSubSystem BrakeSubsystem = ss_None ;
TBrakeValve BrakeValve = NoValve;
TBrakeHandle BrakeHandle = NoHandle;
TBrakeHandle BrakeLocHandle = NoHandle;
double MBPM = 1.0; /*masa najwiekszego cisnienia*/
std::shared_ptr<TBrake> Hamulec;
std::shared_ptr<TDriverHandle> Handle;
@@ -644,52 +630,60 @@ public:
std::shared_ptr<TReservoir> Pipe;
std::shared_ptr<TReservoir> Pipe2;
TLocalBrake LocalBrake; /*rodzaj hamulca indywidualnego*/
TLocalBrake LocalBrake = NoBrake; /*rodzaj hamulca indywidualnego*/
TBrakePressureTable BrakePressureTable; /*wyszczegolnienie cisnien w rurze*/
TBrakePressure BrakePressureActual; //wartości ważone dla aktualnej pozycji kranu
int ASBType; /*0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat*/
int TurboTest;
double MaxBrakeForce; /*maksymalna sila nacisku hamulca*/
int ASBType = 0; /*0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat*/
int TurboTest = 0;
double MaxBrakeForce = 0.0; /*maksymalna sila nacisku hamulca*/
double MaxBrakePress[5]; //pomocniczy, proz, sred, lad, pp
double P2FTrans;
double TrackBrakeForce; /*sila nacisku hamulca szynowego*/
int BrakeMethod; /*flaga rodzaju hamulca*/
double P2FTrans = 0.0;
double TrackBrakeForce = 0.0; /*sila nacisku hamulca szynowego*/
int BrakeMethod = 0; /*flaga rodzaju hamulca*/
/*max. cisnienie w cyl. ham., stala proporcjonalnosci p-K*/
double HighPipePress; double LowPipePress; double DeltaPipePress;
double HighPipePress = 0.0;
double LowPipePress = 0.0;
double DeltaPipePress = 0.0;
/*max. i min. robocze cisnienie w przewodzie glownym oraz roznica miedzy nimi*/
double CntrlPipePress; //ciśnienie z zbiorniku sterującym
double BrakeVolume; double BrakeVVolume; double VeselVolume;
double CntrlPipePress = 0.0; //ciśnienie z zbiorniku sterującym
double BrakeVolume = 0.0;
double BrakeVVolume = 0.0;
double VeselVolume = 0.0;
/*pojemnosc powietrza w ukladzie hamulcowym, w ukladzie glownej sprezarki [m^3] */
int BrakeCylNo; /*ilosc cylindrow ham.*/
double BrakeCylRadius; double BrakeCylDist;
int BrakeCylNo = 0; /*ilosc cylindrow ham.*/
double BrakeCylRadius = 0.0;
double BrakeCylDist = 0.0;
double BrakeCylMult[3];
int LoadFlag;
int LoadFlag = 0;
/*promien cylindra, skok cylindra, przekladnia hamulcowa*/
double BrakeCylSpring; /*suma nacisku sprezyn powrotnych, kN*/
double BrakeSlckAdj; /*opor nastawiacza skoku tloka, kN*/
double BrakeRigEff; /*sprawnosc przekladni dzwigniowej*/
double RapidMult; /*przelozenie rapidu*/
int BrakeValveSize;
double BrakeCylSpring = 0.0; /*suma nacisku sprezyn powrotnych, kN*/
double BrakeSlckAdj = 0.0; /*opor nastawiacza skoku tloka, kN*/
double BrakeRigEff = 0.0; /*sprawnosc przekladni dzwigniowej*/
double RapidMult = 1.0; /*przelozenie rapidu*/
int BrakeValveSize = 0;
std::string BrakeValveParams;
double Spg;
double MinCompressor; double MaxCompressor; double CompressorSpeed;
double Spg = 0.0;
double MinCompressor = 0.0;
double MaxCompressor = 0.0;
double CompressorSpeed = 0.0;
/*cisnienie wlaczania, zalaczania sprezarki, wydajnosc sprezarki*/
TBrakeDelayTable BrakeDelay; /*opoznienie hamowania/odhamowania t/o*/
int BrakeCtrlPosNo; /*ilosc pozycji hamulca*/
int BrakeCtrlPosNo = 0; /*ilosc pozycji hamulca*/
/*nastawniki:*/
int MainCtrlPosNo; /*ilosc pozycji nastawnika*/
int ScndCtrlPosNo;
int LightsPosNo; int LightsDefPos;
bool LightsWrap;
int MainCtrlPosNo = 0; /*ilosc pozycji nastawnika*/
int ScndCtrlPosNo = 0;
int LightsPosNo = 1;
int LightsDefPos = 0;
bool LightsWrap = false;
int Lights[2][17]; // pozycje świateł, przód - tył, 1 .. 16
bool ScndInMain; /*zaleznosc bocznika od nastawnika*/
bool MBrake; /*Czy jest hamulec reczny*/
double StopBrakeDecc;
bool ScndInMain = false; /*zaleznosc bocznika od nastawnika*/
bool MBrake = false; /*Czy jest hamulec reczny*/
double StopBrakeDecc = 0.0;
TSecuritySystem SecuritySystem;
/*-sekcja parametrow dla lokomotywy elektrycznej*/
TSchemeTable RList; /*lista rezystorow rozruchowych i polaczen silnikow, dla dizla: napelnienia*/
int RlistSize;
int RlistSize = 0;
TMotorParameters MotorParam[MotorParametersArraySize + 1];
/*rozne parametry silnika przy bocznikowaniach*/
/*dla lokomotywy spalinowej z przekladnia mechaniczna: przelozenia biegow*/
@@ -698,143 +692,141 @@ public:
// NToothM, NToothW : byte;
// Ratio: real; {NToothW/NToothM}
// end;
double NominalVoltage; /*nominalne napiecie silnika*/
double WindingRes;
double u; //wspolczynnik tarcia yB wywalic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
double CircuitRes; /*rezystancje silnika i obwodu*/
int IminLo; int IminHi; /*prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver*/
int ImaxLo; int ImaxHi; /*maksymalny prad niskiego i wysokiego rozruchu*/
double nmax; /*maksymalna dop. ilosc obrotow /s*/
double InitialCtrlDelay; double CtrlDelay; /* -//- -//- miedzy kolejnymi poz.*/
double CtrlDownDelay; /* -//- -//- przy schodzeniu z poz.*/ /*hunter-101012*/
int FastSerialCircuit;/*0 - po kolei zamyka styczniki az do osiagniecia szeregowej, 1 - natychmiastowe wejscie na szeregowa*/ /*hunter-111012*/
int AutoRelayType; /*0 -brak, 1 - jest, 2 - opcja*/
bool CoupledCtrl; /*czy mainctrl i scndctrl sa sprzezone*/
double NominalVoltage = 0.0; /*nominalne napiecie silnika*/
double WindingRes = 0.0;
double u = 0.0; //wspolczynnik tarcia yB wywalic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
double CircuitRes = 0.0; /*rezystancje silnika i obwodu*/
int IminLo = 0; int IminHi = 0; /*prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver*/
int ImaxLo = 0; int ImaxHi = 0; /*maksymalny prad niskiego i wysokiego rozruchu*/
double nmax = 0.0; /*maksymalna dop. ilosc obrotow /s*/
double InitialCtrlDelay = 0.0; double CtrlDelay = 0.0; /* -//- -//- miedzy kolejnymi poz.*/
double CtrlDownDelay = 0.0; /* -//- -//- przy schodzeniu z poz.*/ /*hunter-101012*/
int FastSerialCircuit = 0;/*0 - po kolei zamyka styczniki az do osiagniecia szeregowej, 1 - natychmiastowe wejscie na szeregowa*/ /*hunter-111012*/
int AutoRelayType = 0; /*0 -brak, 1 - jest, 2 - opcja*/
bool CoupledCtrl = false; /*czy mainctrl i scndctrl sa sprzezone*/
//CouplerNr: TCouplerNr; {ABu: nr sprzegu podlaczonego w drugim obiekcie}
bool IsCoupled; /*czy jest sprzezony ale jedzie z tylu*/
int DynamicBrakeType; /*patrz dbrake_**/
int RVentType; /*0 - brak, 1 - jest, 2 - automatycznie wlaczany*/
double RVentnmax; /*maks. obroty wentylatorow oporow rozruchowych*/
double RVentCutOff; /*rezystancja wylaczania wentylatorow dla RVentType=2*/
int CompressorPower; /*0: bezp. z obwodow silnika, 1: z przetwornicy, reczne, 2: w przetwornicy, stale, 5: z silnikowego*/
int SmallCompressorPower; /*Winger ZROBIC*/
bool Trafo; /*pojazd wyposażony w transformator*/
bool IsCoupled = false; /*czy jest sprzezony ale jedzie z tylu*/
int DynamicBrakeType = 0; /*patrz dbrake_**/
int RVentType = 0; /*0 - brak, 1 - jest, 2 - automatycznie wlaczany*/
double RVentnmax = 1.0; /*maks. obroty wentylatorow oporow rozruchowych*/
double RVentCutOff = 0.0; /*rezystancja wylaczania wentylatorow dla RVentType=2*/
int CompressorPower = 1; /*0: bezp. z obwodow silnika, 1: z przetwornicy, reczne, 2: w przetwornicy, stale, 5: z silnikowego*/
int SmallCompressorPower = 0; /*Winger ZROBIC*/
bool Trafo = false; /*pojazd wyposażony w transformator*/
/*-sekcja parametrow dla lokomotywy spalinowej z przekladnia mechaniczna*/
double dizel_Mmax; double dizel_nMmax; double dizel_Mnmax; double dizel_nmax; double dizel_nominalfill;
double dizel_Mmax = 1.0;
double dizel_nMmax = 1.0;
double dizel_Mnmax = 2.0;
double dizel_nmax = 2.0;
double dizel_nominalfill = 0.0;
/*parametry aproksymacji silnika spalinowego*/
double dizel_Mstand; /*moment oporow ruchu silnika dla enrot=0*/
double dizel_Mstand = 0.0; /*moment oporow ruchu silnika dla enrot=0*/
/* dizel_auto_min, dizel_auto_max: real; {predkosc obrotowa przelaczania automatycznej skrzyni biegow*/
double dizel_nmax_cutoff; /*predkosc obrotowa zadzialania ogranicznika predkosci*/
double dizel_nmin; /*najmniejsza dopuszczalna predkosc obrotowa*/
double dizel_minVelfullengage; /*najmniejsza predkosc przy jezdzie ze sprzeglem bez poslizgu*/
double dizel_AIM; /*moment bezwladnosci walu itp*/
double dizel_engageDia; double dizel_engageMaxForce; double dizel_engagefriction; /*parametry sprzegla*/
double dizel_nmax_cutoff = 0.0; /*predkosc obrotowa zadzialania ogranicznika predkosci*/
double dizel_nmin = 0.0; /*najmniejsza dopuszczalna predkosc obrotowa*/
double dizel_minVelfullengage = 0.0; /*najmniejsza predkosc przy jezdzie ze sprzeglem bez poslizgu*/
double dizel_AIM = 1.0; /*moment bezwladnosci walu itp*/
double dizel_engageDia = 0.5; double dizel_engageMaxForce = 6000.0; double dizel_engagefriction = 0.5; /*parametry sprzegla*/
/*- dla lokomotyw spalinowo-elektrycznych -*/
double AnPos = 0.0; // pozycja sterowania dokladnego (analogowego)
bool AnalogCtrl = false; //
bool AnMainCtrl = false; //
bool ShuntModeAllow = false;
bool ShuntMode = false;
/*- dla lokomotyw spalinowo-elektrycznych -*/
double AnPos; // pozycja sterowania dokladnego (analogowego)
bool AnalogCtrl; //
bool AnMainCtrl; //
bool ShuntModeAllow;
bool ShuntMode;
bool Flat;
double Vhyp;
bool Flat = false;
double Vhyp = 1.0;
TDESchemeTable DElist;
double Vadd;
double Vadd = 1.0;
TMPTRelayTable MPTRelay;
int RelayType;
int RelayType = 0;
TShuntSchemeTable SST;
double PowerCorRatio; //Wspolczynnik korekcyjny
/*- dla uproszczonego modelu silnika (dumb) oraz dla drezyny*/
double Ftmax;
double PowerCorRatio = 1.0; //Wspolczynnik korekcyjny
/*- dla uproszczonego modelu silnika (dumb) oraz dla drezyny*/
double Ftmax = 0.0;
/*- dla lokomotyw z silnikami indukcyjnymi -*/
double eimc[26];
/*-dla wagonow*/
long MaxLoad; /*masa w T lub ilosc w sztukach - ladownosc*/
long MaxLoad = 0.0; /*masa w T lub ilosc w sztukach - ladownosc*/
std::string LoadAccepted; std::string LoadQuantity; /*co moze byc zaladowane, jednostki miary*/
double OverLoadFactor; /*ile razy moze byc przekroczona ladownosc*/
double LoadSpeed; double UnLoadSpeed;/*szybkosc na- i rozladunku jednostki/s*/
int DoorOpenCtrl; int DoorCloseCtrl; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/
double DoorStayOpen; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/
bool DoorClosureWarning; /*czy jest ostrzeganie przed zamknieciem*/
double DoorOpenSpeed; double DoorCloseSpeed; /*predkosc otwierania i zamykania w j.u. */
double DoorMaxShiftL; double DoorMaxShiftR; double DoorMaxPlugShift;/*szerokosc otwarcia lub kat*/
int DoorOpenMethod; /*sposob otwarcia - 1: przesuwne, 2: obrotowe, 3: trójelementowe*/
double PlatformSpeed; /*szybkosc stopnia*/
double PlatformMaxShift; /*wysuniecie stopnia*/
int PlatformOpenMethod; /*sposob animacji stopnia*/
bool ScndS; /*Czy jest bocznikowanie na szeregowej*/
/*--sekcja zmiennych*/
/*--opis konkretnego egzemplarza taboru*/
double OverLoadFactor = 0.0; /*ile razy moze byc przekroczona ladownosc*/
double LoadSpeed = 0.0; double UnLoadSpeed = 0.0;/*szybkosc na- i rozladunku jednostki/s*/
int DoorOpenCtrl = 0; int DoorCloseCtrl = 0; /*0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)*/
double DoorStayOpen = 0.0; /*jak dlugo otwarte w przypadku DoorCloseCtrl=2*/
bool DoorClosureWarning = false; /*czy jest ostrzeganie przed zamknieciem*/
double DoorOpenSpeed = 1.0; double DoorCloseSpeed = 1.0; /*predkosc otwierania i zamykania w j.u. */
double DoorMaxShiftL = 0.5; double DoorMaxShiftR = 0.5; double DoorMaxPlugShift = 0.5;/*szerokosc otwarcia lub kat*/
int DoorOpenMethod = 2; /*sposob otwarcia - 1: przesuwne, 2: obrotowe, 3: trójelementowe*/
double PlatformSpeed = 0.25; /*szybkosc stopnia*/
double PlatformMaxShift = 0.5; /*wysuniecie stopnia*/
int PlatformOpenMethod = 1; /*sposob animacji stopnia*/
bool ScndS = false; /*Czy jest bocznikowanie na szeregowej*/
/*--sekcja zmiennych*/
/*--opis konkretnego egzemplarza taboru*/
TLocation Loc; //pozycja pojazdów do wyznaczenia odległości pomiędzy sprzęgami
TRotation Rot;
std::string Name; /*nazwa wlasna*/
TCoupling Couplers[2]; //urzadzenia zderzno-sprzegowe, polaczenia miedzy wagonami
double HVCouplers[2][2]; //przewod WN
int ScanCounter; /*pomocnicze do skanowania sprzegow*/
bool EventFlag; /*!o true jesli cos nietypowego sie wydarzy*/
int SoundFlag; /*!o patrz stale sound_ */
double DistCounter; /*! licznik kilometrow */
double V; //predkosc w [m/s] względem sprzęgów (dodania gdy jedzie w stronę 0)
double Vel; //moduł prędkości w [km/h], używany przez AI
double AccS; //efektywne przyspieszenie styczne w [m/s^2] (wszystkie siły)
double AccN; //przyspieszenie normalne w [m/s^2]
double AccV;
double nrot;
int ScanCounter = 0; /*pomocnicze do skanowania sprzegow*/
bool EventFlag = false; /*!o true jesli cos nietypowego sie wydarzy*/
int SoundFlag = 0; /*!o patrz stale sound_ */
double DistCounter = 0.0; /*! licznik kilometrow */
double V = 0.0; //predkosc w [m/s] względem sprzęgów (dodania gdy jedzie w stronę 0)
double Vel = 0.0; //moduł prędkości w [km/h], używany przez AI
double AccS = 0.0; //efektywne przyspieszenie styczne w [m/s^2] (wszystkie siły)
double AccN = 0.0; //przyspieszenie normalne w [m/s^2]
double AccV = 0.0;
double nrot = 0.0;
/*! rotacja kol [obr/s]*/
double EnginePower; /*! chwilowa moc silnikow*/
double dL; double Fb; double Ff; /*przesuniecie, sila hamowania i tarcia*/
double FTrain; double FStand; /*! sila pociagowa i oporow ruchu*/
double FTotal; /*! calkowita sila dzialajaca na pojazd*/
double UnitBrakeForce; /*!s siła hamowania przypadająca na jeden element*/
double Ntotal; /*!s siła nacisku klockow*/
bool SlippingWheels; bool SandDose; /*! poslizg kol, sypanie piasku*/
double Sand; /*ilosc piasku*/
double BrakeSlippingTimer; /*pomocnicza zmienna do wylaczania przeciwposlizgu*/
double dpBrake; double dpPipe; double dpMainValve; double dpLocalValve;
double EnginePower = 0.0; /*! chwilowa moc silnikow*/
double dL = 0.0; double Fb = 0.0; double Ff = 0.0; /*przesuniecie, sila hamowania i tarcia*/
double FTrain = 0.0; double FStand = 0.0; /*! sila pociagowa i oporow ruchu*/
double FTotal = 0.0; /*! calkowita sila dzialajaca na pojazd*/
double UnitBrakeForce = 0.0; /*!s siła hamowania przypadająca na jeden element*/
double Ntotal = 0.0; /*!s siła nacisku klockow*/
bool SlippingWheels = false; bool SandDose = false; /*! poslizg kol, sypanie piasku*/
double Sand = 0.0; /*ilosc piasku*/
double BrakeSlippingTimer = 0.0; /*pomocnicza zmienna do wylaczania przeciwposlizgu*/
double dpBrake = 0.0; double dpPipe = 0.0; double dpMainValve = 0.0; double dpLocalValve = 0.0;
/*! przyrosty cisnienia w kroku czasowym*/
double ScndPipePress; /*cisnienie w przewodzie zasilajacym*/
double BrakePress; /*!o cisnienie w cylindrach hamulcowych*/
double LocBrakePress; /*!o cisnienie w cylindrach hamulcowych z pomocniczego*/
double PipeBrakePress; /*!o cisnienie w cylindrach hamulcowych z przewodu*/
double PipePress; /*!o cisnienie w przewodzie glownym*/
double EqvtPipePress; /*!o cisnienie w przewodzie glownym skladu*/
double Volume; /*objetosc spr. powietrza w zbiorniku hamulca*/
double CompressedVolume; /*objetosc spr. powietrza w ukl. zasilania*/
double PantVolume; /*objetosc spr. powietrza w ukl. pantografu*/
double Compressor; /*! cisnienie w ukladzie zasilajacym*/
bool CompressorFlag; /*!o czy wlaczona sprezarka*/
bool PantCompFlag; /*!o czy wlaczona sprezarka pantografow*/
bool CompressorAllow; /*! zezwolenie na uruchomienie sprezarki NBMX*/
bool ConverterFlag; /*! czy wlaczona przetwornica NBMX*/
bool ConverterAllow; /*zezwolenie na prace przetwornicy NBMX*/
int BrakeCtrlPos; /*nastawa hamulca zespolonego*/
double BrakeCtrlPosR; /*nastawa hamulca zespolonego - plynna dla FV4a*/
double BrakeCtrlPos2; /*nastawa hamulca zespolonego - kapturek dla FV4a*/
int LocalBrakePos; /*nastawa hamulca indywidualnego*/
int ManualBrakePos; /*nastawa hamulca recznego*/
double LocalBrakePosA;
int BrakeStatus; /*0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg, 16 - uzyte EP, 32 - pozycja R, 64 - powrot z R*/
bool EmergencyBrakeFlag; /*hamowanie nagle*/
int BrakeDelayFlag; /*nastawa opoznienia ham. osob/towar/posp/exp 0/1/2/4*/
int BrakeDelays; /*nastawy mozliwe do uzyskania*/
int BrakeOpModeFlag; /*nastawa trybu pracy PS/PN/EP/MED 1/2/4/8*/
int BrakeOpModes; /*nastawy mozliwe do uzyskania*/
bool DynamicBrakeFlag; /*czy wlaczony hamulec elektrodymiczny*/
double ScndPipePress = 0.0; /*cisnienie w przewodzie zasilajacym*/
double BrakePress = 0.0; /*!o cisnienie w cylindrach hamulcowych*/
double LocBrakePress = 0.0; /*!o cisnienie w cylindrach hamulcowych z pomocniczego*/
double PipeBrakePress = 0.0; /*!o cisnienie w cylindrach hamulcowych z przewodu*/
double PipePress = 0.0; /*!o cisnienie w przewodzie glownym*/
double EqvtPipePress = 0.0; /*!o cisnienie w przewodzie glownym skladu*/
double Volume = 0.0; /*objetosc spr. powietrza w zbiorniku hamulca*/
double CompressedVolume = 0.0; /*objetosc spr. powietrza w ukl. zasilania*/
double PantVolume = 0.48; /*objetosc spr. powietrza w ukl. pantografu*/ // aby podniesione pantografy opadły w krótkim czasie przy wyłączonej sprężarce
double Compressor = 0.0; /*! cisnienie w ukladzie zasilajacym*/
bool CompressorFlag = false; /*!o czy wlaczona sprezarka*/
bool PantCompFlag = false; /*!o czy wlaczona sprezarka pantografow*/
bool CompressorAllow = false; /*! zezwolenie na uruchomienie sprezarki NBMX*/
bool ConverterFlag = false ; /*! czy wlaczona przetwornica NBMX*/
bool ConverterAllow = false; /*zezwolenie na prace przetwornicy NBMX*/
int BrakeCtrlPos = -2; /*nastawa hamulca zespolonego*/
double BrakeCtrlPosR = 0.0; /*nastawa hamulca zespolonego - plynna dla FV4a*/
double BrakeCtrlPos2 = 0.0; /*nastawa hamulca zespolonego - kapturek dla FV4a*/
int LocalBrakePos = 0; /*nastawa hamulca indywidualnego*/
int ManualBrakePos = 0; /*nastawa hamulca recznego*/
double LocalBrakePosA = 0.0;
int BrakeStatus = b_off; /*0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg, 16 - uzyte EP, 32 - pozycja R, 64 - powrot z R*/
bool EmergencyBrakeFlag = false; /*hamowanie nagle*/
int BrakeDelayFlag = 0; /*nastawa opoznienia ham. osob/towar/posp/exp 0/1/2/4*/
int BrakeDelays = 0; /*nastawy mozliwe do uzyskania*/
int BrakeOpModeFlag = 0; /*nastawa trybu pracy PS/PN/EP/MED 1/2/4/8*/
int BrakeOpModes = 0; /*nastawy mozliwe do uzyskania*/
bool DynamicBrakeFlag = false; /*czy wlaczony hamulec elektrodymiczny*/
// NapUdWsp: integer;
double LimPipePress; /*stabilizator cisnienia*/
double ActFlowSpeed; /*szybkosc stabilizatora*/
double LimPipePress = 0.0; /*stabilizator cisnienia*/
double ActFlowSpeed = 0.0; /*szybkosc stabilizatora*/
int DamageFlag; //kombinacja bitowa stalych dtrain_* }
int EngDmgFlag; //kombinacja bitowa stalych usterek}
int DerailReason; //przyczyna wykolejenia
int DamageFlag = 0; //kombinacja bitowa stalych dtrain_* }
int EngDmgFlag = 0; //kombinacja bitowa stalych usterek}
int DerailReason = 0; //przyczyna wykolejenia
//EndSignalsFlag: byte; {ABu 060205: zmiany - koncowki: 1/16 - swiatla prz/tyl, 2/31 - blachy prz/tyl}
//HeadSignalsFlag: byte; {ABu 060205: zmiany - swiatla: 1/2/4 - przod, 16/32/63 - tyl}
@@ -843,107 +835,115 @@ public:
/*i wykonywana przez RunInternalCommand*/
std::string CommandOut; /*komenda przekazywana przez ExternalCommand*/
std::string CommandLast; //Ra: ostatnio wykonana komenda do podglądu
double ValueOut; /*argument komendy która ma byc przekazana na zewnatrz*/
double ValueOut = 0.0; /*argument komendy która ma byc przekazana na zewnatrz*/
TTrackShape RunningShape;/*geometria toru po ktorym jedzie pojazd*/
TTrackParam RunningTrack;/*parametry toru po ktorym jedzie pojazd*/
double OffsetTrackH; double OffsetTrackV; /*przesuniecie poz. i pion. w/m osi toru*/
double OffsetTrackH = 0.0; double OffsetTrackV = 0.0; /*przesuniecie poz. i pion. w/m osi toru*/
/*-zmienne dla lokomotyw*/
bool Mains; /*polozenie glownego wylacznika*/
int MainCtrlPos; /*polozenie glownego nastawnika*/
int ScndCtrlPos; /*polozenie dodatkowego nastawnika*/
int LightsPos;
int ActiveDir; //czy lok. jest wlaczona i w ktorym kierunku:
/*-zmienne dla lokomotyw*/
bool Mains = false; /*polozenie glownego wylacznika*/
int MainCtrlPos = 0; /*polozenie glownego nastawnika*/
int ScndCtrlPos = 0; /*polozenie dodatkowego nastawnika*/
int LightsPos = 0;
int ActiveDir = 0; //czy lok. jest wlaczona i w ktorym kierunku:
//względem wybranej kabiny: -1 - do tylu, +1 - do przodu, 0 - wylaczona
int CabNo; //numer kabiny, z której jest sterowanie: 1 lub -1; w przeciwnym razie brak sterowania - rozrzad
int DirAbsolute; //zadany kierunek jazdy względem sprzęgów (1=w strone 0,-1=w stronę 1)
int ActiveCab; //numer kabiny, w ktorej jest obsada (zwykle jedna na skład)
double LastSwitchingTime; /*czas ostatniego przelaczania czegos*/
int CabNo = 0; //numer kabiny, z której jest sterowanie: 1 lub -1; w przeciwnym razie brak sterowania - rozrzad
int DirAbsolute = 0; //zadany kierunek jazdy względem sprzęgów (1=w strone 0,-1=w stronę 1)
int ActiveCab = 0; //numer kabiny, w ktorej jest obsada (zwykle jedna na skład)
double LastSwitchingTime = 0.0; /*czas ostatniego przelaczania czegos*/
//WarningSignal: byte; {0: nie trabi, 1,2: trabi}
bool DepartureSignal; /*sygnal odjazdu*/
bool InsideConsist;
bool DepartureSignal = false; /*sygnal odjazdu*/
bool InsideConsist = false;
/*-zmienne dla lokomotywy elektrycznej*/
TTractionParam RunningTraction;/*parametry sieci trakcyjnej najblizej lokomotywy*/
double enrot; double Im; double Itot; double IHeating; double ITraction; double TotalCurrent; double Mm; double Mw; double Fw; double Ft;
double enrot = 0.0;
double Im = 0.0;
double Itot = 0.0;
double IHeating = 0.0;
double ITraction = 0.0;
double TotalCurrent = 0.0;
double Mm = 0.0;
double Mw = 0.0;
double Fw = 0.0;
double Ft = 0.0;
/*ilosc obrotow, prad silnika i calkowity, momenty, sily napedne*/
//Ra: Im jest ujemny, jeśli lok jedzie w stronę sprzęgu 1
//a ujemne powinien być przy odwróconej polaryzacji sieci...
//w wielu miejscach jest używane abs(Im)
int Imin; int Imax; /*prad przelaczania automatycznego rozruchu, prad bezpiecznika*/
double Voltage; /*aktualne napiecie sieci zasilajacej*/
int MainCtrlActualPos; /*wskaznik RList*/
int ScndCtrlActualPos; /*wskaznik MotorParam*/
bool DelayCtrlFlag; //czy czekanie na 1. pozycji na załączenie?
double LastRelayTime; /*czas ostatniego przelaczania stycznikow*/
bool AutoRelayFlag; /*mozna zmieniac jesli AutoRelayType=2*/
bool FuseFlag; /*!o bezpiecznik nadmiarowy*/
bool ConvOvldFlag; /*! nadmiarowy przetwornicy i ogrzewania*/
bool StLinFlag; /*!o styczniki liniowe*/
bool ResistorsFlag; /*!o jazda rezystorowa*/
double RventRot; /*!s obroty wentylatorow rozruchowych*/
bool UnBrake; /*w EZT - nacisniete odhamowywanie*/
double PantPress; /*Cisnienie w zbiornikach pantografow*/
bool s_CAtestebrake; //hunter-091012: zmienna dla testu ca
int Imin = 0; int Imax = 0; /*prad przelaczania automatycznego rozruchu, prad bezpiecznika*/
double Voltage = 0.0; /*aktualne napiecie sieci zasilajacej*/
int MainCtrlActualPos = 0; /*wskaznik RList*/
int ScndCtrlActualPos = 0; /*wskaznik MotorParam*/
bool DelayCtrlFlag = false; //czy czekanie na 1. pozycji na załączenie?
double LastRelayTime = 0.0; /*czas ostatniego przelaczania stycznikow*/
bool AutoRelayFlag = false; /*mozna zmieniac jesli AutoRelayType=2*/
bool FuseFlag = false; /*!o bezpiecznik nadmiarowy*/
bool ConvOvldFlag = false; /*! nadmiarowy przetwornicy i ogrzewania*/
bool StLinFlag = false; /*!o styczniki liniowe*/
bool ResistorsFlag = false; /*!o jazda rezystorowa*/
double RventRot = 0.0; /*!s obroty wentylatorow rozruchowych*/
bool UnBrake = false; /*w EZT - nacisniete odhamowywanie*/
double PantPress = 0.0; /*Cisnienie w zbiornikach pantografow*/
bool s_CAtestebrake = false; //hunter-091012: zmienna dla testu ca
/*-zmienne dla lokomotywy spalinowej z przekladnia mechaniczna*/
double dizel_fill = 0.0; /*napelnienie*/
double dizel_engagestate = 0.0; /*sprzeglo skrzyni biegow: 0 - luz, 1 - wlaczone, 0.5 - wlaczone 50% (z poslizgiem)*/
double dizel_engage = 0.0; /*sprzeglo skrzyni biegow: aktualny docisk*/
double dizel_automaticgearstatus = 0.0; /*0 - bez zmiany, -1 zmiana na nizszy +1 zmiana na wyzszy*/
bool dizel_enginestart = false; /*czy trwa rozruch silnika*/
double dizel_engagedeltaomega = 0.0; /*roznica predkosci katowych tarcz sprzegla*/
/*-zmienne dla lokomotywy spalinowej z przekladnia mechaniczna*/
double dizel_fill; /*napelnienie*/
double dizel_engagestate; /*sprzeglo skrzyni biegow: 0 - luz, 1 - wlaczone, 0.5 - wlaczone 50% (z poslizgiem)*/
double dizel_engage; /*sprzeglo skrzyni biegow: aktualny docisk*/
double dizel_automaticgearstatus; /*0 - bez zmiany, -1 zmiana na nizszy +1 zmiana na wyzszy*/
bool dizel_enginestart; /*czy trwa rozruch silnika*/
double dizel_engagedeltaomega; /*roznica predkosci katowych tarcz sprzegla*/
/*- zmienne dla lokomotyw z silnikami indukcyjnymi -*/
/*- zmienne dla lokomotyw z silnikami indukcyjnymi -*/
double eimv[21];
/*-zmienne dla drezyny*/
double PulseForce; /*przylozona sila*/
double PulseForceTimer;
int PulseForceCount;
double PulseForce = 0.0; /*przylozona sila*/
double PulseForceTimer = 0.0;
int PulseForceCount = 0;
/*dla drezyny, silnika spalinowego i parowego*/
double eAngle;
double eAngle = 1.5;
/*-dla wagonow*/
long Load; /*masa w T lub ilosc w sztukach - zaladowane*/
long Load = 0.0; /*masa w T lub ilosc w sztukach - zaladowane*/
std::string LoadType; /*co jest zaladowane*/
int LoadStatus; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model
double LastLoadChangeTime; //raz (roz)ładowania
int LoadStatus = 0; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model
double LastLoadChangeTime = 0.0; //raz (roz)ładowania
bool DoorBlocked; //Czy jest blokada drzwi
bool DoorLeftOpened; //stan drzwi
bool DoorRightOpened;
bool PantFrontUp; //stan patykow 'Winger 160204
bool PantRearUp;
bool PantFrontSP; //dzwiek patykow 'Winger 010304
bool PantRearSP;
int PantFrontStart; //stan patykow 'Winger 160204
int PantRearStart;
double PantFrontVolt; //pantograf pod napieciem? 'Winger 160404
double PantRearVolt;
bool DoorBlocked = false; //Czy jest blokada drzwi
bool DoorLeftOpened = false; //stan drzwi
bool DoorRightOpened = false;
bool PantFrontUp = false; //stan patykow 'Winger 160204
bool PantRearUp = false;
bool PantFrontSP = true; //dzwiek patykow 'Winger 010304
bool PantRearSP = true;
int PantFrontStart = 0; //stan patykow 'Winger 160204
int PantRearStart = 0;
double PantFrontVolt = 0.0; //pantograf pod napieciem? 'Winger 160404
double PantRearVolt = 0.0;
std::string PantSwitchType;
std::string ConvSwitchType;
bool Heating; //ogrzewanie 'Winger 020304
int DoubleTr; //trakcja ukrotniona - przedni pojazd 'Winger 160304
bool Heating = false; //ogrzewanie 'Winger 020304
int DoubleTr = 1; //trakcja ukrotniona - przedni pojazd 'Winger 160304
bool PhysicActivation;
bool PhysicActivation = true;
/*ABu: stale dla wyznaczania sil (i nie tylko) po optymalizacji*/
double FrictConst1;
double FrictConst2s;
double FrictConst2d;
double TotalMassxg; /*TotalMass*g*/
double FrictConst1 = 0.0;
double FrictConst2s = 0.0;
double FrictConst2d= 0.0;
double TotalMassxg = 0.0; /*TotalMass*g*/
vector3 vCoulpler[2]; // powtórzenie współrzędnych sprzęgów z DynObj :/
vector3 DimHalf; // połowy rozmiarów do obliczeń geometrycznych
// int WarningSignal; //0: nie trabi, 1,2: trabi syreną o podanym numerze
int WarningSignal; // tymczasowo 8bit, ze względu na funkcje w MTools
double fBrakeCtrlPos; // płynna nastawa hamulca zespolonego
bool bPantKurek3; // kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z małą sprężarką
int iProblem; // flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać
int WarningSignal = 0; // tymczasowo 8bit, ze względu na funkcje w MTools
double fBrakeCtrlPos = -2.0; // płynna nastawa hamulca zespolonego
bool bPantKurek3 = true; // kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z małą sprężarką // domyślnie zbiornik pantografu połączony jest ze zbiornikiem głównym
int iProblem = 0; // flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać
int iLights[2]; // bity zapalonych świateł tutaj, żeby dało się liczyć pobór prądu
private:
double CouplerDist(int Coupler);

409
McZapkie/Mover.cpp
View File

@@ -86,7 +86,7 @@ double TMoverParameters::current(double n, double U)
double Rz, Delta, Isf;
double Mn; // przujmuje int, ale dla poprawnosci obliczeń
double Bn;
int SP;
int SP = 0;
double U1; // napiecie z korekta
MotorCurrent = 0;
@@ -266,10 +266,14 @@ double TMoverParameters::current(double n, double U)
TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
std::string NameInit, int LoadInitial,
std::string LoadTypeInitial,
int Cab) //: T_MoverParameters(VelInitial, TypeNameInit,
int Cab) ://: T_MoverParameters(VelInitial, TypeNameInit,
//NameInit, LoadInitial, LoadTypeInitial, Cab)
TypeName( TypeNameInit ),
ActiveCab( Cab ),
LoadType( LoadTypeInitial ),
Load( LoadInitial ),
Name( NameInit )
{
int b, k;
WriteLog(
"------------------------------------------------------");
WriteLog("init default physic values for " + NameInit + ", [" + TypeNameInit + "], [" +
@@ -278,71 +282,42 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
DimHalf.x = 0.5 * Dim.W; // połowa szerokości, OX jest w bok?
DimHalf.y = 0.5 * Dim.L; // połowa długości, OY jest do przodu?
DimHalf.z = 0.5 * Dim.H; // połowa wysokości, OZ jest w górę?
Cx = 0.0;
Floor = 0.960; // standardowa wysokość podłogi
// BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odcięcie (CHK jest jeszcze nie
// wczytane!)
bPantKurek3 = true; // domyślnie zbiornik pantografu połączony jest ze zbiornikiem głównym
iProblem = 0; // pojazd w pełni gotowy do ruchu
iLights[0] = iLights[1] = 0; //światła zgaszone
// BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odcięcie (CHK jest jeszcze nie wczytane!)
iLights[ 0 ] = 0;
iLights[ 1 ] = 0; //światła zgaszone
// inicjalizacja stalych
dMoveLen = 0.0;
CategoryFlag = 1;
TrainType = 0;
EngineType = None;
EnginePowerSource = TPowerParameters();
SystemPowerSource = TPowerParameters();
for (b = 0; b < ResArraySize + 1; ++b)
for (int b = 0; b < ResArraySize + 1; ++b)
{
RList[b] = TScheme();
}
RlistSize = 0;
for (b = 0; b < MotorParametersArraySize + 1; ++b)
MotorParam[b] = TMotorParameters();
WheelDiameter = 1.0;
WheelDiameterL = 0.9;
WheelDiameterT = 0.9;
TrackW = 1.435;
AxleInertialMoment = 0.0;
AxleArangement = "";
NPoweredAxles = 0;
NAxles = 0;
BearingType = 1;
ADist = 0.0;
BDist = 0.0;
SandCapacity = 0.0;
BrakeCtrlPosNo = 0;
LightsPosNo = 0;
LightsDefPos = 1;
LightsWrap = false;
for (b = 0; b < 2; b++)
for (k = 1; k <= 17; k++)
Lights[b][k] = 0;
for (k = -1; k <= MainBrakeMaxPos; k++)
{
BrakePressureTable[k].PipePressureVal = 0.0;
BrakePressureTable[k].BrakePressureVal = 0.0;
BrakePressureTable[k].FlowSpeedVal = 0.0;
for(int b = 0; b < MotorParametersArraySize + 1; ++b) {
MotorParam[ b ] = TMotorParameters();
}
for (int b = 0; b < 2; ++b)
for (int k = 1; k <= 17; ++k)
Lights[b][k] = 0;
for (int b = -1; b <= MainBrakeMaxPos; ++b)
{
BrakePressureTable[b].PipePressureVal = 0.0;
BrakePressureTable[b].BrakePressureVal = 0.0;
BrakePressureTable[b].FlowSpeedVal = 0.0;
}
// with BrakePressureTable[-2] do {pozycja odciecia}
{
BrakePressureTable[-2].PipePressureVal = -1.0;
BrakePressureTable[-2].BrakePressureVal = -1.0;
BrakePressureTable[-2].FlowSpeedVal = 0.0;
}
Transmision = TTransmision();
for( int b = 0; b < 4; ++b ) {
BrakeDelay[ b ] = 0.0;
}
NBpA = 0;
DynamicBrakeType = 0;
ASBType = 0;
AutoRelayType = 0;
for (b = 0; b < 2; b++) // Ra: kto tu zrobił "for b:=1 to 2 do" ???
for (int b = 0; b < 2; ++b) // Ra: kto tu zrobił "for b:=1 to 2 do" ???
{
Couplers[b].CouplerType = NoCoupler;
Couplers[b].SpringKB = 1.0;
@@ -352,158 +327,25 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
Couplers[b].DmaxC = 0.1;
Couplers[b].FmaxC = 1000.0;
}
for( b = 0; b < 2; ++b ) {
for(int b = 0; b < 2; ++b ) {
HVCouplers[ b ][ 0 ] = 0.0;
HVCouplers[ b ][ 1 ] = 0.0;
}
Power = 0.0;
MaxLoad = 0;
LoadAccepted = "";
LoadSpeed = 0.0;
UnLoadSpeed = 0.0;
HeatingPower = 0.0;
LightPower = 0.0;
BatteryVoltage = 0.0;
NominalBatteryVoltage = 0.0;
NominalVoltage = 0.0;
WindingRes = 0.0;
u = 0.0;
CircuitRes = 0.0;
IminLo, IminHi, ImaxLo, ImaxHi, Imin, Imax = 0.0;
nmax = 0.0;
Voltage = 0.0;
for( int b = 0; b < 3; ++b ) {
BrakeCylMult[ b ] = 0.0;
}
HeatingPowerSource = TPowerParameters();
//HeatingPowerSource.MaxVoltage = 0.0;
//HeatingPowerSource.MaxCurrent = 0.0;
//HeatingPowerSource.IntR = 0.001;
//HeatingPowerSource.SourceType = NotDefined;
//HeatingPowerSource.PowerType = NoPower;
//HeatingPowerSource.RPowerCable.PowerTrans = NoPower;
AlterHeatPowerSource = TPowerParameters();
//AlterHeatPowerSource.MaxVoltage = 0.0;
//AlterHeatPowerSource.MaxCurrent = 0.0;
//AlterHeatPowerSource.IntR = 0.001;
//AlterHeatPowerSource.SourceType = NotDefined;
//AlterHeatPowerSource.PowerType = NoPower;
//AlterHeatPowerSource.RPowerCable.PowerTrans = NoPower;
LightPowerSource = TPowerParameters();
//LightPowerSource.MaxVoltage = 0.0;
//LightPowerSource.MaxCurrent = 0.0;
//LightPowerSource.IntR = 0.001;
//LightPowerSource.SourceType = NotDefined;
//LightPowerSource.PowerType = NoPower;
//LightPowerSource.RPowerCable.PowerTrans = NoPower;
AlterLightPowerSource = TPowerParameters();
//AlterLightPowerSource.MaxVoltage = 0.0;
//AlterLightPowerSource.MaxCurrent = 0.0;
//AlterLightPowerSource.IntR = 0.001;
//AlterLightPowerSource.SourceType = NotDefined;
//AlterLightPowerSource.PowerType = NoPower;
//AlterLightPowerSource.RPowerCable.PowerTrans = NoPower;
TypeName = TypeNameInit;
HighPipePress = 0.0;
LowPipePress = 0.0;
DeltaPipePress = 0.0;
EqvtPipePress = 0.0;
CntrlPipePress = 0.0;
BrakeCylNo = 0;
BrakeCylRadius = 0.0;
BrakeCylDist = 0.0;
for (b = 0; b < 3; b++)
BrakeCylMult[b] = 0.0;
VeselVolume = 0.0;
BrakeVolume = 0.0;
BrakeVVolume = 0.0;
RapidMult = 1.0;
BrakeCylSpring = 0.0;
BrakeSlckAdj = 0.0;
BrakeRigEff = 0.0;
BrakeValveSize = 0.0;
BrakeValveParams = "";
AnPos = 0.0;
AnalogCtrl, AnMainCtrl = false;
Spg = 0.0;
MinCompressor = 0.0;
MaxCompressor = 0.0;
CompressorSpeed = 0.0;
ScndPipePress = 0.0;
BrakePress = 0.0;
LocBrakePress = 0.0;
PipeBrakePress = 0.0;
EqvtPipePress = 0.0;
Volume = 0.0;
CompressedVolume = 0.0;
Compressor = 0.0;
CompressorFlag = false;
PantCompFlag = false;
ConverterAllow = false;
LimPipePress = 0.0;
ActFlowSpeed = 0.0;
dizel_Mmax = 1.0;
dizel_nMmax = 1.0;
dizel_Mnmax = 2.0;
dizel_nmax = 2.0;
dizel_nominalfill = 0.0;
dizel_Mstand = 0.0;
dizel_nmax_cutoff = 0.0;
dizel_nmin = 0.0;
dizel_minVelfullengage = 0.0;
dizel_AIM = 1.0;
dizel_engageDia = 0.5;
dizel_engageMaxForce = 6000.0;
dizel_engagefriction = 0.5;
TurboTest = 0;
DoorOpenCtrl = 0;
DoorCloseCtrl = 0;
DoorStayOpen = 0.0;
DoorClosureWarning = false;
DoorOpenSpeed = 1.0;
DoorCloseSpeed = 1.0;
DoorMaxShiftL = 0.5;
DoorMaxShiftR = 0.5;
DoorMaxPlugShift = 0.5;
DoorOpenMethod = 2;
DoorBlocked = false;
PlatformSpeed = 0.25;
PlatformMaxShift = 0.5;
PlatformOpenMethod = 1;
DepartureSignal = false;
InsideConsist = false;
CompressorPower = 1.0;
SmallCompressorPower = 0.0;
for (b = 0; b < 26; b++)
eimc[b] = 0.0;
for( int b = 0; b < 26; ++b ) {
eimc[ b ] = 0.0;
}
eimc[eimc_p_eped] = 1.5;
StopBrakeDecc = 0.0;
ScndInMain = false;
Vhyp = 1.0;
Vadd = 1.0;
Vmax = -1.0;
Mass = 0.0;
Power = 0.0;
Mred = 0.0;
TotalMass = 0.0;
PowerCorRatio = 1.0;
Ftmax = 0.0;
ScndS = false;
// inicjalizacja zmiennych}
// Loc:=LocInitial; //Ra: to i tak trzeba potem przesunąć, po ustaleniu pozycji na torze
// (potrzebna długość)
// Rot:=RotInitial;
for (b = 0; b < 2; b++)
for (int b = 0; b < 2; ++b)
{
Couplers[b].AllowedFlag = 3; // domyślnie hak i hamulec, inne trzeba włączyć jawnie w FIZ
Couplers[b].CouplingFlag = 0;
@@ -514,155 +356,20 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
Couplers[b].Dist = 0.0;
Couplers[b].CheckCollision = false;
}
ScanCounter = 0;
BrakeCtrlPos = -2; // to nie ma znaczenia, konstruktor w Mover.cpp zmienia na -2
fBrakeCtrlPos = BrakeCtrlPos;
BrakeCtrlPosR = 0.0;
BrakeCtrlPos2 = 0.0;
LocalBrakePos = 0;
LocalBrakePosA = 0.0;
ManualBrakePos = 0;
BrakeDelays = 0;
BrakeOpModeFlag = 0;
BrakeOpModes = 0;
BrakeDelayFlag = 0;
BrakeStatus = b_off;
EmergencyBrakeFlag = false;
MainCtrlPos = 0;
ScndCtrlPos = 0;
MainCtrlActualPos = 0;
ScndCtrlActualPos = 0;
CoupledCtrl = false;
IsCoupled = false;
DelayCtrlFlag = false;
AutoRelayFlag = false;
LightsPos = 0;
Heating = false;
Mains = false;
ActiveDir = 0; // kierunek nie ustawiony
CabNo = 0; // sterowania nie ma, ustawiana przez CabActivization()
ActiveCab = Cab; // obsada w podanej kabinie
DirAbsolute = 0;
SlippingWheels = false;
SandDose = false;
FuseFlag = false;
ConvOvldFlag = false; // hunter-251211
StLinFlag = false;
ResistorsFlag = false;
RventRot = 0.0;
RVentType = 0;
RVentnmax = 1.0;
RVentCutOff = 0.0;
enrot = 0.0;
nrot = 0.0;
Im = 0.0;
Itot = 0.0;
IHeating = 0.0;
ITraction = 0.0;
EnginePower = 0.0;
BrakePress = 0.0;
Compressor = 0.0;
ConverterFlag = false;
Trafo = false;
CompressorAllow = false;
DoorLeftOpened = false;
DoorRightOpened = false;
Battery = false;
EpFuse = true;
Signalling = false;
Radio = true;
DoorSignalling = false;
UnBrake = false;
// Winger 160204
PantVolume =
0.48; // aby podniesione pantografy opadły w krótkim czasie przy wyłączonej sprężarce
PantFrontUp = false;
PantRearUp = false;
PantFrontStart = 0;
PantRearStart = 0;
PantFrontSP = true;
PantRearSP = true;
PantPress = 0.0;
PantFrontVolt = 0.0;
PantRearVolt = 0.0;
PantSwitchType = "";
ConvSwitchType = "";
DoubleTr = 1;
BrakeSlippingTimer = 0.0;
dpBrake = 0.0;
dpPipe = 0.0;
dpMainValve = 0.0;
dpLocalValve = 0.0;
MBPM = 1.0;
DynamicBrakeFlag = false;
BrakeSystem = Individual;
BrakeSubsystem = ss_None;
BrakeValve = NoValve;
BrakeHandle = NoHandle;
BrakeLocHandle = NoHandle;
Hamulec = NULL;
Handle = NULL;
LocHandle = NULL;
Pipe = NULL;
Pipe2 = NULL;
LocalBrake = NoBrake;
MaxBrakeForce = 0.0;
MBrake = false;
for (b = 0; b < 5; b++)
for (int b = 0; b < 5; ++b)
{
MaxBrakePress[b] = 0.0;
}
P2FTrans = 0.0;
TrackBrakeForce = 0.0;
BrakeMethod = 0;
Ft = 0.0;
Ff = 0.0;
Fb = 0.0;
dL = 0.0;
FTotal = 0.0;
FStand = 0.0;
FTrain = 0.0;
UnitBrakeForce = 0.0;
Ntotal = 0.0;
AccS = 0.0;
AccN = 0.0;
AccV = 0.0;
EventFlag = false;
SoundFlag = 0;
Vel = abs(VelInitial);
V = VelInitial / 3.6;
LastSwitchingTime = 0.0;
LastRelayTime = 0.0;
DistCounter = 0.0;
PulseForce = 0.0;
PulseForceTimer = 0.0;
PulseForceCount = 0.0;
MainCtrlPosNo = 0;
ScndCtrlPosNo = 0;
InitialCtrlDelay, CtrlDelay, CtrlDownDelay = 0.0;
FastSerialCircuit = 0;
eAngle = 1.5;
dizel_fill = 0.0;
dizel_engagestate = 0.0;
dizel_engage = 0.0;
dizel_automaticgearstatus = 0.0;
dizel_enginestart = false;
dizel_engagedeltaomega = 0.0;
PhysicActivation = true;
for( int b = 0; b < 21; b++ ) {
eimv[ b ] = 0.0;
}
for (b = 0; b < 21; b++)
eimv[b] = 0.0;
RunningShape.R = 0.0;
RunningShape.Len = 1.0;
RunningShape.dHtrack = 0.0;
RunningShape.dHrail = 0.0;
RunningTrack.CategoryFlag = CategoryFlag;
RunningTrack.Width = TrackW;
@@ -676,20 +383,6 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
RunningTraction.TractionMaxCurrent = 0.0;
RunningTraction.TractionResistivity = 1.0;
OffsetTrackH = 0.0;
OffsetTrackV = 0.0;
CommandIn = TCommand();
//CommandIn.Command = "";
//CommandIn.Value1 = 0.0;
//CommandIn.Value2 = 0.0;
//CommandIn.Location.X = 0.0;
//CommandIn.Location.Y = 0.0;
//CommandIn.Location.Z = 0.0;
CommandLast, CommandOut = "";
ValueOut = 0.0;
// czesciowo stale, czesciowo zmienne}
SecuritySystem.SystemType = 0;
SecuritySystem.AwareDelay = -1.0;
SecuritySystem.SoundSignalDelay = -1.0;
@@ -712,29 +405,11 @@ TMoverParameters::TMoverParameters(double VelInitial, std::string TypeNameInit,
// if Pos(LoadTypeInitial,LoadAccepted)>0 then
// begin
//}
LoadType = LoadTypeInitial;
Load = LoadInitial;
LoadStatus = 0;
LastLoadChangeTime = 0.0;
LoadFlag = 0;
LoadQuantity = "";
OverLoadFactor = 0.0;
//{
// end
// else Load:=0;
// }
Name = NameInit;
DerailReason = 0; // Ra: powód wykolejenia
TotalCurrent = 0.0;
ShuntModeAllow = false;
ShuntMode = false;
Flat = false;
DamageFlag = 0;
EngDmgFlag = 0;
DerailReason = 0;
WarningSignal = 0;
};
double TMoverParameters::Distance(const TLocation &Loc1, const TLocation &Loc2,
@@ -1066,7 +741,11 @@ void TMoverParameters::UpdatePantVolume(double dt)
void TMoverParameters::UpdateBatteryVoltage(double dt)
{ // przeliczenie obciążenia baterii
double sn1, sn2, sn3, sn4, sn5; // Ra: zrobić z tego amperomierz NN
double sn1 = 0.0,
sn2 = 0.0,
sn3 = 0.0,
sn4 = 0.0,
sn5 = 0.0; // Ra: zrobić z tego amperomierz NN
if ((BatteryVoltage > 0) && (EngineType != DieselEngine) && (EngineType != WheelsDriven) &&
(NominalBatteryVoltage > 0))
{

17
RealSound.cpp
View File

@@ -20,23 +20,6 @@ http://mozilla.org/MPL/2.0/.
#include "Timer.h"
#include "mczapkie/mctools.h"
TRealSound::TRealSound()
{
pSound = NULL;
dSoundAtt = -1;
AM = 0.0;
AA = 0.0;
FM = 0.0;
FA = 0.0;
vSoundPosition.x = 0;
vSoundPosition.y = 0;
vSoundPosition.z = 0;
fDistance = fPreviousDistance = 0.0;
fFrequency = 22050.0; // częstotliwość samplowania pliku
iDoppler = 0; // normlanie jest załączony; !=0 - modyfikacje
bLoopPlay = false; // dźwięk wyłączony
}
TRealSound::TRealSound(std::string const &SoundName, double SoundAttenuation, double X, double Y, double Z, bool Dynamic,
bool freqmod, double rmin)
{

23
RealSound.h
View File

@@ -17,20 +17,21 @@ http://mozilla.org/MPL/2.0/.
class TRealSound
{
protected:
PSound pSound;
PSound pSound = nullptr;
// char *Nazwa; // dla celow odwszawiania NOTE: currently not used anywhere
double fDistance, fPreviousDistance; // dla liczenia Dopplera
float fFrequency; // częstotliwość samplowania pliku
int iDoppler; // Ra 2014-07: możliwość wyłączenia efektu Dopplera np. dla śpiewu ptaków
double fDistance = 0.0,
fPreviousDistance = 0.0; // dla liczenia Dopplera
float fFrequency = 22050.0; // częstotliwość samplowania pliku
int iDoppler = 0; // Ra 2014-07: możliwość wyłączenia efektu Dopplera np. dla śpiewu ptaków
public:
vector3 vSoundPosition; // polozenie zrodla dzwieku
double dSoundAtt; // odleglosc polowicznego zaniku dzwieku
double AM; // mnoznik amplitudy
double AA; // offset amplitudy
double FM; // mnoznik czestotliwosci
double FA; // offset czestotliwosci
bool bLoopPlay; // czy zapętlony dźwięk jest odtwarzany
TRealSound();
double dSoundAtt = -1.0; // odleglosc polowicznego zaniku dzwieku
double AM = 0.0; // mnoznik amplitudy
double AA = 0.0; // offset amplitudy
double FM = 0.0; // mnoznik czestotliwosci
double FA = 0.0; // offset czestotliwosci
bool bLoopPlay = false; // czy zapętlony dźwięk jest odtwarzany
TRealSound() = default;
TRealSound( std::string const &SoundName, double SoundAttenuation, double X, double Y, double Z, bool Dynamic,
bool freqmod = false, double rmin = 0.0);
~TRealSound();

4
Sound.cpp
View File

@@ -168,7 +168,7 @@ LPDIRECTSOUNDBUFFER TSoundContainer::GetUnique(LPDIRECTSOUND pDS)
if (!DSBuffer)
return NULL;
// jeśli się dobrze zainicjowało
LPDIRECTSOUNDBUFFER buff;
LPDIRECTSOUNDBUFFER buff = nullptr;
pDS->DuplicateSoundBuffer(DSBuffer, &buff);
if (buff)
DSBuffers.push(buff);
@@ -273,7 +273,7 @@ void TSoundsManager::RestoreAll()
HRESULT hr;
DWORD dwStatus;
DWORD dwStatus = 0;
for (int i = 0; i < Count; i++)
{

2
Texture.cpp
View File

@@ -581,7 +581,7 @@ TTexturesManager::AlphaValue TTexturesManager::LoadTGA(std::string fileName, int
GLubyte *imgData = new GLubyte[width * height * bytesPerPixel]; // nowy rozmiar
gluScaleImage(bytesPerPixel == 3 ? GL_RGB : GL_RGBA, w, h, GL_UNSIGNED_BYTE, imageData,
width, height, GL_UNSIGNED_BYTE, imgData);
delete imageData; // usunięcie starego
delete[] imageData; // usunięcie starego
imageData = imgData;
}
GLuint id = CreateTexture(imageData, (alpha ? GL_BGRA : GL_BGR), width, height, alpha, hash,

4
Timer.cpp
View File

@@ -70,7 +70,7 @@ double GetFPS()
void ResetTimers()
{
// double CurrentTime=
GetTickCount();
::GetTickCount64();
DeltaTime = 0.1;
DeltaRenderTime = 0;
fSoundTimer = 0;
@@ -102,7 +102,7 @@ void UpdateTimers(bool pause)
oldCount = count;
// Keep track of the time lapse and frame count
double fTime = GetTickCount() * 0.001f; // Get current time in seconds
double fTime = ::GetTickCount64() * 0.001f; // Get current time in seconds
++dwFrames; // licznik ramek
// update the frame rate once per second
if (fTime - fLastTime > 1.0f)

11
Track.cpp
View File

@@ -77,13 +77,10 @@ TIsolated::TIsolated()
TIsolated("none", NULL);
};
TIsolated::TIsolated(const string &n, TIsolated *i)
{ // utworznie obwodu izolowanego
asName = n;
pNext = i;
iAxles = 0;
evBusy = evFree = NULL;
pMemCell = NULL; // podpiąć istniejącą albo utworzyć pustą
TIsolated::TIsolated(const string &n, TIsolated *i) :
asName( n ), pNext( i )
{
// utworznie obwodu izolowanego. nothing to do here.
};
TIsolated::~TIsolated(){

10
Track.h
View File

@@ -98,14 +98,14 @@ const int iMaxNumDynamics = 40; // McZapkie-100303
class TIsolated
{ // obiekt zbierający zajętości z kilku odcinków
int iAxles; // ilość osi na odcinkach obsługiwanych przez obiekt
TIsolated *pNext; // odcinki izolowane są trzymane w postaci listy jednikierunkowej
int iAxles = 0; // ilość osi na odcinkach obsługiwanych przez obiekt
TIsolated *pNext = nullptr; // odcinki izolowane są trzymane w postaci listy jednikierunkowej
static TIsolated *pRoot; // początek listy
public:
std::string asName; // nazwa obiektu, baza do nazw eventów
TEvent *evBusy; // zdarzenie wyzwalane po zajęciu grupy
TEvent *evFree; // zdarzenie wyzwalane po całkowitym zwolnieniu zajętości grupy
TMemCell *pMemCell; // automatyczna komórka pamięci, która współpracuje z odcinkiem izolowanym
TEvent *evBusy = nullptr; // zdarzenie wyzwalane po zajęciu grupy
TEvent *evFree = nullptr; // zdarzenie wyzwalane po całkowitym zwolnieniu zajętości grupy
TMemCell *pMemCell = nullptr; // automatyczna komórka pamięci, która współpracuje z odcinkiem izolowanym
TIsolated();
TIsolated(const std::string &n, TIsolated *i);
~TIsolated();

35
Traction.cpp
View File

@@ -92,27 +92,14 @@ sekcji z sąsiedniego przęsła).
TTraction::TTraction()
{
pPoint1 = pPoint2 = pPoint3 = pPoint4 = vector3(0, 0, 0);
// vFront=vector3(0,0,1);
// vUp=vector3(0,1,0);
// vLeft=vector3(1,0,0);
fHeightDifference = 0;
iNumSections = 0;
iLines = 0;
// dwFlags= 0;
Wires = 2;
// fU=fR= 0;
uiDisplayList = 0;
asPowerSupplyName = "";
// mdPole= NULL;
// ReplacableSkinID= 0;
hvNext[0] = hvNext[1] = NULL;
iLast = 1; //że niby ostatni drut
psPowered = psPower[0] = psPower[1] = NULL; // na początku zasilanie nie podłączone
psSection = NULL; // na początku nie podłączone
hvParallel = NULL; // normalnie brak bieżni wspólnej
fResistance[0] = fResistance[1] = -1.0; // trzeba dopiero policzyć
iTries = 0; // ile razy próbować podłączyć, ustawiane później
hvNext[ 0 ] = nullptr;
hvNext[ 1 ] = nullptr;
psPower[ 0 ] = nullptr;
psPower[ 1 ] = nullptr; // na początku zasilanie nie podłączone
iNext[ 0 ] = 0;
iNext[ 1 ] = 0;
fResistance[ 0 ] = -1.0;
fResistance[ 1 ] = -1.0; // trzeba dopiero policzyć
}
TTraction::~TTraction()
@@ -149,7 +136,7 @@ void TTraction::Optimize()
pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glEnd();
// Nie wiem co 'Marcin
vector3 pt1, pt2, pt3, pt4, v1, v2;
Math3D::vector3 pt1, pt2, pt3, pt4, v1, v2;
v1 = pPoint4 - pPoint3;
v2 = pPoint2 - pPoint1;
float step = 0;
@@ -390,7 +377,7 @@ void TTraction::RaArrayFill(CVertNormTex *Vert)
Vert->z = pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert;
// Nie wiem co 'Marcin
vector3 pt1, pt2, pt3, pt4, v1, v2;
Math3D::vector3 pt1, pt2, pt3, pt4, v1, v2;
v1 = pPoint4 - pPoint3;
v2 = pPoint2 - pPoint1;
float step = 0;
@@ -552,7 +539,7 @@ void TTraction::RenderVBO(float mgn, int iPtr)
}
};
int TTraction::TestPoint(vector3 *Point)
int TTraction::TestPoint(Math3D::vector3 *Point)
{ // sprawdzanie, czy przęsła można połączyć
if (!hvNext[0])
if (pPoint1.Equal(Point))

46
Traction.h
View File

@@ -14,8 +14,6 @@ http://mozilla.org/MPL/2.0/.
#include "VBO.h"
#include "dumb3d.h"
using namespace Math3D;
class TTractionPowerSource;
class TTraction
@@ -29,35 +27,33 @@ class TTraction
// - z: wysokość bezwzględna drutu w danym miejsu
public: // na razie
TTractionPowerSource *psPower[2]; // najbliższe zasilacze z obu kierunków
TTractionPowerSource *psPowered; // ustawione tylko dla bezpośrednio zasilanego przęsła
TTractionPowerSource *psPowered = nullptr; // ustawione tylko dla bezpośrednio zasilanego przęsła
TTraction *hvNext[2]; //łączenie drutów w sieć
int iNext[2]; // do którego końca się łączy
int iLast; // ustawiony bit 0, jeśli jest ostatnim drutem w sekcji; bit1 - przedostatni
int iLast = 1; //że niby ostatni drut // ustawiony bit 0, jeśli jest ostatnim drutem w sekcji; bit1 - przedostatni
public:
GLuint uiDisplayList;
vector3 pPoint1, pPoint2, pPoint3, pPoint4;
vector3 vParametric; // współczynniki równania parametrycznego odcinka
double fHeightDifference; //,fMiddleHeight;
GLuint uiDisplayList = 0;
Math3D::vector3 pPoint1, pPoint2, pPoint3, pPoint4;
Math3D::vector3 vParametric; // współczynniki równania parametrycznego odcinka
double fHeightDifference = 0.0; //,fMiddleHeight;
// int iCategory,iMaterial,iDamageFlag;
// float fU,fR,fMaxI,fWireThickness;
int iNumSections;
int iLines; // ilosc linii dla VBO
float NominalVoltage;
float MaxCurrent;
float fResistivity; //[om/m], przeliczone z [om/km]
DWORD Material; // 1: Cu, 2: Al
float WireThickness;
DWORD DamageFlag; // 1: zasniedziale, 128: zerwana
int Wires;
float WireOffset;
int iNumSections = 0;
int iLines = 0; // ilosc linii dla VBO
float NominalVoltage = 0.0;
float MaxCurrent = 0.0;
float fResistivity = 0.0; //[om/m], przeliczone z [om/km]
DWORD Material = 0; // 1: Cu, 2: Al
float WireThickness = 0.0;
DWORD DamageFlag = 0; // 1: zasniedziale, 128: zerwana
int Wires = 2;
float WireOffset = 0.0;
std::string asPowerSupplyName; // McZapkie: nazwa podstacji trakcyjnej
TTractionPowerSource *
psSection; // zasilacz (opcjonalnie może to być pulpit sterujący EL2 w hali!)
TTractionPowerSource *psSection = nullptr; // zasilacz (opcjonalnie może to być pulpit sterujący EL2 w hali!)
std::string asParallel; // nazwa przęsła, z którym może być bieżnia wspólna
TTraction *hvParallel; // jednokierunkowa i zapętlona lista przęseł ewentualnej bieżni wspólnej
float fResistance[2]; // rezystancja zastępcza do punktu zasilania (0: przęsło zasilane, <0: do
// policzenia)
int iTries;
TTraction *hvParallel = nullptr; // jednokierunkowa i zapętlona lista przęseł ewentualnej bieżni wspólnej
float fResistance[2]; // rezystancja zastępcza do punktu zasilania (0: przęsło zasilane, <0: do policzenia)
int iTries = 0;
// bool bVisible;
// DWORD dwFlags;
@@ -75,7 +71,7 @@ class TTraction
int RaArrayPrepare();
void RaArrayFill(CVertNormTex *Vert);
void RenderVBO(float mgn, int iPtr);
int TestPoint(vector3 *Point);
int TestPoint(Math3D::vector3 *Point);
void Connect(int my, TTraction *with, int to);
void Init();
bool WhereIs();

27
TractionPower.cpp
View File

@@ -20,33 +20,16 @@ http://mozilla.org/MPL/2.0/.
//---------------------------------------------------------------------------
TTractionPowerSource::TTractionPowerSource(TGroundNode *node)
TTractionPowerSource::TTractionPowerSource(TGroundNode const *node) :
gMyNode( node )
{
NominalVoltage = 0;
VoltageFrequency = 0;
InternalRes = 0.2;
MaxOutputCurrent = 0;
FastFuseTimeOut = 1;
FastFuseRepetition = 3;
SlowFuseTimeOut = 60;
Recuperation = false;
TotalAdmitance = 1e-10; // 10Mom - jakaś tam upływność
TotalPreviousAdmitance = 1e-10; // zero jest szkodliwe
OutputVoltage = 0;
FastFuse = false;
SlowFuse = false;
FuseTimer = 0;
FuseCounter = 0;
psNode[0] = NULL; // sekcje zostaną podłączone do zasilaczy
psNode[1] = NULL;
bSection = false; // sekcja nie jest źródłem zasilania, tylko grupuje przęsła
gMyNode = node;
psNode[0] = nullptr; // sekcje zostaną podłączone do zasilaczy
psNode[1] = nullptr;
};
TTractionPowerSource::~TTractionPowerSource(){};
void TTractionPowerSource::Init(double u, double i)
void TTractionPowerSource::Init(double const u, double const i)
{ // ustawianie zasilacza przy braku w scenerii
NominalVoltage = u;
VoltageFrequency = 0;

42
TractionPower.h
View File

@@ -16,39 +16,39 @@ class TGroundNode;
class TTractionPowerSource
{
private:
double NominalVoltage;
double VoltageFrequency;
double InternalRes;
double MaxOutputCurrent;
double FastFuseTimeOut;
int FastFuseRepetition;
double SlowFuseTimeOut;
bool Recuperation;
double NominalVoltage = 0.0;
double VoltageFrequency = 0.0;
double InternalRes = 0.2;
double MaxOutputCurrent = 0.0;
double FastFuseTimeOut = 1.0;
int FastFuseRepetition = 3;
double SlowFuseTimeOut = 60.0;
bool Recuperation = false;
double TotalCurrent;
double TotalAdmitance;
double TotalPreviousAdmitance;
double OutputVoltage;
bool FastFuse;
bool SlowFuse;
double FuseTimer;
int FuseCounter;
TGroundNode *gMyNode; // wskaźnik na węzeł rodzica
double TotalCurrent = 0.0;
double TotalAdmitance = 1e-10; // 10Mom - jakaś tam upływność
double TotalPreviousAdmitance = 1e-10; // zero jest szkodliwe
double OutputVoltage = 0.0;
bool FastFuse = false;
bool SlowFuse = false;
double FuseTimer = 0.0;
int FuseCounter = 0;
TGroundNode const *gMyNode = nullptr; // wskaźnik na węzeł rodzica
protected:
public: // zmienne publiczne
TTractionPowerSource *psNode[2]; // zasilanie na końcach dla sekcji
bool bSection; // czy jest sekcją
bool bSection = false; // czy jest sekcją
public:
// AnsiString asName;
TTractionPowerSource(TGroundNode *node);
TTractionPowerSource(TGroundNode const *node);
~TTractionPowerSource();
void Init(double u, double i);
void Init(double const u, double const i);
bool Load(cParser *parser);
bool Render();
bool Update(double dt);
double CurrentGet(double res);
void VoltageSet(double v)
void VoltageSet(double const v)
{
NominalVoltage = v;
};

10
TrkFoll.cpp
View File

@@ -21,16 +21,6 @@ http://mozilla.org/MPL/2.0/.
#include "DynObj.h"
#include "Event.h"
TTrackFollower::TTrackFollower()
{
pCurrentTrack = NULL;
pCurrentSegment = NULL;
fCurrentDistance = 0;
pPosition = vAngles = vector3(0, 0, 0);
fDirection = 1; // jest przodem do Point2
fOffsetH = 0.0; // na starcie stoi na środku
}
TTrackFollower::~TTrackFollower()
{
}

18
TrkFoll.h
View File

@@ -16,21 +16,21 @@ http://mozilla.org/MPL/2.0/.
class TTrackFollower
{ // oś poruszająca się po torze
private:
TTrack *pCurrentTrack; // na którym torze siê znajduje
TTrack *pCurrentTrack = nullptr; // na którym torze siê znajduje
std::shared_ptr<TSegment> pCurrentSegment; // zwrotnice mog¹ mieæ dwa segmenty
double fCurrentDistance; // przesuniêcie wzglêdem Point1 w stronê Point2
double fDirection; // ustawienie wzglêdem toru: -1.0 albo 1.0, mno¿one przez dystans
double fCurrentDistance = 0.0; // przesuniêcie wzglêdem Point1 w stronê Point2
double fDirection = 1.0; // ustawienie wzglêdem toru: -1.0 albo 1.0, mno¿one przez dystans // jest przodem do Point2
bool ComputatePosition(); // przeliczenie pozycji na torze
TDynamicObject *Owner; // pojazd posiadający
int iEventFlag; // McZapkie-020602: informacja o tym czy wyzwalac zdarzenie: 0,1,2,3
int iEventallFlag;
int iSegment; // który segment toru jest używany (żeby nie przeskakiwało po przestawieniu
TDynamicObject *Owner = nullptr; // pojazd posiadający
int iEventFlag = 0; // McZapkie-020602: informacja o tym czy wyzwalac zdarzenie: 0,1,2,3
int iEventallFlag = 0;
int iSegment = 0; // który segment toru jest używany (żeby nie przeskakiwało po przestawieniu
// zwrotnicy pod taborem)
public:
double fOffsetH; // Ra: odległość środka osi od osi toru (dla samochodów) - użyć do wężykowania
double fOffsetH = 0.0; // Ra: odległość środka osi od osi toru (dla samochodów) - użyć do wężykowania
vector3 pPosition; // współrzędne XYZ w układzie scenerii
vector3 vAngles; // x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach)
TTrackFollower();
TTrackFollower() = default;
~TTrackFollower();
TTrack * SetCurrentTrack(TTrack *pTrack, int end);
bool Move(double fDistance, bool bPrimary);