mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-07-20 03:19:19 +02:00
merge, with tmj renderer
This commit is contained in:
milek7
543
Driver.cpp
543
Driver.cpp
@@ -70,6 +70,8 @@ Tutaj łączymy teorię z praktyką - tu nic nie działa i nikt nie wie dlaczego
|
||||
// 17. otwieranie/zamykanie drzwi
|
||||
// 18. Ra: odczepianie z zahamowaniem i podczepianie
|
||||
// 19. dla Humandriver: tasma szybkosciomierza - zapis do pliku!
|
||||
// 20. wybór pozycji zaworu maszynisty w oparciu o zadane opoznienie hamowania
|
||||
|
||||
|
||||
// do zrobienia:
|
||||
// 1. kierownik pociagu
|
||||
@@ -507,7 +509,7 @@ void TController::TableTraceRoute(double fDistance, TDynamicObject *pVehicle)
|
||||
fCurrentDistance = lastspeedpoint.fDist;
|
||||
// nie doliczac dlugosci gdy: miniety początek lub jazda do konca toru
|
||||
fTrackLength = (
|
||||
( (lastspeedpoint.iFlags & ( spElapsed | spEnd )) != 0 ) ?
|
||||
( ( lastspeedpoint.iFlags & ( spElapsed | spEnd ) ) != 0 ) ?
|
||||
0.0 :
|
||||
pTrack->Length() );
|
||||
}
|
||||
@@ -633,8 +635,8 @@ void TController::TableTraceRoute(double fDistance, TDynamicObject *pVehicle)
|
||||
// jeśli kolejny ma większą prędkość niż poprzedni, to zapamiętać poprzedni (do czasu wyjechania)
|
||||
if( ( ( ( iLast != -1 )
|
||||
&& ( TestFlag( sSpeedTable[ iLast ].iFlags, spEnabled | spTrack ) ) ) ?
|
||||
( sSpeedTable[ iLast ].trTrack != tLast ) :
|
||||
true ) ) {
|
||||
( sSpeedTable[ iLast ].trTrack != tLast ) :
|
||||
true ) ) {
|
||||
// jeśli nie był dodany do tabelki
|
||||
if( TableAddNew() ) {
|
||||
// zapisanie toru z ograniczeniem prędkości
|
||||
@@ -691,7 +693,7 @@ void TController::TableCheck(double fDistance)
|
||||
vector3 dir = pVehicles[0]->VectorFront() * pVehicles[0]->DirectionGet(); // wektor kierunku jazdy
|
||||
vector3 pos = pVehicles[0]->HeadPosition(); // zaczynamy od pozycji pojazdu
|
||||
double len = 0.0; // odległość będziemy zliczać narastająco
|
||||
for( int i = 0; i <= iLast; ++i )
|
||||
for( int i = 0; i < iLast; ++i )
|
||||
{ // aktualizacja rekordów z wyjątkiem ostatniego
|
||||
if (sSpeedTable[i].iFlags & spEnabled) // jeśli pozycja istotna
|
||||
{
|
||||
@@ -1223,42 +1225,49 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
|
||||
}
|
||||
}
|
||||
else if (sSpeedTable[i].evEvent->StopCommand())
|
||||
{ // jeśli prędkość jest zerowa, a komórka zawiera komendę
|
||||
eSignNext = sSpeedTable[i].evEvent; // dla informacji
|
||||
if (iDrivigFlags &
|
||||
moveStopHere) // jeśli ma stać, dostaje komendę od razu
|
||||
go = cm_Command; // komenda z komórki, do wykonania po zatrzymaniu
|
||||
else if (sSpeedTable[i].fDist <= 20.0) // jeśli ma dociągnąć, to niech
|
||||
// dociąga (moveStopCloser
|
||||
// dotyczy dociągania do W4, nie
|
||||
// semafora)
|
||||
go = cm_Command; // komenda z komórki, do wykonania po zatrzymaniu
|
||||
{ // jeśli prędkość jest zerowa, a komórka zawiera komendę
|
||||
eSignNext = sSpeedTable[ i ].evEvent; // dla informacji
|
||||
if( true == TestFlag( iDrivigFlags, moveStopHere ) ) {
|
||||
// jeśli ma stać, dostaje komendę od razu
|
||||
go = cm_Command; // komenda z komórki, do wykonania po zatrzymaniu
|
||||
}
|
||||
else if( sSpeedTable[ i ].fDist <= 20.0 ) {
|
||||
// jeśli ma dociągnąć, to niech dociąga
|
||||
// (moveStopCloser dotyczy dociągania do W4, nie semafora)
|
||||
go = cm_Command; // komenda z komórki, do wykonania po zatrzymaniu
|
||||
}
|
||||
}
|
||||
} // jeśli nie ma zawalidrogi
|
||||
} // jeśli event
|
||||
if (v >= 0.0)
|
||||
{ // pozycje z prędkością -1 można spokojnie pomijać
|
||||
d = sSpeedTable[i].fDist;
|
||||
if ((sSpeedTable[i].iFlags & spElapsed) ?
|
||||
false :
|
||||
d > 0.0) // sygnał lub ograniczenie z przodu (+32=przejechane)
|
||||
{ // 2014-02: jeśli stoi, a ma do przejechania kawałek, to niech jedzie
|
||||
if ((mvOccupied->Vel == 0.0) ?
|
||||
((sSpeedTable[i].iFlags &
|
||||
(spEnabled | spEvent | spPassengerStopPoint)) ==
|
||||
(spEnabled | spEvent | spPassengerStopPoint)) &&
|
||||
(d > fMaxProximityDist) :
|
||||
false)
|
||||
a = (iDrivigFlags & moveStopCloser) ? fAcc : 0.0; // ma podjechać bliżej -
|
||||
// czy na pewno w tym
|
||||
// miejscu taki warunek?
|
||||
else
|
||||
{
|
||||
a = (v * v - mvOccupied->Vel * mvOccupied->Vel) /
|
||||
(25.92 * d); // przyspieszenie: ujemne, gdy trzeba hamować
|
||||
if (d < fMinProximityDist) // jak jest już blisko
|
||||
if (v < fVelDes)
|
||||
fVelDes = v; // ograniczenie aktualnej prędkości
|
||||
if( ( d > 0.0 )
|
||||
&& ( false == TestFlag( sSpeedTable[ i ].iFlags, spElapsed ) ) ) {
|
||||
// sygnał lub ograniczenie z przodu (+32=przejechane)
|
||||
// 2014-02: jeśli stoi, a ma do przejechania kawałek, to niech jedzie
|
||||
if( ( mvOccupied->Vel == 0.0 )
|
||||
&& ( d > fMaxProximityDist )
|
||||
&& ( true == TestFlag( sSpeedTable[ i ].iFlags, ( spEnabled | spEvent | spPassengerStopPoint ) ) ) ) {
|
||||
// ma podjechać bliżej - czy na pewno w tym miejscu taki warunek?
|
||||
a = (
|
||||
iDrivigFlags & moveStopCloser ?
|
||||
fAcc :
|
||||
0.0 );
|
||||
}
|
||||
else {
|
||||
// przyspieszenie: ujemne, gdy trzeba hamować
|
||||
a = ( v * v - mvOccupied->Vel * mvOccupied->Vel ) / ( 25.92 * d );
|
||||
if( fBrakeDist > 0.0 ) {
|
||||
// maintain desired acc while we have enough room to brake safely, when close enough start paying attention
|
||||
// try to make a smooth transition instead of sharp change
|
||||
a = interpolate( a, fAcc, clamp( ( d - fBrakeDist ) / fBrakeDist, 0.0, 1.0 ) );
|
||||
}
|
||||
if( ( d < fMinProximityDist )
|
||||
&& ( v < fVelDes ) ) {
|
||||
// jak jest już blisko, ograniczenie aktualnej prędkości
|
||||
fVelDes = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (sSpeedTable[i].iFlags & spTrack) // jeśli tor
|
||||
@@ -1276,20 +1285,18 @@ TCommandType TController::TableUpdate(double &fVelDes, double &fDist, double &fN
|
||||
else // event trzyma tylko jeśli VelNext=0, nawet po przejechaniu (nie powinno
|
||||
// dotyczyć samochodów?)
|
||||
a = (v == 0.0 ? -1.0 : fAcc); // ruszanie albo hamowanie
|
||||
if (a < fAcc && v == Min0R(v, fNext))
|
||||
{ // mniejsze przyspieszenie to mniejsza możliwość rozpędzenia się albo konieczność
|
||||
// hamowania
|
||||
|
||||
if ((a < fAcc) && (v == std::min(v, fNext))) {
|
||||
// mniejsze przyspieszenie to mniejsza możliwość rozpędzenia się albo konieczność hamowania
|
||||
// jeśli droga wolna, to może być a>1.0 i się tu nie załapuje
|
||||
// if (mvOccupied->Vel>10.0)
|
||||
fAcc = a; // zalecane przyspieszenie (nie musi być uwzględniane przez AI)
|
||||
fNext = v; // istotna jest prędkość na końcu tego odcinka
|
||||
fDist = d; // dlugość odcinka
|
||||
}
|
||||
else if ((fAcc > 0) && (v > 0) && (v <= fNext))
|
||||
{ // jeśli nie ma wskazań do hamowania, można podać drogę i prędkość na jej końcu
|
||||
else if ((fAcc > 0) && (v > 0) && (v <= fNext)) {
|
||||
// jeśli nie ma wskazań do hamowania, można podać drogę i prędkość na jej końcu
|
||||
fNext = v; // istotna jest prędkość na końcu tego odcinka
|
||||
fDist = d; // dlugość odcinka (kolejne pozycje mogą wydłużać drogę, jeśli
|
||||
// prędkość jest stała)
|
||||
fDist = d; // dlugość odcinka (kolejne pozycje mogą wydłużać drogę, jeśli prędkość jest stała)
|
||||
}
|
||||
} // if (v>=0.0)
|
||||
if (fNext >= 0.0)
|
||||
@@ -1331,7 +1338,7 @@ void TController::TablePurger()
|
||||
for( std::size_t idx = 0; idx < sSpeedTable.size() - 1; ++idx ) {
|
||||
auto const &speedpoint = sSpeedTable[ idx ];
|
||||
if( ( 0 == ( speedpoint.iFlags & spEnabled ) )
|
||||
|| ( ( (speedpoint.iFlags & ( spElapsed | spTrack | spCurve | spSwitch )) == ( spElapsed | spTrack | spCurve ) )
|
||||
|| ( ( ( speedpoint.iFlags & ( spElapsed | spTrack | spCurve | spSwitch ) ) == ( spElapsed | spTrack | spCurve ) )
|
||||
&& ( speedpoint.fVelNext < 0.0 ) ) ) {
|
||||
// NOTE: we could break out early here, but running through entire thing gives us exact size needed for new table
|
||||
++trimcount;
|
||||
@@ -1353,7 +1360,7 @@ void TController::TablePurger()
|
||||
}
|
||||
auto const &speedpoint = sSpeedTable[ idx ];
|
||||
if( ( 0 == ( speedpoint.iFlags & spEnabled ) )
|
||||
|| ( (( speedpoint.iFlags & ( spElapsed | spTrack | spCurve | spSwitch )) == ( spElapsed | spTrack | spCurve ) )
|
||||
|| ( ( ( speedpoint.iFlags & ( spElapsed | spTrack | spCurve | spSwitch ) ) == ( spElapsed | spTrack | spCurve ) )
|
||||
&& ( speedpoint.fVelNext < 0.0 ) ) ) {
|
||||
// if the trimmed point happens to be currently active semaphor we need to invalidate their placements
|
||||
if( idx == SemNextIndex ) {
|
||||
@@ -1583,12 +1590,14 @@ void TController::Activation()
|
||||
ControllingSet(); // utworzenie połączenia do sterowanego pojazdu (może się zmienić) -
|
||||
// silnikowy dla EZT
|
||||
}
|
||||
if (mvControlling->EngineType ==
|
||||
DieselEngine) // dla 2Ls150 - przed ustawieniem kierunku - można zmienić tryb pracy
|
||||
if (mvControlling->ShuntModeAllow)
|
||||
if( mvControlling->EngineType == DieselEngine ) {
|
||||
// dla 2Ls150 - przed ustawieniem kierunku - można zmienić tryb pracy
|
||||
if( mvControlling->ShuntModeAllow ) {
|
||||
mvControlling->CurrentSwitch(
|
||||
(OrderList[OrderPos] & Shunt) ||
|
||||
(fMass > 224000.0)); // do tego na wzniesieniu może nie dać rady na liniowym
|
||||
( ( OrderList[ OrderPos ] & Shunt ) == Shunt )
|
||||
|| ( fMass > 224000.0 ) ); // do tego na wzniesieniu może nie dać rady na liniowym
|
||||
}
|
||||
}
|
||||
// Ra: to przełączanie poniżej jest tu bez sensu
|
||||
mvOccupied->ActiveCab =
|
||||
iDirection; // aktywacja kabiny w prowadzonym pojeżdzie (silnikowy może być odwrotnie?)
|
||||
@@ -1683,6 +1692,45 @@ void TController::AutoRewident()
|
||||
}
|
||||
d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła)
|
||||
}
|
||||
//teraz zerujemy tabelkę opóźnienia hamowania
|
||||
double velstep = (mvOccupied->Vmax*0.5) / BrakeAccTableSize;
|
||||
for (int i = 0; i < BrakeAccTableSize; i++)
|
||||
{
|
||||
fBrake_a0[i+1] = 0;
|
||||
fBrake_a1[i+1] = 0;
|
||||
}
|
||||
d = pVehicles[0]; // pojazd na czele składu
|
||||
while (d)
|
||||
{ // 4. Przeliczanie siły hamowania
|
||||
for (int i = 0; i < BrakeAccTableSize; i++)
|
||||
{
|
||||
fBrake_a0[i+1] += d->MoverParameters->BrakeForceR(0.25, velstep*(1 + 2 * i));
|
||||
fBrake_a1[i+1] += d->MoverParameters->BrakeForceR(1.00, velstep*(1 + 2 * i));
|
||||
}
|
||||
d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła)
|
||||
}
|
||||
for (int i = 0; i < BrakeAccTableSize; i++)
|
||||
{
|
||||
fBrake_a1[i+1] -= fBrake_a0[i+1];
|
||||
fBrake_a0[i+1] /= fMass;
|
||||
fBrake_a0[i + 1] += 0.001*velstep*(1 + 2 * i);
|
||||
fBrake_a1[i+1] /= (12*fMass);
|
||||
}
|
||||
if (mvOccupied->TrainType == dt_EZT)
|
||||
{
|
||||
fAccThreshold = -fBrake_a0[BrakeAccTableSize] - 8 * fBrake_a1[BrakeAccTableSize];
|
||||
fBrakeReaction = 0.25;
|
||||
}
|
||||
else if (ustaw > 16)
|
||||
{
|
||||
fAccThreshold = -fBrake_a0[BrakeAccTableSize] - 4 * fBrake_a1[BrakeAccTableSize];
|
||||
fBrakeReaction = 1.00 + fLength*0.004;
|
||||
}
|
||||
else
|
||||
{
|
||||
fAccThreshold = -fBrake_a0[BrakeAccTableSize] - 1 * fBrake_a1[BrakeAccTableSize];
|
||||
fBrakeReaction = 1.00 + fLength*0.005;
|
||||
}
|
||||
};
|
||||
|
||||
int TController::CheckDirection() {
|
||||
@@ -1955,6 +2003,15 @@ bool TController::SetProximityVelocity(double NewDist,double NewVelNext)
|
||||
}
|
||||
*/
|
||||
|
||||
double TController::BrakeAccFactor()
|
||||
{
|
||||
// double Factor = 1 + fBrakeReaction*mvOccupied->Vel / (std::max(0.0, ActualProximityDist) + 1);
|
||||
double Factor = 1;
|
||||
if((ActualProximityDist>fMinProximityDist)||(mvOccupied->Vel<VelDesired+fVelPlus))
|
||||
Factor+=(fBrakeReaction*(mvOccupied->BrakeCtrlPosR < 0.5 ? 1.5 : 1))*mvOccupied->Vel / (std::max(0.0, ActualProximityDist) + 1) * ((AccDesired - AbsAccS_pub) / fAccThreshold);
|
||||
return Factor;
|
||||
}
|
||||
|
||||
void TController::SetDriverPsyche()
|
||||
{
|
||||
// double maxdist=0.5; //skalowanie dystansu od innego pojazdu, zmienic to!!!
|
||||
@@ -2298,17 +2355,41 @@ bool TController::IncBrake()
|
||||
}
|
||||
else {
|
||||
if( mvOccupied->BrakeCtrlPos + 1 == mvOccupied->BrakeCtrlPosNo ) {
|
||||
if( AccDesired < -1.5 ) // hamowanie nagle
|
||||
OK = mvOccupied->IncBrakeLevel();
|
||||
if (AccDesired < -1.5) // hamowanie nagle
|
||||
OK = mvOccupied->BrakeLevelAdd(1.0);
|
||||
else
|
||||
OK = false;
|
||||
}
|
||||
else {
|
||||
// dodane dla towarowego
|
||||
if( mvOccupied->BrakeDelayFlag == bdelay_G ?
|
||||
-AccDesired * 6.6 > std::min( 2, mvOccupied->BrakeCtrlPos ) :
|
||||
true ) {
|
||||
OK = mvOccupied->IncBrakeLevel();
|
||||
float pos_corr = 0;
|
||||
|
||||
TDynamicObject *d;
|
||||
d = pVehicles[0]; // pojazd na czele składu
|
||||
while (d)
|
||||
{ // przeliczanie dodatkowego potrzebnego spadku ciśnienia
|
||||
pos_corr+=(d->MoverParameters->Hamulec->GetCRP() - 5.0)*d->MoverParameters->TotalMass;
|
||||
d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła)
|
||||
}
|
||||
pos_corr = pos_corr / fMass * 2.5;
|
||||
|
||||
if (mvOccupied->BrakeHandle == FV4a)
|
||||
{
|
||||
pos_corr += mvOccupied->Handle->GetCP()*0.2;
|
||||
|
||||
}
|
||||
double deltaAcc = -AccDesired*BrakeAccFactor() - (fBrake_a0[0] + 4.0 * (mvOccupied->BrakeCtrlPosR - 1 - pos_corr)*fBrake_a1[0]);
|
||||
|
||||
if( deltaAcc > fBrake_a1[0])
|
||||
{
|
||||
if (mvOccupied->BrakeCtrlPosR<0.1)
|
||||
OK = mvOccupied->BrakeLevelAdd(1.0);
|
||||
else
|
||||
{
|
||||
OK = mvOccupied->BrakeLevelAdd(0.25);
|
||||
if ((deltaAcc > 5 * fBrake_a1[0]) && (mvOccupied->BrakeCtrlPosR <= 3.0))
|
||||
mvOccupied->BrakeLevelAdd(0.75);
|
||||
}
|
||||
}
|
||||
else
|
||||
OK = false;
|
||||
@@ -2341,6 +2422,7 @@ bool TController::IncBrake()
|
||||
bool TController::DecBrake()
|
||||
{ // zmniejszenie siły hamowania
|
||||
bool OK = false;
|
||||
double deltaAcc = 0;
|
||||
switch (mvOccupied->BrakeSystem)
|
||||
{
|
||||
case Individual:
|
||||
@@ -2350,8 +2432,18 @@ bool TController::DecBrake()
|
||||
OK = mvOccupied->DecLocalBrakeLevel(1 + floor(0.5 + fabs(AccDesired)));
|
||||
break;
|
||||
case Pneumatic:
|
||||
if (mvOccupied->BrakeCtrlPos > 0)
|
||||
OK = mvOccupied->DecBrakeLevel();
|
||||
deltaAcc = -AccDesired*BrakeAccFactor() - (fBrake_a0[0] + 4 * (mvOccupied->BrakeCtrlPosR-1.0)*fBrake_a1[0]);
|
||||
if (deltaAcc < 0)
|
||||
{
|
||||
if (mvOccupied->BrakeCtrlPosR > 0)
|
||||
{
|
||||
OK = mvOccupied->BrakeLevelAdd(-0.25);
|
||||
//if ((deltaAcc < 5 * fBrake_a1[0]) && (mvOccupied->BrakeCtrlPosR >= 1.2))
|
||||
// mvOccupied->BrakeLevelAdd(-1.0);
|
||||
if (mvOccupied->BrakeCtrlPosR < 0.74)
|
||||
mvOccupied->BrakeLevelSet(0.0);
|
||||
}
|
||||
}
|
||||
if (!OK)
|
||||
OK = mvOccupied->DecLocalBrakeLevel(2);
|
||||
if (mvOccupied->PipePress < 3.0)
|
||||
@@ -2842,7 +2934,7 @@ bool TController::PutCommand(std::string NewCommand, double NewValue1, double Ne
|
||||
else
|
||||
TrainParams->NewName(NewCommand); // czyści tabelkę przystanków
|
||||
delete tsGuardSignal;
|
||||
tsGuardSignal = NULL; // wywalenie kierownika
|
||||
tsGuardSignal = nullptr; // wywalenie kierownika
|
||||
if (NewCommand != "none")
|
||||
{
|
||||
if (!TrainParams->LoadTTfile(
|
||||
@@ -3222,7 +3314,7 @@ bool TController::UpdateSituation(double dt)
|
||||
if ((iDrivigFlags & movePrimary) == 0)
|
||||
return true; // pasywny nic nie robi
|
||||
|
||||
double AbsAccS;
|
||||
double AbsAccS = 0;
|
||||
// double VelReduced; //o ile km/h może przekroczyć dozwoloną prędkość bez hamowania
|
||||
bool UpdateOK = false;
|
||||
if (AIControllFlag)
|
||||
@@ -3245,6 +3337,10 @@ bool TController::UpdateSituation(double dt)
|
||||
// ABu-160305 testowanie gotowości do jazdy
|
||||
// Ra: przeniesione z DynObj, skład użytkownika też jest testowany, żeby mu przekazać, że ma
|
||||
// odhamować
|
||||
int index = double(BrakeAccTableSize) * (mvOccupied->Vel / mvOccupied->Vmax);
|
||||
index = std::min(BrakeAccTableSize, std::max(1, index));
|
||||
fBrake_a0[0] = fBrake_a0[index];
|
||||
fBrake_a1[0] = fBrake_a1[index];
|
||||
Ready = true; // wstępnie gotowy
|
||||
fReady = 0.0; // założenie, że odhamowany
|
||||
fAccGravity = 0.0; // przyspieszenie wynikające z pochylenia
|
||||
@@ -3424,6 +3520,8 @@ bool TController::UpdateSituation(double dt)
|
||||
// zalecane ciśnienie
|
||||
if (fMass > 1000000.0)
|
||||
fBrakeDist *= 2.0; // korekta dla ciężkich, bo przeżynają - da to coś?
|
||||
if ((-fAccThreshold>0.05)&&(mvOccupied->CategoryFlag==1))
|
||||
fBrakeDist = mvOccupied->Vel * mvOccupied->Vel / 25.92 / -fAccThreshold;
|
||||
if (mvOccupied->BrakeDelayFlag == bdelay_G)
|
||||
fBrakeDist = fBrakeDist + 2 * mvOccupied->Vel; // dla nastawienia G
|
||||
// koniecznie należy wydłużyć drogę na czas reakcji
|
||||
@@ -4224,8 +4322,19 @@ bool TController::UpdateSituation(double dt)
|
||||
if (mvOccupied->V == 0.0)
|
||||
AbsAccS = fAccGravity; // Ra 2014-03: jesli skład stoi, to działa na niego
|
||||
// składowa styczna grawitacji
|
||||
else
|
||||
AbsAccS = iDirection * mvOccupied->AccS; // przyspieszenie chwilowe, liczone
|
||||
else
|
||||
{
|
||||
AbsAccS = 0;
|
||||
TDynamicObject *d = pVehicles[0]; // pojazd na czele składu
|
||||
while (d)
|
||||
{
|
||||
AbsAccS += d->MoverParameters->TotalMass * d->MoverParameters->AccS * iDirection;
|
||||
d = d->Next(); // kolejny pojazd, podłączony od tyłu (licząc od czoła)
|
||||
}
|
||||
AbsAccS /= fMass;
|
||||
//AbsAccS = iDirection * mvOccupied->AccS; // przyspieszenie chwilowe, liczone
|
||||
}
|
||||
AbsAccS_pub = AbsAccS;
|
||||
// jako różnica skierowanej prędkości w
|
||||
// czasie
|
||||
// if (mvOccupied->V<0.0) AbsAccS=-AbsAccS; //Ra 2014-03: to trzeba przemyśleć
|
||||
@@ -4248,12 +4357,12 @@ bool TController::UpdateSituation(double dt)
|
||||
//(AbsAccS) - chwilowe przyspieszenie pojazu (uwzględnia grawitację), ujemne działa
|
||||
// przeciwnie do zadanego kierunku jazdy
|
||||
//(AccDesired) porównujemy z (fAccGravity) albo (AbsAccS)
|
||||
// if ((VelNext>=0.0)&&(ActualProximityDist>=0)&&(mvOccupied->Vel>=VelNext)) //gdy
|
||||
// zbliza sie i jest za szybko do NOWEGO
|
||||
if ((VelNext >= 0.0) && (ActualProximityDist <= scanmax) && (vel >= VelNext))
|
||||
{ // gdy zbliża się i jest za szybki do nowej prędkości, albo stoi na zatrzymaniu
|
||||
if (vel > 0.0)
|
||||
{ // jeśli jedzie
|
||||
if( ( VelNext >= 0.0 )
|
||||
&& ( ActualProximityDist <= scanmax )
|
||||
&& ( vel >= VelNext ) ) {
|
||||
// gdy zbliża się i jest za szybki do nowej prędkości, albo stoi na zatrzymaniu
|
||||
if (vel > 0.0) {
|
||||
// jeśli jedzie
|
||||
if ((vel < VelNext) ?
|
||||
(ActualProximityDist > fMaxProximityDist * (1 + 0.1 * vel)) :
|
||||
false) // dojedz do semafora/przeszkody
|
||||
@@ -4263,24 +4372,33 @@ bool TController::UpdateSituation(double dt)
|
||||
AccDesired = AccPreferred;
|
||||
// VelDesired:=Min0R(VelDesired,VelReduced+VelNext);
|
||||
}
|
||||
else if (ActualProximityDist > fMinProximityDist)
|
||||
{ // jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze
|
||||
// jest daleko
|
||||
if (vel <
|
||||
VelNext + 40.0) // dwustopniowe hamowanie - niski przy małej różnicy
|
||||
else if (ActualProximityDist > fMinProximityDist) {
|
||||
// jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko
|
||||
if (ActualProximityDist < fMaxProximityDist) {
|
||||
// jak minął już maksymalny dystans po prostu hamuj (niski stopień)
|
||||
// ma stanąć, a jest w drodze hamowania albo ma jechać
|
||||
// hamowanie tak, aby stanąć
|
||||
AccDesired = ( VelNext * VelNext - vel * vel ) / ( 25.92 * ( ActualProximityDist + 0.1 - 0.5*fMinProximityDist ) );
|
||||
AccDesired = std::min(AccDesired, fAccThreshold);
|
||||
VelDesired = 0.0;
|
||||
}
|
||||
else if ((vel < VelNext + fVelPlus)||((vel<VelNext+2*fVelPlus)&&
|
||||
(vel*vel<(VelNext + fVelPlus)*(VelNext + fVelPlus)-12.96*ActualProximityDist*std::min(0.0,AbsAccS)))) // jeśli niewielkie przekroczenie
|
||||
{ // AccDesired=0.0;
|
||||
AccDesired = 0.01; // proteza trochę: to
|
||||
}
|
||||
else if (ActualProximityDist*25.92*fBrake_a0[0] > 2*vel*vel)
|
||||
{ // jeśli ma stanąć, a mieści się w drodze hamowania
|
||||
AccDesired = AccPreferred;
|
||||
}
|
||||
else if ((vel <
|
||||
VelNext + 20.0)&&(false)) // dwustopniowe hamowanie - niski przy małej różnicy
|
||||
{ // jeśli jedzie wolniej niż VelNext+35km/h //Ra: 40, żeby nie
|
||||
// kombinował na zwrotnicach
|
||||
if (VelNext == 0.0)
|
||||
{ // jeśli ma się zatrzymać, musi być to robione precyzyjnie i
|
||||
// skutecznie
|
||||
if (ActualProximityDist <
|
||||
fMaxProximityDist) // jak minął już maksymalny dystans
|
||||
{ // po prostu hamuj (niski stopień) //ma stanąć, a jest w
|
||||
// drodze hamowania albo ma jechać
|
||||
AccDesired = fAccThreshold; // hamowanie tak, aby stanąć
|
||||
VelDesired = 0.0; // Min0R(VelDesired,VelNext);
|
||||
}
|
||||
else if (ActualProximityDist > fBrakeDist)
|
||||
if (ActualProximityDist > fBrakeDist)
|
||||
{ // jeśli ma stanąć, a mieści się w drodze hamowania
|
||||
if (vel < 10.0) // jeśli prędkość jest łatwa do zatrzymania
|
||||
{ // tu jest trochę problem, bo do punktu zatrzymania dobija
|
||||
@@ -4300,17 +4418,12 @@ bool TController::UpdateSituation(double dt)
|
||||
AccDesired = 0.0;
|
||||
}
|
||||
else // 25.92 (=3.6*3.6*2) - przelicznik z km/h na m/s
|
||||
if (vel <
|
||||
VelNext + fVelPlus) // jeśli niewielkie przekroczenie
|
||||
// AccDesired=0.0;
|
||||
AccDesired = Min0R(0.0, AccPreferred); // proteza trochę: to
|
||||
// niech nie hamuje,
|
||||
// chyba że coś z
|
||||
// przodu
|
||||
else
|
||||
AccDesired = -(vel * vel) /
|
||||
(25.92 * (ActualProximityDist +
|
||||
0.1)); //-fMinProximityDist));//-0.1;
|
||||
0.1-0.5*(fMinProximityDist+fMaxProximityDist))); //-fMinProximityDist));//-0.1;
|
||||
////mniejsze opóźnienie przy
|
||||
// małej różnicy
|
||||
ReactionTime = 0.1; // i orientuj się szybciej, jak masz stanąć
|
||||
@@ -4326,15 +4439,25 @@ bool TController::UpdateSituation(double dt)
|
||||
AccDesired = (VelNext * VelNext - vel * vel) /
|
||||
(25.92 * ActualProximityDist +
|
||||
0.1); // mniejsze opóźnienie przy małej różnicy
|
||||
if (ActualProximityDist < fMaxProximityDist)
|
||||
ReactionTime = 0.1; // i orientuj się szybciej, jeśli w
|
||||
// krytycznym przedziale
|
||||
if( ActualProximityDist < fMaxProximityDist ) {
|
||||
// i orientuj się szybciej, jeśli w krytycznym przedziale
|
||||
ReactionTime = 0.1;
|
||||
}
|
||||
}
|
||||
}
|
||||
else // przy dużej różnicy wysoki stopień (1,25 potrzebnego opoznienia)
|
||||
AccDesired = (VelNext * VelNext - vel * vel) /
|
||||
(20.73 * ActualProximityDist +
|
||||
0.1); // najpierw hamuje mocniej, potem zluzuje
|
||||
else { // przy dużej różnicy wysoki stopień (1,00 potrzebnego opoznienia)
|
||||
double dist = 0;// (VelNext * VelNext - (VelNext + 20) * (VelNext + 20)) / (25.92)*(-1 / fBrake_a0[0] - 1 / fAccThreshold);
|
||||
// ensure some minimal coasting speed, otherwise a vehicle entering this zone at very low speed will be crawling forever
|
||||
AccDesired =
|
||||
( VelNext * VelNext - vel * vel )
|
||||
/ ( 25.92
|
||||
* std::max(
|
||||
ActualProximityDist - VelNext - dist,
|
||||
std::min(
|
||||
ActualProximityDist,
|
||||
VelNext + dist ) )
|
||||
+ 0.1 ); // najpierw hamuje mocniej, potem zluzuje
|
||||
}
|
||||
if (AccPreferred < AccDesired)
|
||||
AccDesired = AccPreferred; //(1+abs(AccDesired))
|
||||
// ReactionTime=0.5*mvOccupied->BrakeDelay[2+2*mvOccupied->BrakeDelayFlag];
|
||||
@@ -4344,33 +4467,35 @@ bool TController::UpdateSituation(double dt)
|
||||
// //aby szybkosc hamowania zalezala od przyspieszenia i opoznienia
|
||||
// hamulcow
|
||||
}
|
||||
else
|
||||
{ // jest bliżej niż fMinProximityDist
|
||||
VelDesired =
|
||||
Min0R(VelDesired, VelNext); // utrzymuj predkosc bo juz blisko
|
||||
if (vel <
|
||||
VelNext + fVelPlus) // jeśli niewielkie przekroczenie, ale ma jechać
|
||||
AccDesired = Min0R(0.0, AccPreferred); // to olej (zacznij luzować)
|
||||
else {
|
||||
// jest bliżej niż fMinProximityDist
|
||||
VelDesired = std::min( VelDesired, VelNext ); // utrzymuj predkosc bo juz blisko
|
||||
if( vel < VelNext + fVelPlus ) {
|
||||
// jeśli niewielkie przekroczenie, ale ma jechać
|
||||
AccDesired = std::min( 0.0, AccPreferred ); // to olej (zacznij luzować)
|
||||
}
|
||||
ReactionTime = 0.1; // i orientuj się szybciej
|
||||
}
|
||||
}
|
||||
else // zatrzymany (vel==0.0)
|
||||
// if (iDrivigFlags&moveStopHere) //to nie dotyczy podczepiania
|
||||
// if ((VelNext>0.0)||(ActualProximityDist>fMaxProximityDist*1.2))
|
||||
if (VelNext > 0.0)
|
||||
AccDesired = AccPreferred; // można jechać
|
||||
else // jeśli daleko jechać nie można
|
||||
if (ActualProximityDist >
|
||||
fMaxProximityDist) // ale ma kawałek do sygnalizatora
|
||||
{ // if ((iDrivigFlags&moveStopHere)?false:AccPreferred>0)
|
||||
if (AccPreferred > 0)
|
||||
AccDesired = AccPreferred; // dociagnij do semafora;
|
||||
else
|
||||
VelDesired = 0.0; //,AccDesired=-fabs(fAccGravity); //stoj (hamuj z siłą
|
||||
// równą składowej stycznej grawitacji)
|
||||
else {
|
||||
// zatrzymany (vel==0.0)
|
||||
if( VelNext > 0.0 ) {
|
||||
// można jechać
|
||||
AccDesired = AccPreferred;
|
||||
}
|
||||
else {
|
||||
// jeśli daleko jechać nie można
|
||||
if( ActualProximityDist > fMaxProximityDist ) {
|
||||
// ale ma kawałek do sygnalizatora
|
||||
if( AccPreferred > 0 ) { AccDesired = AccPreferred; } // dociagnij do semafora;
|
||||
else { VelDesired = 0.0; } //stoj
|
||||
}
|
||||
else {
|
||||
// VelNext=0 i stoi bliżej niż fMaxProximityDist
|
||||
VelDesired = 0.0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
VelDesired = 0.0; // VelNext=0 i stoi bliżej niż fMaxProximityDist
|
||||
}
|
||||
else // gdy jedzie wolniej niż potrzeba, albo nie ma przeszkód na drodze
|
||||
AccDesired = (VelDesired != 0.0 ? AccPreferred : -0.01); // normalna jazda
|
||||
@@ -4378,26 +4503,29 @@ bool TController::UpdateSituation(double dt)
|
||||
if ((VelDesired >= 0.0) &&
|
||||
(vel > VelDesired)) // jesli jedzie za szybko do AKTUALNEGO
|
||||
if (VelDesired == 0.0) // jesli stoj, to hamuj, ale i tak juz za pozno :)
|
||||
AccDesired = -0.9; // hamuj solidnie
|
||||
AccDesired = std::min(AccDesired,-0.9); // hamuj solidnie
|
||||
else if ((vel < VelDesired + fVelPlus)) // o 5 km/h to olej
|
||||
{
|
||||
if ((AccDesired > 0.0))
|
||||
AccDesired = 0.0;
|
||||
}
|
||||
else
|
||||
AccDesired = fAccThreshold; // hamuj tak średnio
|
||||
AccDesired = std::min(AccDesired,fBrake_a0[0]); // hamuj tak średnio
|
||||
// koniec predkosci aktualnej
|
||||
if (fAccThreshold > -0.3) // bez sensu, ale dla towarowych korzystnie
|
||||
{ // Ra 2014-03: to nie uwzględnia odległości i zaczyna hamować, jak tylko zobaczy
|
||||
// W4
|
||||
if ((AccDesired > 0.0) &&
|
||||
(VelNext >= 0.0)) // wybieg bądź lekkie hamowanie, warunki byly zamienione
|
||||
if (vel > VelNext + 100.0) // lepiej zaczac hamowac
|
||||
AccDesired = fAccThreshold;
|
||||
else if (vel > VelNext + 70.0)
|
||||
AccDesired = 0.0; // nie spiesz się, bo będzie hamowanie
|
||||
// koniec wybiegu i hamowania
|
||||
}
|
||||
#ifdef DEBUGFAC
|
||||
if (fAccThreshold > -0.3) // bez sensu, ale dla towarowych korzystnie
|
||||
{ // Ra 2014-03: to nie uwzględnia odległości i zaczyna hamować, jak tylko zobaczy
|
||||
// W4
|
||||
if ((AccDesired > 0.0) &&
|
||||
(VelNext >= 0.0)) // wybieg bądź lekkie hamowanie, warunki byly zamienione
|
||||
if (vel > VelNext + 100.0) // lepiej zaczac hamowac
|
||||
AccDesired = fAccThreshold;
|
||||
else if (vel > VelNext + 70.0)
|
||||
AccDesired = 0.0; // nie spiesz się, bo będzie hamowanie
|
||||
// koniec wybiegu i hamowania
|
||||
}
|
||||
#endif // DEBUGFAC
|
||||
|
||||
if (AIControllFlag)
|
||||
{ // część wykonawcza tylko dla AI, dla człowieka jedynie napisy
|
||||
if (mvControlling->ConvOvldFlag ||
|
||||
@@ -4432,6 +4560,10 @@ bool TController::UpdateSituation(double dt)
|
||||
SetDriverPsyche();
|
||||
}
|
||||
}
|
||||
if (-AccDesired * BrakeAccFactor() < ((fReady > 0.4)||(VelNext>vel-40.0) ? fBrake_a0[0]*0.8 : -fAccThreshold))
|
||||
AccDesired = std::max(-0.06, AccDesired);
|
||||
else
|
||||
ReactionTime = 0.25; // i orientuj się szybciej, jeśli hamujesz
|
||||
if (mvOccupied->BrakeSystem == Pneumatic) // napełnianie uderzeniowe
|
||||
if (mvOccupied->BrakeHandle == FV4a)
|
||||
{
|
||||
@@ -4462,12 +4594,12 @@ bool TController::UpdateSituation(double dt)
|
||||
}
|
||||
// if
|
||||
// ((mvOccupied->BrakeCtrlPos<0)&&(mvOccupied->BrakePress<0.3))//{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)})
|
||||
if ((mvOccupied->BrakeCtrlPos < 0) &&
|
||||
(mvOccupied->EqvtPipePress >
|
||||
(fReady < 0.25 ?
|
||||
5.1 :
|
||||
5.2))) //{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)})
|
||||
mvOccupied->IncBrakeLevel();
|
||||
if ((mvOccupied->BrakeCtrlPos < 0) &&
|
||||
(mvOccupied->EqvtPipePress >
|
||||
(fReady < 0.25 ?
|
||||
5.1 :
|
||||
5.2))) //{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)})
|
||||
mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_RP));
|
||||
}
|
||||
#if LOGVELOCITY
|
||||
WriteLog("Dist=" + FloatToStrF(ActualProximityDist, ffFixed, 7, 1) +
|
||||
@@ -4487,47 +4619,68 @@ bool TController::UpdateSituation(double dt)
|
||||
AccDesired = fAccDesiredAv =
|
||||
0.2 * AccDesired +
|
||||
0.8 * fAccDesiredAv; // uśrednione, żeby ograniczyć migotanie
|
||||
if (VelDesired == 0.0)
|
||||
if (AccDesired >= -0.01)
|
||||
AccDesired = -0.01; // Ra 2F1J: jeszcze jedna prowizoryczna łatka
|
||||
if (AccDesired >= 0.0)
|
||||
if (iDrivigFlags & movePress)
|
||||
mvOccupied->BrakeReleaser(1); // wyluzuj lokomotywę - może być więcej!
|
||||
else if (OrderList[OrderPos] !=
|
||||
Disconnect) // przy odłączaniu nie zwalniamy tu hamulca
|
||||
if ((AccDesired > 0.0) ||
|
||||
(fAccGravity * fAccGravity <
|
||||
0.001)) // luzuj tylko na plaskim lub przy ruszaniu
|
||||
{
|
||||
while (DecBrake())
|
||||
; // jeśli przyspieszamy, to nie hamujemy
|
||||
if (mvOccupied->BrakePress > 0.4)
|
||||
mvOccupied->BrakeReleaser(
|
||||
1); // wyluzuj lokomotywę, to szybciej ruszymy
|
||||
if( VelDesired == 0.0 ) {
|
||||
// Ra 2F1J: jeszcze jedna prowizoryczna łatka
|
||||
if( AccDesired >= -0.01 ) {
|
||||
AccDesired = -0.01;
|
||||
}
|
||||
}
|
||||
if( AccDesired >= 0.0 ) {
|
||||
if( true == TestFlag( iDrivigFlags, movePress ) ) {
|
||||
// wyluzuj lokomotywę - może być więcej!
|
||||
mvOccupied->BrakeReleaser( 1 );
|
||||
}
|
||||
else if( OrderList[ OrderPos ] != Disconnect ) {
|
||||
// przy odłączaniu nie zwalniamy tu hamulca
|
||||
if( ( fAccGravity * fAccGravity < 0.001 ?
|
||||
true :
|
||||
AccDesired > 0.0 ) ) {
|
||||
// on slopes disengage the brakes only if you actually intend to accelerate
|
||||
while( true == DecBrake() ) { ; } // jeśli przyspieszamy, to nie hamujemy
|
||||
if( ( mvOccupied->BrakePress > 0.4 )
|
||||
&& ( mvOccupied->Hamulec->GetCRP() > 4.9 ) ) {
|
||||
// wyluzuj lokomotywę, to szybciej ruszymy
|
||||
mvOccupied->BrakeReleaser( 1 );
|
||||
}
|
||||
else {
|
||||
if( mvOccupied->PipePress >= 3.0 ) {
|
||||
// TODO: combine all releaser handling in single decision tree instead of having bits all over the place
|
||||
mvOccupied->BrakeReleaser( 0 );
|
||||
}
|
||||
}
|
||||
}
|
||||
// margines dla prędkości jest doliczany tylko jeśli oczekiwana prędkość jest
|
||||
// większa od 5km/h
|
||||
if (!(iDrivigFlags & movePress))
|
||||
{ // jeśli nie dociskanie
|
||||
if (AccDesired < -0.1)
|
||||
while (DecSpeed())
|
||||
; // jeśli hamujemy, to nie przyspieszamy
|
||||
else if (((fAccGravity < -0.01) ? AccDesired < 0.0 :
|
||||
AbsAccS > AccDesired) ||
|
||||
(vel > VelDesired)) // jak za bardzo przyspiesza albo prędkość
|
||||
// przekroczona
|
||||
}
|
||||
}
|
||||
// margines dla prędkości jest doliczany tylko jeśli oczekiwana prędkość jest większa od 5km/h
|
||||
if( false == TestFlag( iDrivigFlags, movePress ) ) {
|
||||
// jeśli nie dociskanie
|
||||
if( AccDesired < -0.1 ) {
|
||||
while( true == DecSpeed() ) { ; } // jeśli hamujemy, to nie przyspieszamy
|
||||
}
|
||||
else if( ( vel > VelDesired )
|
||||
|| ( fAccGravity < -0.01 ?
|
||||
AccDesired < 0.0 :
|
||||
AbsAccS > AccDesired ) ) {
|
||||
// jak za bardzo przyspiesza albo prędkość przekroczona
|
||||
DecSpeed(); // pojedyncze cofnięcie pozycji, bo na zero to przesada
|
||||
}
|
||||
}
|
||||
// yB: usunięte różne dziwne warunki, oddzielamy część zadającą od wykonawczej
|
||||
// zwiekszanie predkosci
|
||||
// Ra 2F1H: jest konflikt histerezy pomiędzy nastawioną pozycją a uzyskiwanym
|
||||
// przyspieszeniem - utrzymanie pozycji powoduje przekroczenie przyspieszenia
|
||||
if (AbsAccS <
|
||||
AccDesired) // jeśli przyspieszenie pojazdu jest mniejsze niż żądane oraz
|
||||
if (vel < VelDesired - fVelMinus) // jeśli prędkość w kierunku czoła jest
|
||||
// mniejsza od dozwolonej o margines
|
||||
if ((ActualProximityDist > fMaxProximityDist) ? true : (vel < VelNext))
|
||||
IncSpeed(); // to można przyspieszyć
|
||||
if( AbsAccS < AccDesired ) {
|
||||
// jeśli przyspieszenie pojazdu jest mniejsze niż żądane oraz
|
||||
if( vel < VelDesired - fVelMinus ) {
|
||||
// jeśli prędkość w kierunku czoła jest mniejsza od dozwolonej o margines
|
||||
if( ( ActualProximityDist > fMaxProximityDist ?
|
||||
true :
|
||||
vel < VelNext ) ) {
|
||||
// to można przyspieszyć
|
||||
IncSpeed();
|
||||
}
|
||||
}
|
||||
}
|
||||
// if ((AbsAccS<AccDesired)&&(vel<VelDesired))
|
||||
// if (!MaxVelFlag) //Ra: to nie jest używane
|
||||
// if (!IncSpeed()) //Ra: to tutaj jest bez sensu, bo nie dociągnie do
|
||||
@@ -4583,37 +4736,41 @@ bool TController::UpdateSituation(double dt)
|
||||
if (((fAccGravity < -0.05) && (vel < 0)) ||
|
||||
((AccDesired < fAccGravity - 0.1) &&
|
||||
(AbsAccS >
|
||||
AccDesired + 0.05))) // u góry ustawia się hamowanie na fAccThreshold
|
||||
AccDesired + fBrake_a1[0]))) // u góry ustawia się hamowanie na fAccThreshold
|
||||
// if not MinVelFlag)
|
||||
if (fBrakeTime < 0 ? true : (AccDesired < fAccGravity - 0.3) ||
|
||||
(mvOccupied->BrakeCtrlPos <= 0))
|
||||
if (!IncBrake()) // jeśli upłynął czas reakcji hamulca, chyba że
|
||||
// nagłe albo luzował
|
||||
if( false == IncBrake() ) {
|
||||
// jeśli upłynął czas reakcji hamulca, chyba że nagłe albo luzował
|
||||
MinVelFlag = true;
|
||||
else
|
||||
{
|
||||
}
|
||||
else {
|
||||
MinVelFlag = false;
|
||||
fBrakeTime =
|
||||
3 +
|
||||
0.5 *
|
||||
(mvOccupied
|
||||
->BrakeDelay[2 + 2 * mvOccupied->BrakeDelayFlag] -
|
||||
3);
|
||||
// Ra: ten czas należy zmniejszyć, jeśli czas dojazdu do
|
||||
// zatrzymania jest mniejszy
|
||||
3.0
|
||||
+ 0.5 * ( (
|
||||
mvOccupied->BrakeDelayFlag > bdelay_G ?
|
||||
mvOccupied->BrakeDelay[ 1 ] :
|
||||
mvOccupied->BrakeDelay[ 3 ] )
|
||||
- 3.0 );
|
||||
// Ra: ten czas należy zmniejszyć, jeśli czas dojazdu do zatrzymania jest mniejszy
|
||||
fBrakeTime *= 0.5; // Ra: tymczasowo, bo przeżyna S1
|
||||
}
|
||||
if ((AccDesired < fAccGravity - 0.05) && (AbsAccS < AccDesired - 0.2))
|
||||
if ((AccDesired < fAccGravity - 0.05) && (AbsAccS < AccDesired - fBrake_a1[0]*0.51))
|
||||
// if ((AccDesired<0.0)&&(AbsAccS<AccDesired-0.1)) //ST44 nie hamuje na
|
||||
// czas, 2-4km/h po minięciu tarczy
|
||||
// if (fBrakeTime<0)
|
||||
{ // jak hamuje, to nie tykaj kranu za często
|
||||
// yB: luzuje hamulec dopiero przy różnicy opóźnień rzędu 0.2
|
||||
if (OrderList[OrderPos] !=
|
||||
Disconnect) // przy odłączaniu nie zwalniamy tu hamulca
|
||||
if( OrderList[ OrderPos ] != Disconnect ) {
|
||||
// przy odłączaniu nie zwalniamy tu hamulca
|
||||
DecBrake(); // tutaj zmniejszało o 1 przy odczepianiu
|
||||
fBrakeTime =
|
||||
(mvOccupied->BrakeDelay[1 + 2 * mvOccupied->BrakeDelayFlag]) / 3.0;
|
||||
}
|
||||
fBrakeTime = (
|
||||
mvOccupied->BrakeDelayFlag > bdelay_G ?
|
||||
mvOccupied->BrakeDelay[ 0 ] :
|
||||
mvOccupied->BrakeDelay[ 2 ] )
|
||||
/ 3.0;
|
||||
fBrakeTime *= 0.5; // Ra: tymczasowo, bo przeżyna S1
|
||||
}
|
||||
}
|
||||
@@ -4646,6 +4803,7 @@ bool TController::UpdateSituation(double dt)
|
||||
mvControlling->DecMainCtrl(1);
|
||||
if (mvOccupied->BrakeCtrlPos ==
|
||||
mvOccupied->BrakeCtrlPosNo) // jeśli ostatnia pozycja hamowania
|
||||
//yB: ten warunek wyżej nie ma sensu
|
||||
mvOccupied->DecBrakeLevel(); // to cofnij hamulec
|
||||
else
|
||||
mvControlling->AntiSlippingButton();
|
||||
@@ -4677,11 +4835,13 @@ bool TController::UpdateSituation(double dt)
|
||||
}
|
||||
if (AIControllFlag)
|
||||
{ // odhamowywanie składu po zatrzymaniu i zabezpieczanie lokomotywy
|
||||
if ((OrderList[OrderPos] & (Disconnect | Connect)) ==
|
||||
0) // przy (p)odłączaniu nie zwalniamy tu hamulca
|
||||
if ((mvOccupied->V == 0.0) && ((VelDesired == 0.0) || (AccDesired == 0.0)))
|
||||
if ((mvOccupied->BrakeCtrlPos < 1) || !mvOccupied->DecBrakeLevel())
|
||||
mvOccupied->IncLocalBrakeLevel(1); // dodatkowy na pozycję 1
|
||||
if ((OrderList[OrderPos] & (Disconnect | Connect)) ==
|
||||
0) // przy (p)odłączaniu nie zwalniamy tu hamulca
|
||||
if ((mvOccupied->V == 0.0) && ((VelDesired == 0.0) || (AccDesired == 0.0)))
|
||||
if (mvOccupied->BrakeCtrlPos == mvOccupied->Handle->GetPos(bh_RP))
|
||||
mvOccupied->IncLocalBrakeLevel(1); // dodatkowy na pozycję 1
|
||||
else
|
||||
mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_RP));
|
||||
}
|
||||
break; // rzeczy robione przy jezdzie
|
||||
} // switch (OrderList[OrderPos])
|
||||
@@ -4697,7 +4857,6 @@ bool TController::UpdateSituation(double dt)
|
||||
iStationStart = TrainParams->StationIndex; // zaktualizować wyświetlanie rozkładu
|
||||
fLastStopExpDist = -1.0f; // usunąć licznik
|
||||
}
|
||||
|
||||
if (AIControllFlag)
|
||||
{
|
||||
if (fWarningDuration > 0.0) // jeśli pozostało coś do wytrąbienia
|
||||
|
||||
Reference in New Issue
Block a user