replaced the list of dynamic objects on tracks with stl-based version

Driver.cpp

@@ -241,6 +241,7 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len)
                     fVelNext = 30.0; // uzależnić prędkość od promienia; albo niech będzie
                 // ograniczona w skrzyżowaniu (velocity z ujemną wartością)
                 if ((iFlags & spElapsed) == 0) // jeśli nie wjechał
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
 					if (trTrack->iNumDynamics > 0) // a skrzyżowanie zawiera pojazd
                     {
                         if (Global::iWriteLogEnabled & 8)
@@ -248,6 +249,14 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len)
                         fVelNext =
 							0.0; // to zabronić wjazdu (chyba że ten z przodu też jedzie prosto)
                     }
+#else
+                    if( false == trTrack->Dynamics.empty() ) {
+                        if( Global::iWriteLogEnabled & 8 ) {
+                            WriteLog( "Tor " + trTrack->NameGet() + " zajety przed pojazdem. Num=" + std::to_string( trTrack->Dynamics.size() ) + "Dist= " + std::to_string( fDist ) );
+                            fVelNext = 0.0; // to zabronić wjazdu (chyba że ten z przodu też jedzie prosto)
+                        }
+                    }
+#endif
             }
             if (iFlags & spSwitch) // jeśli odcinek zmienny
             {
@@ -262,6 +271,7 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len)
                     // na Mydelniczce potrafi skanować na wprost mimo pojechania na bok
                 }
                 // poniższe nie dotyczy trybu łączenia?
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
 				if ((iFlags & spElapsed) ? false :
                         trTrack->iNumDynamics >
 					0) // jeśli jeszcze nie wjechano na tor, a coś na nim jest
@@ -273,6 +283,16 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len)
 				// else if (fVelNext==0.0) //jeśli została wyzerowana
 				// fVelNext=trTrack->VelocityGet(); //odczyt prędkości
                 }
+#else
+                if( ( ( iFlags & spElapsed ) == 0 )
+                 && ( false == trTrack->Dynamics.empty() ) ) {
+                    // jeśli jeszcze nie wjechano na tor, a coś na nim jest
+                    if( Global::iWriteLogEnabled & 8 ) {
+                        WriteLog( "Rozjazd " + trTrack->NameGet() + " zajety przed pojazdem. Num=" + std::to_string( trTrack->Dynamics.size() ) + "Dist= " + std::to_string( fDist ) );
+                    }
+                    fVelNext = 0.0; // to niech stanie w zwiększonej odległości
+                }
+#endif
             }
         }
     }
@@ -4927,6 +4947,7 @@ double TController::Distance(vector3 &p1,vector3 &n,vector3 &p2)
 
 bool TController::BackwardTrackBusy(TTrack *Track)
 { // najpierw sprawdzamy, czy na danym torze są pojazdy z innego składu
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if (Track->iNumDynamics)
     { // jeśli tylko z własnego składu, to tor jest wolny
         for (int i = 0; i < Track->iNumDynamics; ++i)
@@ -4934,6 +4955,17 @@ bool TController::BackwardTrackBusy(TTrack *Track)
                 return true; // to tor jest zajęty i skanowanie nie obowiązuje
     }
     return false; // wolny
+#else
+    if( false == Track->Dynamics.empty() ) {
+        for( auto dynamic : Track->Dynamics ) {
+            if( dynamic->ctOwner != this ) {
+                // jeśli jest jakiś cudzy to tor jest zajęty i skanowanie nie obowiązuje
+                return true;
+            }
+        }
+    }
+    return false; // wolny
+#endif
 };
 
 TEvent * TController::CheckTrackEventBackward(double fDirection, TTrack *Track)

DynObj.cpp

@@ -965,6 +965,7 @@ TDynamicObject * TDynamicObject::ABuFindNearestObject(TTrack *Track,
 
     // Uwaga! Jesli CouplNr==-2 to szukamy njblizszego obiektu, a nie sprzegu!!!
 
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if ((Track->iNumDynamics) > 0)
     { // o ile w ogóle jest co przeglądać na tym torze
         // vector3 poz; //pozycja pojazdu XYZ w scenerii
@@ -1013,7 +1014,33 @@ TDynamicObject * TDynamicObject::ABuFindNearestObject(TTrack *Track,
         }
         return NULL;
     }
-    return NULL;
+#else
+    for( auto dynamic : Track->Dynamics ) {
+
+        if( CouplNr == -2 ) {
+            // wektor [kamera-obiekt] - poszukiwanie obiektu
+            if( LengthSquared3( Global::GetCameraPosition() - dynamic->vPosition ) < 100.0 ) {
+                // 10 metrów
+                return dynamic;
+            }
+        }
+        else {
+            // jeśli (CouplNr) inne niz -2, szukamy sprzęgu
+            if( LengthSquared3( Global::GetCameraPosition() - dynamic->vCoulpler[ 0 ] ) < 25.0 ) {
+                // 5 metrów
+                CouplNr = 0;
+                return dynamic;
+            }
+            if( LengthSquared3( Global::GetCameraPosition() - dynamic->vCoulpler[ 1 ] ) < 25.0 ) {
+                // 5 metrów
+                CouplNr = 1;
+                return dynamic;
+            }
+        }
+    }
+    // empty track or nothing found
+    return nullptr;
+#endif
 }
 
 TDynamicObject * TDynamicObject::ABuScanNearestObject(TTrack *Track, double ScanDir,
@@ -1135,14 +1162,22 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
 
     // WY: wskaznik do znalezionego obiektu.
     //    CouplFound - nr sprzegu znalezionego obiektu
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if (Track->iNumDynamics > 0)
+#else
+    if( false == Track->Dynamics.empty() )
+#endif
     { // sens szukania na tym torze jest tylko, gdy są na nim pojazdy
         double ObjTranslation; // pozycja najblizszego obiektu na torze
         double MyTranslation; // pozycja szukającego na torze
         double MinDist = Track->Length(); // najmniejsza znaleziona odleglość
         // (zaczynamy od długości toru)
         double TestDist; // robocza odległość od kolejnych pojazdów na danym odcinku
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
         int iMinDist = -1; // indeks wykrytego obiektu
+#else
+        TDynamicObject *collider = nullptr;
+#endif
         // if (Track->iNumDynamics>1)
         // iMinDist+=0; //tymczasowo pułapka
         if (MyTrack == Track) // gdy szukanie na tym samym torze
@@ -1154,7 +1189,8 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
             MyTranslation = MinDist; // szukanie w kierunku Point1 (do zera) - jesteśmy w Point2
         if (ScanDir >= 0)
         { // jeśli szukanie w kierunku Point2
-            for (int i = 0; i < Track->iNumDynamics; i++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+            for( int i = 0; i < Track->iNumDynamics; i++ )
             { // pętla po pojazdach
                 if (Track->Dynamics[i] != this) // szukający się nie liczy
                 {
@@ -1200,10 +1236,56 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
                     }
                 }
             }
+#else
+            for( auto dynamic : Track->Dynamics ) {
+                // pętla po pojazdach
+                if( dynamic == this ) {
+                    // szukający się nie liczy
+                    continue;
+                }
+                
+                TestDist = ( dynamic->RaTranslationGet() ) - MyTranslation; // odległogłość tamtego od szukającego
+                if( ( TestDist > 0 ) && ( TestDist <= MinDist ) ) { // gdy jest po właściwej stronie i bliżej
+                    // niż jakiś wcześniejszy
+                    CouplFound = ( dynamic->RaDirectionGet() > 0 ) ? 1 : 0; // to, bo (ScanDir>=0)
+                    if( Track->iCategoryFlag & 254 ) {
+                        // trajektoria innego typu niż tor kolejowy
+                        // dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija
+                        // Ra: mijanie samochodów wcale nie jest proste
+                        // Przesuniecie wzgledne pojazdow. Wyznaczane, zeby sprawdzic,
+                        // czy pojazdy faktycznie sie zderzaja (moga byc przesuniete
+                        // w/m siebie tak, ze nie zachodza na siebie i wtedy sie mijaja).
+                        double RelOffsetH; // wzajemna odległość poprzeczna
+                        if( CouplFound ) {
+                            // my na tym torze byśmy byli w kierunku Point2
+                            // dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć
+                            RelOffsetH = ( MoverParameters->OffsetTrackH - dynamic->MoverParameters->OffsetTrackH );
+                        }
+                        else {
+                            // dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się
+                            RelOffsetH = ( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH );
+                        }
+                        if( RelOffsetH < 0 ) {
+                            RelOffsetH = -RelOffsetH;
+                        }
+                        if( RelOffsetH + RelOffsetH > MoverParameters->Dim.W + dynamic->MoverParameters->Dim.W ) {
+                            // odległość większa od połowy sumy szerokości - kolizji nie będzie
+                            continue;
+                        }
+                        // jeśli zahaczenie jest niewielkie, a jest miejsce na poboczu, to
+                        // zjechać na pobocze
+                    }
+                    collider = dynamic; // potencjalna kolizja
+                    MinDist = TestDist; // odleglość pomiędzy aktywnymi osiami pojazdów
+                }
+                
+            }
+#endif
         }
         else //(ScanDir<0)
         {
-            for (int i = 0; i < Track->iNumDynamics; i++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+            for( int i = 0; i < Track->iNumDynamics; i++ )
             {
                 if (Track->Dynamics[i] != this)
                 {
@@ -1247,15 +1329,54 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
                     }
                 }
             }
+#else
+            for( auto dynamic : Track->Dynamics ) {
+
+                if( dynamic == this ) { continue; }
+
+                TestDist = MyTranslation - ( dynamic->RaTranslationGet() ); //???-przesunięcie wózka względem Point1 toru
+                if( ( TestDist > 0 ) && ( TestDist < MinDist ) ) {
+                    CouplFound = ( dynamic->RaDirectionGet() > 0 ) ? 0 : 1; // odwrotnie, bo (ScanDir<0)
+                    if( Track->iCategoryFlag & 254 ) // trajektoria innego typu niż tor kolejowy
+                    { // dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija
+                        // Ra: mijanie samochodów wcale nie jest proste
+                        // Przesunięcie względne pojazdów. Wyznaczane, żeby sprawdzić,
+                        // czy pojazdy faktycznie się zderzają (mogą być przesunięte
+                        // w/m siebie tak, że nie zachodzą na siebie i wtedy sie mijają).
+                        double RelOffsetH; // wzajemna odległość poprzeczna
+                        if( CouplFound ) {
+                            // my na tym torze byśmy byli w kierunku Point1
+                            // dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć
+                            RelOffsetH = ( MoverParameters->OffsetTrackH - dynamic->MoverParameters->OffsetTrackH );
+                        }
+                        else {
+                            // dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się
+                            RelOffsetH = ( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH );
+                        }
+                        if( RelOffsetH < 0 ) {
+                            RelOffsetH = -RelOffsetH;
+                        }
+                        if( RelOffsetH + RelOffsetH > MoverParameters->Dim.W + dynamic->MoverParameters->Dim.W ) {
+                            // odległość większa od połowy sumy szerokości - kolizji nie będzie
+                            continue;
+                        }
+                    }
+                    collider = dynamic; // potencjalna kolizja
+                    MinDist = TestDist; // odleglość pomiędzy aktywnymi osiami pojazdów
+                }
+            }
+#endif
         }
-        dist += MinDist; // doliczenie odległości przeszkody albo długości odcinka
-        // do przeskanowanej
-        // odległości
-        return (iMinDist >= 0) ? Track->Dynamics[iMinDist] : NULL;
+        dist += MinDist; // doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+        return ( iMinDist >= 0 ) ? Track->Dynamics[ iMinDist ] : NULL;
+#else
+        return collider;
+#endif
     }
     dist += Track->Length(); // doliczenie długości odcinka do przeskanowanej
     // odległości
-    return NULL; // nie ma pojazdów na torze, to jest NULL
+    return nullptr; // nie ma pojazdów na torze, to jest NULL
 }
 
 int TDynamicObject::DettachStatus(int dir)

Ground.cpp

@@ -3814,10 +3814,18 @@ bool TGround::AddToQuery(TEvent *Event, TDynamicObject *Node)
                     if (Event->Params[6].asTrack)
                     { // McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla
                         // wszystkich 'dynamic' na danym torze
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
                         for (int i = 0; i < Event->Params[6].asTrack->iNumDynamics; ++i)
                             Event->Params[5].asMemCell->PutCommand(
                                 Event->Params[6].asTrack->Dynamics[i]->Mechanik,
                                 &Event->Params[4].nGroundNode->pCenter);
+#else
+                        for( auto dynamic : Event->Params[ 6 ].asTrack->Dynamics ) {
+                            Event->Params[ 5 ].asMemCell->PutCommand(
+                                dynamic->Mechanik,
+                                &Event->Params[ 4 ].nGroundNode->pCenter );
+                        }
+#endif
                         //if (DebugModeFlag)
                             WriteLog("EVENT EXECUTED: AddValues & Track command - " +
                                      std::string(Event->Params[0].asText) + " " +
@@ -4006,10 +4014,18 @@ bool TGround::CheckQuery()
                     if (tmpEvent->Params[6].asTrack)
                     { // McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla
                         // wszystkich 'dynamic' na danym torze
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
                         for (int i = 0; i < tmpEvent->Params[6].asTrack->iNumDynamics; ++i)
                             tmpEvent->Params[5].asMemCell->PutCommand(
                                 tmpEvent->Params[6].asTrack->Dynamics[i]->Mechanik,
                                 &tmpEvent->Params[4].nGroundNode->pCenter);
+#else
+                        for( auto dynamic : tmpEvent->Params[ 6 ].asTrack->Dynamics ) {
+                            tmpEvent->Params[ 5 ].asMemCell->PutCommand(
+                                dynamic->Mechanik,
+                                &tmpEvent->Params[ 4 ].nGroundNode->pCenter );
+                        }
+#endif
                         //if (DebugModeFlag)
                             WriteLog("Type: UpdateValues & Track command - " +
                                      std::string(tmpEvent->Params[0].asText) + " " +
@@ -5038,7 +5054,8 @@ TDynamicObject * TGround::DynamicNearest(vector3 pPosition, double distance, boo
             if ((tmp = FastGetSubRect(i, j)) != NULL)
                 for (node = tmp->nRootNode; node; node = node->nNext2) // następny z sektora
                     if (node->iType == TP_TRACK) // Ra: przebudować na użycie tabeli torów?
-                        for (k = 0; k < node->pTrack->iNumDynamics; k++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+                        for( k = 0; k < node->pTrack->iNumDynamics; k++ )
                             if (mech ? (node->pTrack->Dynamics[k]->Mechanik != NULL) :
                                        true) // czy ma mieć obsadę
                                 if ((sqd = SquareMagnitude(
@@ -5048,6 +5065,17 @@ TDynamicObject * TGround::DynamicNearest(vector3 pPosition, double distance, boo
                                     sqm = sqd; // nowa odległość
                                     dyn = node->pTrack->Dynamics[k]; // nowy lider
                                 }
+#else
+                        for( auto dynamic : node->pTrack->Dynamics ) {
+                            if( mech ? ( dynamic->Mechanik != nullptr ) : true ) {
+                                // czy ma mieć obsadę
+                                if( ( sqd = SquareMagnitude( dynamic->GetPosition() - pPosition ) ) < sqm ) {
+                                    sqm = sqd; // nowa odległość
+                                    dyn = dynamic; // nowy lider
+                                }
+                            }
+                        }
+#endif
     return dyn;
 };
 TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, bool mech)
@@ -5064,7 +5092,8 @@ TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, boo
             if ((tmp = FastGetSubRect(i, j)) != NULL)
                 for (node = tmp->nRootNode; node; node = node->nNext2) // następny z sektora
                     if (node->iType == TP_TRACK) // Ra: przebudować na użycie tabeli torów?
-                        for (k = 0; k < node->pTrack->iNumDynamics; k++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+                        for( k = 0; k < node->pTrack->iNumDynamics; k++ )
                             if (mech ? (node->pTrack->Dynamics[k]->Mechanik != NULL) :
                                        true) // czy ma mieć obsadę
                             {
@@ -5083,6 +5112,21 @@ TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, boo
                                     dyn = node->pTrack->Dynamics[k]; // nowy lider
                                 }
                             }
+#else
+                        for( auto dynamic : node->pTrack->Dynamics ) {
+                            if( mech ? ( dynamic->Mechanik != nullptr ) : true ) {
+                                // czy ma mieć obsadę
+                                if( ( sqd = SquareMagnitude( dynamic->HeadPosition() - pPosition ) ) < sqm ) {
+                                    sqm = sqd; // nowa odległość
+                                    dyn = dynamic; // nowy lider
+                                }
+                                if( ( sqd = SquareMagnitude( dynamic->RearPosition() - pPosition ) ) < sqm ) {
+                                    sqm = sqd; // nowa odległość
+                                    dyn = dynamic; // nowy lider
+                                }
+                            }
+                        }
+#endif
     return dyn;
 };
 //---------------------------------------------------------------------------
@@ -5221,7 +5265,11 @@ void TGround::TrackBusyList()
     TTrack *Track;
     for (Current = nRootOfType[TP_TRACK]; Current; Current = Current->nNext)
         if (!Current->asName.empty()) // musi być nazwa
-            if (Current->pTrack->iNumDynamics) // osi to chyba nie ma jak policzyć
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+            if( Current->pTrack->iNumDynamics ) // osi to chyba nie ma jak policzyć
+#else
+            if( false == Current->pTrack->Dynamics.empty() )
+#endif
                 WyslijString(Current->asName, 8); // zajęty
 };
 //---------------------------------------------------------------------------

McZapkie/MOVER.h

@@ -672,7 +672,7 @@ public:
 							/*nastawniki:*/
 	int MainCtrlPosNo = 0;     /*ilosc pozycji nastawnika*/
 	int ScndCtrlPosNo = 0;
-	int LightsPosNo = 1;
+	int LightsPosNo = 0; // NOTE: values higher than 0 seem to break the current code for light switches
     int LightsDefPos = 0;
 	bool LightsWrap = false;
 	int Lights[2][17]; // pozycje świateł, przód - tył, 1 .. 16

McZapkie/Mover.cpp

@@ -298,7 +298,7 @@ Name( NameInit )
     }
 
     for (int b = 0; b < 2; ++b)
-        for (int k = 1; k <= 17; ++k)
+        for (int k = 0; k < 17; ++k)
             Lights[b][k] = 0;
 
     for (int b = -1; b <= MainBrakeMaxPos; ++b)

Track.cpp

@@ -145,7 +145,9 @@ void TIsolated::Modify(int i, TDynamicObject *o)
 TTrack::TTrack(TGroundNode *g) :
     pMyNode( g ) // Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode
 {
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     ::SecureZeroMemory( Dynamics, sizeof( Dynamics ) );
+#endif
     fRadiusTable[ 0 ] = 0.0;
     fRadiusTable[ 1 ] = 0.0;
     nFouling[ 0 ] = nullptr;
@@ -997,6 +999,7 @@ bool TTrack::AddDynamicObject(TDynamicObject *Dynamic)
         Dynamic->MyTrack = NULL; // trzeba by to uzależnić od kierunku ruchu...
         return true;
     }
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if (Global::iMultiplayer) // jeśli multiplayer
         if (!iNumDynamics) // pierwszy zajmujący
             if (pMyNode->asName != "none")
@@ -1016,6 +1019,25 @@ bool TTrack::AddDynamicObject(TDynamicObject *Dynamic)
         Error("Too many dynamics on track " + pMyNode->asName);
         return false;
     }
+#else
+    if( Global::iMultiplayer ) {
+        // jeśli multiplayer
+        if( true == Dynamics.empty() ) {
+            // pierwszy zajmujący
+            if( pMyNode->asName != "none" ) {
+                // przekazanie informacji o zajętości toru
+                Global::pGround->WyslijString( pMyNode->asName, 8 );
+            }
+        }
+    }
+    Dynamics.emplace_back( Dynamic );
+    Dynamic->MyTrack = this; // ABu: na ktorym torze jesteśmy
+    if( Dynamic->iOverheadMask ) {
+        // jeśli ma pantografy
+        Dynamic->OverheadTrack( fOverhead ); // przekazanie informacji o jeździe bezprądowej na tym odcinku toru
+    }
+    return true;
+#endif
 };
 
 void TTrack::MoveMe(vector3 pPosition)
@@ -1833,14 +1855,24 @@ void TTrack::Render()
 
 bool TTrack::CheckDynamicObject(TDynamicObject *Dynamic)
 { // sprawdzenie, czy pojazd jest przypisany do toru
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     for (int i = 0; i < iNumDynamics; i++)
         if (Dynamic == Dynamics[i])
             return true;
     return false;
+#else
+    for( auto dynamic : Dynamics ) {
+        if( dynamic == Dynamic ) {
+            return true;
+        }
+    }
+    return false;
+#endif
 };
 
 bool TTrack::RemoveDynamicObject(TDynamicObject *Dynamic)
 { // usunięcie pojazdu z listy przypisanych do toru
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     for (int i = 0; i < iNumDynamics; i++)
     { // sprawdzanie wszystkich po kolei
         if (Dynamic == Dynamics[i])
@@ -1858,6 +1890,41 @@ bool TTrack::RemoveDynamicObject(TDynamicObject *Dynamic)
     }
     Error("Cannot remove dynamic from track");
     return false;
+#else
+    bool result = false;
+    if( *Dynamics.begin() == Dynamic ) {
+        // most likely the object getting removed it's at the front...
+        Dynamics.pop_front();
+        result = true;
+    }
+    else if( *( --Dynamics.end() ) == Dynamic ) {
+        // ...or the back of the queue...
+        Dynamics.pop_back();
+        result = true;
+    }
+    else {
+        // ... if these fail, check all objects one by one, just in case
+        // TODO: check if this is ever needed, remove if it isn't.
+        for( auto idx = Dynamics.begin(); idx != Dynamics.end(); ++idx ) {
+            if( *idx == Dynamic ) {
+                Dynamics.erase( idx );
+                result = true;
+            }
+        }
+    }
+    if( Global::iMultiplayer ) {
+        // jeśli multiplayer
+        if( true == Dynamics.empty() ) {
+            // jeśli już nie ma żadnego
+            if( pMyNode->asName != "none" ) {
+                // przekazanie informacji o zwolnieniu toru
+                Global::pGround->WyslijString( pMyNode->asName, 9 ); 
+            }
+        }
+    }
+    
+    return result;
+#endif
 }
 
 bool TTrack::InMovement()
@@ -2551,28 +2618,48 @@ void TTrack::EnvironmentReset()
 
 void TTrack::RenderDyn()
 { // renderowanie nieprzezroczystych fragmentów pojazdów
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if (!iNumDynamics)
         return; // po co kombinować, jeśli nie ma pojazdów?
     // EnvironmentSet(); //Ra: pojazdy sobie same teraz liczą cienie
     for (int i = 0; i < iNumDynamics; i++)
         Dynamics[i]->Render(); // sam sprawdza, czy VBO; zmienia kontekst VBO!
     // EnvironmentReset();
+#else
+    for( auto dynamic : Dynamics ) {
+        // sam sprawdza, czy VBO; zmienia kontekst VBO!
+        dynamic->Render();
+    }
+#endif
 };
 
 void TTrack::RenderDynAlpha()
 { // renderowanie przezroczystych fragmentów pojazdów
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     if (!iNumDynamics)
         return; // po co kombinować, jeśli nie ma pojazdów?
     // EnvironmentSet(); //Ra: pojazdy sobie same teraz liczą cienie
     for (int i = 0; i < iNumDynamics; i++)
         Dynamics[i]->RenderAlpha(); // sam sprawdza, czy VBO; zmienia kontekst VBO!
     // EnvironmentReset();
+#else
+    for( auto dynamic : Dynamics ) {
+        // sam sprawdza, czy VBO; zmienia kontekst VBO!
+        dynamic->RenderAlpha();
+    }
+#endif
 };
 
 void TTrack::RenderDynSounds()
 { // odtwarzanie dźwięków pojazdów jest niezależne od ich wyświetlania
-    for (int i = 0; i < iNumDynamics; i++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+    for( int i = 0; i < iNumDynamics; i++ )
         Dynamics[i]->RenderSounds();
+#else
+    for( auto dynamic : Dynamics ) {
+        dynamic->RenderSounds();
+    }
+#endif
 };
 //---------------------------------------------------------------------------
 bool TTrack::SetConnections(int i)
@@ -2906,8 +2993,15 @@ TTrack * TTrack::RaAnimate()
                         SwitchExtension->vTrans; // SwitchExtension->Segments[0]->FastGetPoint(0.5);
                     Segment->Init(middle + vector3(sina, 0.0, cosa),
                                   middle - vector3(sina, 0.0, cosa), 5.0); // nowy odcinek
-                    for (int i = 0; i < iNumDynamics; i++)
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
+                    for( int i = 0; i < iNumDynamics; i++ )
                         Dynamics[i]->Move(0.000001); // minimalny ruch, aby przeliczyć pozycję i
+#else
+                    for( auto dynamic : Dynamics ) {
+                        // minimalny ruch, aby przeliczyć pozycję
+                        dynamic->Move( 0.000001 );
+                    }
+#endif
                     // kąty
                     if (Global::bUseVBO)
                     { // dla OpenGL 1.4 odświeży się cały sektor, w późniejszych poprawiamy fragment
@@ -2939,8 +3033,15 @@ TTrack * TTrack::RaAnimate()
 //---------------------------------------------------------------------------
 void TTrack::RadioStop()
 { // przekazanie pojazdom rozkazu zatrzymania
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     for (int i = 0; i < iNumDynamics; i++)
         Dynamics[i]->RadioStop();
+#else
+    for( auto dynamic : Dynamics ) {
+        dynamic->RadioStop();
+    }
+#endif
+
 };
 
 double TTrack::WidthTotal()

Track.h

@@ -94,7 +94,9 @@ class TSwitchExtension
   private:
 };
 
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
 const int iMaxNumDynamics = 40; // McZapkie-100303
+#endif
 
 class TIsolated
 { // obiekt zbierający zajętości z kilku odcinków
@@ -149,8 +151,13 @@ class TTrack : public Resource
     TGroundNode *
         pMyNode = nullptr; // Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode
   public:
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
     int iNumDynamics = 0;
     TDynamicObject *Dynamics[iMaxNumDynamics];
+#else
+    typedef std::deque<TDynamicObject *> dynamics_sequence;
+    dynamics_sequence Dynamics;
+#endif
     int iEvents = 0; // Ra: flaga informująca o obecności eventów
     TEvent *evEventall0 = nullptr; // McZapkie-140302: wyzwalany gdy pojazd stoi
     TEvent *evEventall1 = nullptr;
@@ -196,7 +203,11 @@ class TTrack : public Resource
     TTrack * NullCreate(int dir);
     inline bool IsEmpty()
     {
+#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY
         return (iNumDynamics <= 0);
+#else
+        return Dynamics.empty();
+#endif
     };
     void ConnectPrevPrev(TTrack *pNewPrev, int typ);
     void ConnectPrevNext(TTrack *pNewPrev, int typ);