eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-23 02:49:19 +02:00
Code Issues 123 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" #include "Timer.h"
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
TAdvancedSound::TAdvancedSound()
{
// SoundStart=SoundCommencing=SoundShut= NULL;
State = ss_Off;
fTime = 0;
fStartLength = 0;
fShutLength = 0;
}
TAdvancedSound::~TAdvancedSound() TAdvancedSound::~TAdvancedSound()
{ // Ra: stopowanie się sypie { // Ra: stopowanie się sypie
// SoundStart.Stop(); // SoundStart.Stop();

14
AdvSound.h
View File

@@ -26,15 +26,15 @@ class TAdvancedSound
TRealSound SoundStart; TRealSound SoundStart;
TRealSound SoundCommencing; TRealSound SoundCommencing;
TRealSound SoundShut; TRealSound SoundShut;
TSoundState State; TSoundState State = ss_Off;
double fTime; double fTime = 0.0;
double fStartLength; double fStartLength = 0.0;
double fShutLength; double fShutLength = 0.0;
double defAM; double defAM = 0.0;
double defFM; double defFM = 0.0;
public: public:
TAdvancedSound(); TAdvancedSound() = default;
~TAdvancedSound(); ~TAdvancedSound();
void Init( std::string const &NameOn, std::string const &Name, std::string const &NameOff, double DistanceAttenuation, vector3 const &pPosition); 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); 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] = fAnalog[0] =
(float)((ReadDataBuff[9] << 8) + ReadDataBuff[8]) / (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] = fAnalog[1] =
(float)((ReadDataBuff[11] << 8) + ReadDataBuff[10]) / Global::fMWDAnalogCalib[1][3]; (float)((ReadDataBuff[11] << 8) + ReadDataBuff[10]) / Global::fMWDAnalogCalib[1][2];
fAnalog[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] = fAnalog[3] =
(float)((ReadDataBuff[15] << 8) + ReadDataBuff[14]) / Global::fMWDAnalogCalib[3][3]; (float)((ReadDataBuff[15] << 8) + ReadDataBuff[14]) / Global::fMWDAnalogCalib[3][2];
CheckData(); CheckData();
return TRUE; return TRUE;

202
Driver.cpp
View File

@@ -1428,47 +1428,40 @@ void TController::TablePurger()
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche, TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche, bool primary) :// czy ma aktywnie prowadzić?
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 ControllingSet(); // utworzenie połączenia do sterowanego pojazdu
pVehicles[0] = pVehicle->GetFirstDynamic(0); // pierwszy w kierunku jazdy (Np. Pc1) if( pVehicle != nullptr ) {
pVehicles[1] = pVehicle->GetFirstDynamic(1); // ostatni w kierunku jazdy (końcówki) 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) }
{ else {
case -1: SendCtrlBroadcast("CabActivisation",1); break; pVehicles[ 0 ] = nullptr;
case 1: SendCtrlBroadcast("CabActivisation",2); break; pVehicles[ 1 ] = nullptr;
default: AIControllFlag:=False; //na wszelki wypadek }
} if( mvOccupied != nullptr ) {
*/ iDirectionOrder = mvOccupied->CabNo; // 1=do przodu (w kierunku sprzęgu 0)
iDirection = 0; VehicleName = mvOccupied->Name;
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; // TrainParams=NewTrainParams;
// if (TrainParams) // if (TrainParams)
// asNextStop=TrainParams->NextStop(); // asNextStop=TrainParams->NextStop();
@@ -1477,111 +1470,32 @@ TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
// OrderCommand=""; // OrderCommand="";
// OrderValue=0; // OrderValue=0;
OrdersClear(); 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) if( true == primary ) {
{ iDrivigFlags |= movePrimary; // aktywnie prowadzące pojazd
mkdir("physicslog\\"); }
LogFile.open(string("physicslog\\" + VehicleName + ".dat").c_str(),
std::ios::in | std::ios::out | std::ios::trunc); 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 #if LOGPRESS == 0
LogFile << string(" Time [s] Velocity [m/s] Acceleration [m/ss] Coupler.Dist[m] " LogFile << string( " Time [s] Velocity [m/s] Acceleration [m/ss] Coupler.Dist[m] "
"Coupler.Force[N] TractionForce [kN] FrictionForce [kN] " "Coupler.Force[N] TractionForce [kN] FrictionForce [kN] "
"BrakeForce [kN] BrakePress [MPa] PipePress [MPa] " "BrakeForce [kN] BrakePress [MPa] PipePress [MPa] "
"MotorCurrent [A] MCP SCP BCP LBP DmgFlag Command CVal1 CVal2") "MotorCurrent [A] MCP SCP BCP LBP DmgFlag Command CVal1 CVal2" )
.c_str() .c_str()
<< "\r\n"; << "\r\n";
#endif #endif
#if LOGPRESS == 1 #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 #endif
LogFile.flush(); 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() void TController::CloseLog()
@@ -2594,7 +2508,6 @@ bool TController::IncSpeed()
OK = mvControlling->IncMainCtrl(1); OK = mvControlling->IncMainCtrl(1);
} }
break; break;
break;
case WheelsDriven: case WheelsDriven:
if (!mvControlling->CabNo) if (!mvControlling->CabNo)
mvControlling->CabActivisation(); mvControlling->CabActivisation();
@@ -2748,12 +2661,15 @@ void TController::SpeedSet()
} }
break; break;
case ElectricSeriesMotor: case ElectricSeriesMotor:
if ((!mvControlling->StLinFlag) && (!mvControlling->DelayCtrlFlag) && if( ( false == mvControlling->StLinFlag )
(!iDrivigFlags & moveIncSpeed)) // styczniki liniowe rozłączone yBARC && ( false == mvControlling->DelayCtrlFlag )
&& ( 0 == ( iDrivigFlags & moveIncSpeed ) ) ) // styczniki liniowe rozłączone yBARC
{
// if (iDrivigFlags&moveIncSpeed) {} //jeśli czeka na załączenie liniowych // if (iDrivigFlags&moveIncSpeed) {} //jeśli czeka na załączenie liniowych
// else // else
while (DecSpeed()) while( DecSpeed() )
; // zerowanie napędu ; // zerowanie napędu
}
else if (Ready || (iDrivigFlags & movePress)) // o ile może jechać else if (Ready || (iDrivigFlags & movePress)) // o ile może jechać
if (fAccGravity < -0.10) // i jedzie pod górę większą niż 10 promil if (fAccGravity < -0.10) // i jedzie pod górę większą niż 10 promil
{ // procedura wjeżdżania na ekstremalne wzniesienia { // 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 NewCommand = Global::asCurrentSceneryPath + NewCommand + ".wav"; // na razie jeden
if (FileExists(NewCommand)) if (FileExists(NewCommand))
{ // wczytanie dźwięku odjazdu podawanego bezpośrenido { // 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, pVehicle->GetPosition().y, pVehicle->GetPosition().z,
false); false);
// rsGuardSignal->Stop(); // 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č NewCommand = NewCommand.insert(NewCommand.find_last_of("."),"radio"); // wstawienie przed kropkč
if (FileExists(NewCommand)) if (FileExists(NewCommand))
{ // wczytanie dźwięku odjazdu w wersji radiowej (słychać tylko w kabinie) { // 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, pVehicle->GetPosition().y, pVehicle->GetPosition().z,
false); false);
iGuardRadio = iRadioChannel; iGuardRadio = iRadioChannel;

183
Driver.h
View File

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

35
Event.cpp
View File

@@ -24,29 +24,16 @@ http://mozilla.org/MPL/2.0/.
#include "Ground.h" #include "Ground.h"
#include "McZapkie\mctools.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 if( false == m.empty() ) {
evNext = evNext2 = NULL; // utworzenie niejawnego odczytu komórki pamięci w torze
bEnabled = false; // false dla eventów używanych do skanowania sygnałów (nie dodawane do Type = tp_GetValues;
// kolejki) }
asNodeName = m; // nazwa obiektu powiązanego for( int i = 0; i < 13; ++i ) {
iQueued = 0; // nie został dodany do kolejki Params[ i ].asPointer = nullptr;
// 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
}; };
TEvent::~TEvent() TEvent::~TEvent()
@@ -328,8 +315,8 @@ void TEvent::Load(cParser *parser, vector3 *org)
// str = AnsiString(token.c_str()); // str = AnsiString(token.c_str());
if (token.substr(0, 19) == "PassengerStopPoint:") if (token.substr(0, 19) == "PassengerStopPoint:")
{ {
if (token.find("#")) if (token.find('#') != std::string::npos)
token = token.substr(0, token.find("#") - 1); // obcięcie unikatowości token = token.substr(0, token.find('#') - 1); // obcięcie unikatowości
bEnabled = false; // nie do kolejki (dla SetVelocity też, ale jak jest do toru bEnabled = false; // nie do kolejki (dla SetVelocity też, ale jak jest do toru
// dowiązany) // dowiązany)
Params[6].asCommand = cm_PassengerStopPoint; Params[6].asCommand = cm_PassengerStopPoint;

24
Event.h
View File

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

9
FadeSound.h
View File

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

2
Globals.cpp
View File

@@ -835,7 +835,7 @@ void Global::ConfigParse(cParser &Parser)
Parser.getTokens(); Parser.getTokens();
Parser >> token; Parser >> token;
int i = stol_def(token, -1); // numer wej�cia int i = stol_def(token, -1); // numer wej�cia
if ((i >= 0) || (i <= 1)) if ((i >= 0) && (i <= 3))
{ {
Parser.getTokens(3, false); Parser.getTokens(3, false);
Parser >> fMWDAnalogCalib[i][0] // max -> 2^16 -1 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() TGround::TGround()
{ {
// RootNode=NULL;
nRootDynamic = NULL;
QueryRootEvent = NULL;
tmpEvent = NULL;
tmp2Event = NULL;
OldQRE = NULL;
RootEvent = NULL;
iNumNodes = 0;
// pTrain=NULL;
Global::pGround = this; Global::pGround = this;
bInitDone = false; // Ra: żeby nie robiło dwa razy FirstInit
for (int i = 0; i < TP_LAST; i++) for( int i = 0; i < TP_LAST; ++i ) {
nRootOfType[i] = NULL; // zerowanie tablic wyszukiwania nRootOfType[ i ] = nullptr; // zerowanie tablic wyszukiwania
bDynamicRemove = false; // na razie nic do usunięcia }
sTracks = new TNames(); // nazwy torów - na razie tak sTracks = new TNames(); // nazwy torów - na razie tak
/*
::SecureZeroMemory( TempVerts, sizeof( TempVerts ) );
*/
::SecureZeroMemory( TempConnectionType, sizeof( TempConnectionType ) ); ::SecureZeroMemory( TempConnectionType, sizeof( TempConnectionType ) );
::SecureZeroMemory( pRendered, sizeof( pRendered ) );
} }
TGround::~TGround() TGround::~TGround()

28
Ground.h
View File

@@ -273,29 +273,37 @@ class TGroundRect : public TSubRect
class TGround class TGround
{ {
vector3 CameraDirection; // zmienna robocza przy renderowaniu 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 *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 TGroundRect Rects[iNumRects][iNumRects]; // mapa kwadratów kilometrowych
TEvent *RootEvent; // lista zdarzeń TEvent *RootEvent = nullptr; // lista zdarzeń
TEvent *QueryRootEvent, *tmpEvent, *tmp2Event, *OldQRE; TEvent *QueryRootEvent = nullptr,
*tmpEvent = nullptr,
*tmp2Event = nullptr,
*OldQRE = nullptr;
TSubRect *pRendered[1500]; // lista renderowanych sektorów TSubRect *pRendered[1500]; // lista renderowanych sektorów
int iNumNodes; int iNumNodes = 0;
vector3 pOrigin; vector3 pOrigin;
vector3 aRotate; vector3 aRotate;
bool bInitDone; bool bInitDone = false;
TGroundNode *nRootOfType[TP_LAST]; // tablica grupująca obiekty, przyspiesza szukanie TGroundNode *nRootOfType[TP_LAST]; // tablica grupująca obiekty, przyspiesza szukanie
// TGroundNode *nLastOfType[TP_LAST]; //ostatnia // TGroundNode *nLastOfType[TP_LAST]; //ostatnia
TSubRect srGlobal; // zawiera obiekty globalne (na razie wyzwalacze czasowe) 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 // 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 private: // metody prywatne
bool EventConditon(TEvent *e); bool EventConditon(TEvent *e);
public: public:
bool bDynamicRemove; // czy uruchomić procedurę usuwania pojazdów bool bDynamicRemove = false; // czy uruchomić procedurę usuwania pojazdów
TDynamicObject *LastDyn; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie... TDynamicObject *LastDyn = nullptr; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
// TTrain *pTrain; // TTrain *pTrain;
// double fVDozwolona; // double fVDozwolona;
// bool bTrabil; // bool bTrabil;

568
McZapkie/MOVER.h
View File

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

17
RealSound.cpp
View File

@@ -20,23 +20,6 @@ http://mozilla.org/MPL/2.0/.
#include "Timer.h" #include "Timer.h"
#include "mczapkie/mctools.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, TRealSound::TRealSound(std::string const &SoundName, double SoundAttenuation, double X, double Y, double Z, bool Dynamic,
bool freqmod, double rmin) bool freqmod, double rmin)
{ {

23
RealSound.h
View File

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

4
Sound.cpp
View File

@@ -168,7 +168,7 @@ LPDIRECTSOUNDBUFFER TSoundContainer::GetUnique(LPDIRECTSOUND pDS)
if (!DSBuffer) if (!DSBuffer)
return NULL; return NULL;
// jeśli się dobrze zainicjowało // jeśli się dobrze zainicjowało
LPDIRECTSOUNDBUFFER buff; LPDIRECTSOUNDBUFFER buff = nullptr;
pDS->DuplicateSoundBuffer(DSBuffer, &buff); pDS->DuplicateSoundBuffer(DSBuffer, &buff);
if (buff) if (buff)
DSBuffers.push(buff); DSBuffers.push(buff);
@@ -273,7 +273,7 @@ void TSoundsManager::RestoreAll()
HRESULT hr; HRESULT hr;
DWORD dwStatus; DWORD dwStatus = 0;
for (int i = 0; i < Count; i++) 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 GLubyte *imgData = new GLubyte[width * height * bytesPerPixel]; // nowy rozmiar
gluScaleImage(bytesPerPixel == 3 ? GL_RGB : GL_RGBA, w, h, GL_UNSIGNED_BYTE, imageData, gluScaleImage(bytesPerPixel == 3 ? GL_RGB : GL_RGBA, w, h, GL_UNSIGNED_BYTE, imageData,
width, height, GL_UNSIGNED_BYTE, imgData); width, height, GL_UNSIGNED_BYTE, imgData);
delete imageData; // usunięcie starego delete[] imageData; // usunięcie starego
imageData = imgData; imageData = imgData;
} }
GLuint id = CreateTexture(imageData, (alpha ? GL_BGRA : GL_BGR), width, height, alpha, hash, 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() void ResetTimers()
{ {
// double CurrentTime= // double CurrentTime=
GetTickCount(); ::GetTickCount64();
DeltaTime = 0.1; DeltaTime = 0.1;
DeltaRenderTime = 0; DeltaRenderTime = 0;
fSoundTimer = 0; fSoundTimer = 0;
@@ -102,7 +102,7 @@ void UpdateTimers(bool pause)
oldCount = count; oldCount = count;
// Keep track of the time lapse and frame 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 ++dwFrames; // licznik ramek
// update the frame rate once per second // update the frame rate once per second
if (fTime - fLastTime > 1.0f) if (fTime - fLastTime > 1.0f)

11
Track.cpp
View File

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

10
Track.h
View File

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

35
Traction.cpp
View File

@@ -92,27 +92,14 @@ sekcji z sąsiedniego przęsła).
TTraction::TTraction() TTraction::TTraction()
{ {
pPoint1 = pPoint2 = pPoint3 = pPoint4 = vector3(0, 0, 0); hvNext[ 0 ] = nullptr;
// vFront=vector3(0,0,1); hvNext[ 1 ] = nullptr;
// vUp=vector3(0,1,0); psPower[ 0 ] = nullptr;
// vLeft=vector3(1,0,0); psPower[ 1 ] = nullptr; // na początku zasilanie nie podłączone
fHeightDifference = 0; iNext[ 0 ] = 0;
iNumSections = 0; iNext[ 1 ] = 0;
iLines = 0; fResistance[ 0 ] = -1.0;
// dwFlags= 0; fResistance[ 1 ] = -1.0; // trzeba dopiero policzyć
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
} }
TTraction::~TTraction() TTraction::~TTraction()
@@ -149,7 +136,7 @@ void TTraction::Optimize()
pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset); pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glEnd(); glEnd();
// Nie wiem co 'Marcin // Nie wiem co 'Marcin
vector3 pt1, pt2, pt3, pt4, v1, v2; Math3D::vector3 pt1, pt2, pt3, pt4, v1, v2;
v1 = pPoint4 - pPoint3; v1 = pPoint4 - pPoint3;
v2 = pPoint2 - pPoint1; v2 = pPoint2 - pPoint1;
float step = 0; float step = 0;
@@ -390,7 +377,7 @@ void TTraction::RaArrayFill(CVertNormTex *Vert)
Vert->z = pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset; Vert->z = pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert; ++Vert;
// Nie wiem co 'Marcin // Nie wiem co 'Marcin
vector3 pt1, pt2, pt3, pt4, v1, v2; Math3D::vector3 pt1, pt2, pt3, pt4, v1, v2;
v1 = pPoint4 - pPoint3; v1 = pPoint4 - pPoint3;
v2 = pPoint2 - pPoint1; v2 = pPoint2 - pPoint1;
float step = 0; 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ć { // sprawdzanie, czy przęsła można połączyć
if (!hvNext[0]) if (!hvNext[0])
if (pPoint1.Equal(Point)) if (pPoint1.Equal(Point))

46
Traction.h
View File

@@ -14,8 +14,6 @@ http://mozilla.org/MPL/2.0/.
#include "VBO.h" #include "VBO.h"
#include "dumb3d.h" #include "dumb3d.h"
using namespace Math3D;
class TTractionPowerSource; class TTractionPowerSource;
class TTraction class TTraction
@@ -29,35 +27,33 @@ class TTraction
// - z: wysokość bezwzględna drutu w danym miejsu // - z: wysokość bezwzględna drutu w danym miejsu
public: // na razie public: // na razie
TTractionPowerSource *psPower[2]; // najbliższe zasilacze z obu kierunków 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ć TTraction *hvNext[2]; //łączenie drutów w sieć
int iNext[2]; // do którego końca się łączy 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: public:
GLuint uiDisplayList; GLuint uiDisplayList = 0;
vector3 pPoint1, pPoint2, pPoint3, pPoint4; Math3D::vector3 pPoint1, pPoint2, pPoint3, pPoint4;
vector3 vParametric; // współczynniki równania parametrycznego odcinka Math3D::vector3 vParametric; // współczynniki równania parametrycznego odcinka
double fHeightDifference; //,fMiddleHeight; double fHeightDifference = 0.0; //,fMiddleHeight;
// int iCategory,iMaterial,iDamageFlag; // int iCategory,iMaterial,iDamageFlag;
// float fU,fR,fMaxI,fWireThickness; // float fU,fR,fMaxI,fWireThickness;
int iNumSections; int iNumSections = 0;
int iLines; // ilosc linii dla VBO int iLines = 0; // ilosc linii dla VBO
float NominalVoltage; float NominalVoltage = 0.0;
float MaxCurrent; float MaxCurrent = 0.0;
float fResistivity; //[om/m], przeliczone z [om/km] float fResistivity = 0.0; //[om/m], przeliczone z [om/km]
DWORD Material; // 1: Cu, 2: Al DWORD Material = 0; // 1: Cu, 2: Al
float WireThickness; float WireThickness = 0.0;
DWORD DamageFlag; // 1: zasniedziale, 128: zerwana DWORD DamageFlag = 0; // 1: zasniedziale, 128: zerwana
int Wires; int Wires = 2;
float WireOffset; float WireOffset = 0.0;
std::string asPowerSupplyName; // McZapkie: nazwa podstacji trakcyjnej std::string asPowerSupplyName; // McZapkie: nazwa podstacji trakcyjnej
TTractionPowerSource * TTractionPowerSource *psSection = nullptr; // zasilacz (opcjonalnie może to być pulpit sterujący EL2 w hali!)
psSection; // 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 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 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 float fResistance[2]; // rezystancja zastępcza do punktu zasilania (0: przęsło zasilane, <0: do policzenia)
// policzenia) int iTries = 0;
int iTries;
// bool bVisible; // bool bVisible;
// DWORD dwFlags; // DWORD dwFlags;
@@ -75,7 +71,7 @@ class TTraction
int RaArrayPrepare(); int RaArrayPrepare();
void RaArrayFill(CVertNormTex *Vert); void RaArrayFill(CVertNormTex *Vert);
void RenderVBO(float mgn, int iPtr); void RenderVBO(float mgn, int iPtr);
int TestPoint(vector3 *Point); int TestPoint(Math3D::vector3 *Point);
void Connect(int my, TTraction *with, int to); void Connect(int my, TTraction *with, int to);
void Init(); void Init();
bool WhereIs(); 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; psNode[0] = nullptr; // sekcje zostaną podłączone do zasilaczy
VoltageFrequency = 0; psNode[1] = nullptr;
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;
}; };
TTractionPowerSource::~TTractionPowerSource(){}; TTractionPowerSource::~TTractionPowerSource(){};
void TTractionPowerSource::Init(double u, double i) void TTractionPowerSource::Init(double const u, double const i)
{ // ustawianie zasilacza przy braku w scenerii { // ustawianie zasilacza przy braku w scenerii
NominalVoltage = u; NominalVoltage = u;
VoltageFrequency = 0; VoltageFrequency = 0;

42
TractionPower.h
View File

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

10
TrkFoll.cpp
View File

@@ -21,16 +21,6 @@ http://mozilla.org/MPL/2.0/.
#include "DynObj.h" #include "DynObj.h"
#include "Event.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() TTrackFollower::~TTrackFollower()
{ {
} }

18
TrkFoll.h
View File

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