diff --git a/Hurrican/src/GegnerClass.cpp b/Hurrican/src/GegnerClass.cpp
index 6c7bfc50..3099f8e4 100644
--- a/Hurrican/src/GegnerClass.cpp
+++ b/Hurrican/src/GegnerClass.cpp
@@ -3,11 +3,13 @@
 // --------------------------------------------------------------------------------------
 
 #include "GegnerClass.hpp"
-#include <algorithm>
 #include "Gegner_Helper.hpp"
 #include "Player.hpp"
 #include "stdafx.hpp"
 
+#include <algorithm>
+#include <memory>
+
 // --------------------------------------------------------------------------------------
 // Konstruktor
 // --------------------------------------------------------------------------------------
@@ -540,25 +542,6 @@ bool GegnerClass::IsOnScreen() const {
 // GegnerListClass Funktionen
 // --------------------------------------------------------------------------------------
 
-// --------------------------------------------------------------------------------------
-// Konstruktor : Initialisierung der GegnerDaten
-// --------------------------------------------------------------------------------------
-
-GegnerListClass::GegnerListClass() {
-    pStart = nullptr;
-    pEnd = nullptr;
-    NumGegner = 0;
-}
-
-// --------------------------------------------------------------------------------------
-// Destruktor : Löschen der ganzen Liste und Freigabe der Gegner-Grafiken
-// --------------------------------------------------------------------------------------
-
-GegnerListClass::~GegnerListClass() {
-    // Gegner-Liste komplett leeren
-    ClearAll();
-}
-
 void GegnerListClass::LoadSprites() {
     // Flamme der Drone laden
     DroneFlame.LoadImage("droneflame.png", 164, 46, 82, 46, 2, 1);
@@ -1460,10 +1443,10 @@ void GegnerListClass::LoadSprites() {
 // Gegner "Art" hinzufügen
 // --------------------------------------------------------------------------------------
 
-bool GegnerListClass::PushGegner(float x, float y, int Art, int Value1, int Value2, bool Light, bool atEnd) {
+GegnerClass* GegnerListClass::PushGegner(float x, float y, int Art, int Value1, int Value2, bool Light, bool atEnd) {
 
-    if (NumGegner >= MAX_GEGNER)  // Grenze überschritten ?
-        return false;
+    if (GetNumGegner() >= MAX_GEGNER)  // Grenze überschritten ?
+        return nullptr;
 
     GegnerClass *pNew;  // Das wird der neue Gegner;
 
@@ -1903,7 +1886,7 @@ bool GegnerListClass::PushGegner(float x, float y, int Art, int Value1, int Valu
         } break;
 
         case SHOOTBUTTON: {
-            pNew = new GegnerShootButton(pEnd);
+            pNew = new GegnerShootButton(enemies.back().get());
         } break;
 
         case SHOOTPLATTFORM: {
@@ -2081,35 +2064,17 @@ bool GegnerListClass::PushGegner(float x, float y, int Art, int Value1, int Valu
     pNew->xPosOld = x;
     pNew->yPosOld = y;
 
-    if (pStart == nullptr)  // Liste leer ?
-    {
-        pStart = pNew;  // Ja, dann neuer Gegner gleich der erste
-        pEnd = pNew;    // und letzte Gegner
+    std::unique_ptr<GegnerClass> uNew(pNew);
 
-        pStart->pNext = nullptr;  // Next/Previous gibts nich, da wir
-        pStart->pPrev = nullptr;  // nur 1 Gegner haben
-    } else                     // Liste ist NICHT leer
-    {
-        // Gegner am Ende einfügen?
-        if (atEnd == true) {
-            pEnd->pNext = pNew;  // Letzter Gegner zeigt auf den neuen
-            pNew->pPrev = pEnd;  // Letzter Gegner ist nicht mehr der letzte
-
-            pNew->pNext = nullptr;  // Nach dem neuen Gegner kommt keiner mehr
-            pEnd = pNew;         // da er jetzt der letzte in der Liste ist
-        }
-
-        // Gegner am Anfag einfügen?
-        else {
-            pStart->pPrev = pNew;  // Erster Gegner zeigt auf den neuen
-            pNew->pNext = pStart;  // Erster Gegner ist nicht mehr der erste
-
-            pNew->pPrev = nullptr;  // Vor dem neuen Gegner kommt keiner mehr
-            pStart = pNew;       // da er jetzt der erste in der Liste ist
-        }
+    // Gegner am Ende einfügen?
+    if (atEnd) {
+        enemies.push_back(std::move(uNew));
     }
 
-    NumGegner++;  // Gegneranzahl erhöhen
+    // Gegner am Anfag einfügen?
+    else {
+        enemies.push_front(std::move(uNew));
+    }
 
     // Bei der ShootPlattform noch den Button anfügen
     //
@@ -2118,35 +2083,7 @@ bool GegnerListClass::PushGegner(float x, float y, int Art, int Value1, int Valu
         Gegner.PushGegner(pNew->xPos + 42, pNew->yPos - 9, SHOOTBUTTON, 0, 0, Light);
     }
 
-    return true;
-}
-
-// --------------------------------------------------------------------------------------
-// Bestimmten Gegner der Liste löschen
-// --------------------------------------------------------------------------------------
-
-void GegnerListClass::DelSel(GegnerClass *pTemp) {
-
-    if (pTemp != nullptr)  // zu löschender Gegner existiert
-    {
-        GegnerClass *pN = pTemp->pNext;
-        GegnerClass *pP = pTemp->pPrev;
-
-        if (pP == nullptr)   // Wird der erste Gegner gelöscht ?
-            pStart = pN;  // Dann wird dessen Nächster zum Ersten
-        else
-            pP->pNext = pN;  // ansonsten normal eins aufrücken
-
-        if (pN == nullptr)  // Wird der letzte Gegner gelöscht ?
-            pEnd = pP;   // Dann wir der letzte Gegner zum ersten
-        else
-            pN->pPrev = pP;
-
-        delete (pTemp);  // Speicher freigeben
-        pTemp = nullptr;
-
-        NumGegner--;  // Gegnerzahl verringern
-    }
+    return pNew;
 }
 
 // --------------------------------------------------------------------------------------
@@ -2154,17 +2091,8 @@ void GegnerListClass::DelSel(GegnerClass *pTemp) {
 // --------------------------------------------------------------------------------------
 
 void GegnerListClass::ClearAll() {
-    GegnerClass *pTemp = pStart;  // Zeiger auf den ersten Gegner
 
-    while (pTemp != nullptr)  // Ende der Liste erreicht ?
-    {
-        GegnerClass *pNaechst = pTemp->pNext;  // Zeiger auf den nächsten Gegner (falls der eine gelöscht wird)
-        DelSel(pTemp);            // Das aktuelle löschen
-        pTemp = pNaechst;         // und das nächste bearbeiten
-    }
-
-    pStart = nullptr;
-    pEnd = nullptr;
+    enemies.clear();
 }
 
 // --------------------------------------------------------------------------------------
@@ -2172,7 +2100,8 @@ void GegnerListClass::ClearAll() {
 // --------------------------------------------------------------------------------------
 
 int GegnerListClass::GetNumGegner() const {
-    return NumGegner;
+
+    return enemies.size();
 }
 
 // --------------------------------------------------------------------------------------
@@ -2180,50 +2109,31 @@ int GegnerListClass::GetNumGegner() const {
 // --------------------------------------------------------------------------------------
 
 void GegnerListClass::RenderAll() {
-    GegnerClass *pTemp = pStart;  // Anfang der Liste
 
     // Zuerst die "Gegner" rendern, die als Background fungieren
     // z.B. der große Lüfter, damit diese nicht die anderen Gegner verdecken können
     //
-    while (pTemp != nullptr)  // noch nicht alle durch ?
+    for (auto& enemy: Gegner.enemies)
     {
-        if (pTemp->BackGround == false)  // kein Background? Dann nächsten
-        {
-            pTemp = pTemp->pNext;
-            continue;
-        }
-
-        if (pTemp->Active == true)  // aktueller Gegner aktiv ?
+        if (enemy->BackGround && enemy->Active)
         {
             // dann Gegner rendern
-            pTemp->AlreadyDrawn = false;
-            pTemp->Render();
+            enemy->AlreadyDrawn = false;
+            enemy->Render();
         }
-
-        pTemp = pTemp->pNext;  // Nächsten durchgehen
     }
 
     // Danach alle anderen "richtigen" Gegner rendern
     //
 
-    pTemp = Gegner.pStart;
-
-    while (pTemp != nullptr)  // noch nicht alle durch ?
+    for (auto& enemy: Gegner.enemies)
     {
-        if (pTemp->BackGround == true)  // Background? Dann nächsten
-        {
-            pTemp = pTemp->pNext;
-            continue;
-        }
-
-        if (pTemp->Active == true)  // aktueller Gegner aktiv ?
+        if (!enemy->BackGround && enemy->Active)
         {
             // dann Gegner rendern
-            pTemp->AlreadyDrawn = false;
-            pTemp->Render();
+            enemy->AlreadyDrawn = false;
+            enemy->Render();
         }
-
-        pTemp = pTemp->pNext;  // Und nächsten Gegner rendern
     }
 }
 
@@ -2232,23 +2142,22 @@ void GegnerListClass::RenderAll() {
 // --------------------------------------------------------------------------------------
 
 void GegnerListClass::RunAll() {
-    GegnerClass *pTemp = pStart;  // Anfang der Liste
 
     // Alle Einträge der Gegnerliste durchgehen
     //
-    while (pTemp != nullptr)  // noch nicht alle durch ?
+    auto iter = enemies.begin();
+    while (iter != enemies.end())
     {
-        GegnerClass *pNext = pTemp->pNext;
-
-        pTemp->Run();
+        GegnerClass* enemy = iter->get();
+        enemy->Run();
 
         // ggf Gegner löschen (bei Energy <= 0)
-        if (pTemp->Energy <= 0.0f) {
-            pTemp->GegnerExplode();  // Jeder Gegner explodiert anders
-            DelSel(pTemp);           // Gegner aus der Liste löschen
+        if (enemy->Energy <= 0.0f) {
+            enemy->GegnerExplode();  // Jeder Gegner explodiert anders
+            iter = enemies.erase(iter);
         }
-
-        pTemp = pNext;
+        else
+            ++iter;
     }
 }
 
@@ -2258,25 +2167,25 @@ void GegnerListClass::RunAll() {
 
 void GegnerListClass::DamageEnemiesonScreen(float x, float y, int MaxDamage) {
     // Gegner durchgehen und die auf dem Screen löschen
-    GegnerClass *pTemp = pStart;  // Anfang der Liste
 
-    while (pTemp != nullptr)  // Noch nicht alle durch ?
+    for (auto& enemy: enemies)
     {
-        float const ax = x - pTemp->xPos;
-        float const ay = y - pTemp->yPos;
+        float const ax = x - enemy->xPos;
+        float const ay = y - enemy->yPos;
         float const dx = sqrtf((ax * ax) + (ay * ay));
 
-        GegnerClass *pNext = pTemp->pNext;  // Nächster Gegner in der Liste
-
         // Stampfstein? Fällt runter bei Wackeln
-        if (pTemp->Active == true && pTemp->GegnerArt == STAMPFSTEIN && pTemp->Handlung == GEGNER::STEHEN && dx < 300 &&
-            pTemp->xPos + GegnerRect[pTemp->GegnerArt].right > TileEngine.XOffset &&
-            pTemp->xPos + GegnerRect[pTemp->GegnerArt].left < TileEngine.XOffset + RENDERWIDTH &&
-            pTemp->yPos + GegnerRect[pTemp->GegnerArt].bottom > TileEngine.YOffset &&
-            pTemp->yPos + GegnerRect[pTemp->GegnerArt].top < TileEngine.YOffset + RENDERHEIGHT) {
-            pTemp->Handlung = GEGNER::FALLEN;
-            pTemp->ySpeed = 20.0f;
-            pTemp->yAcc = 15.0f;
+        if (enemy->Active &&
+            enemy->GegnerArt == STAMPFSTEIN &&
+            enemy->Handlung == GEGNER::STEHEN &&
+            dx < 300 &&
+            enemy->xPos + GegnerRect[enemy->GegnerArt].right > TileEngine.XOffset &&
+            enemy->xPos + GegnerRect[enemy->GegnerArt].left < TileEngine.XOffset + RENDERWIDTH &&
+            enemy->yPos + GegnerRect[enemy->GegnerArt].bottom > TileEngine.YOffset &&
+            enemy->yPos + GegnerRect[enemy->GegnerArt].top < TileEngine.YOffset + RENDERHEIGHT) {
+            enemy->Handlung = GEGNER::FALLEN;
+            enemy->ySpeed = 20.0f;
+            enemy->yAcc = 15.0f;
 
             // DKS - Added function WaveIsPlaying() to SoundManagerClass:
             if (!SoundManager.WaveIsPlaying(SOUND::STONEFALL))
@@ -2284,19 +2193,22 @@ void GegnerListClass::DamageEnemiesonScreen(float x, float y, int MaxDamage) {
         }
 
         // Gegner in der Nähe? Dann Energie abziehen
-        if (pTemp->Active == true && dx < 300 && pTemp->Destroyable == true && pTemp->GegnerArt != POWERBLOCK &&
-            pTemp->GegnerArt < RIESENPIRANHA && pTemp->xPos + GegnerRect[pTemp->GegnerArt].right > TileEngine.XOffset &&
-            pTemp->xPos + GegnerRect[pTemp->GegnerArt].left < TileEngine.XOffset + RENDERWIDTH &&
-            pTemp->yPos + GegnerRect[pTemp->GegnerArt].bottom > TileEngine.YOffset &&
-            pTemp->yPos + GegnerRect[pTemp->GegnerArt].top < TileEngine.YOffset + RENDERHEIGHT) {
+        if (enemy->Active &&
+            dx < 300 &&
+            enemy->Destroyable &&
+            enemy->GegnerArt != POWERBLOCK &&
+            enemy->GegnerArt < RIESENPIRANHA &&
+            enemy->xPos + GegnerRect[enemy->GegnerArt].right > TileEngine.XOffset &&
+            enemy->xPos + GegnerRect[enemy->GegnerArt].left < TileEngine.XOffset + RENDERWIDTH &&
+            enemy->yPos + GegnerRect[enemy->GegnerArt].bottom > TileEngine.YOffset &&
+            enemy->yPos + GegnerRect[enemy->GegnerArt].top < TileEngine.YOffset + RENDERHEIGHT) {
+
             int amount = static_cast<int>(MaxDamage - dx);
 
             if (amount < 0)
                 amount = 0;
 
-            pTemp->Energy -= amount;
+            enemy->Energy -= amount;
         }
-
-        pTemp = pNext;  // Und nächsten Gegner anhandeln
     }
 }
diff --git a/Hurrican/src/GegnerClass.hpp b/Hurrican/src/GegnerClass.hpp
index 138e1fc0..b4cb1f88 100644
--- a/Hurrican/src/GegnerClass.hpp
+++ b/Hurrican/src/GegnerClass.hpp
@@ -22,6 +22,9 @@
 #endif
 #include "DX8Sprite.hpp"
 
+#include <list>
+#include <memory>
+
 // --------------------------------------------------------------------------------------
 // Defines
 // --------------------------------------------------------------------------------------
@@ -100,8 +103,6 @@ class GegnerClass {
     void TurnonWall();                                       // An der Wand umdrehen?
     bool TurnonShot();                                       // Umdrehen, wenn angeschoßen
     bool IsOnScreen() const;                                 // Gegner grade sichtbar?
-    GegnerClass *pNext;                                      // Zeiger auf den nächsten   Gegner
-    GegnerClass *pPrev;                                      // Zeiger auf den vorherigen Gegner
 };
 
 // --------------------------------------------------------------------------------------
@@ -109,34 +110,27 @@ class GegnerClass {
 // --------------------------------------------------------------------------------------
 
 class GegnerListClass {
-  private:
-    int NumGegner;  // aktuelle Zahl der Gegner
-
   public:
     // DKS - Moved these three here, they used to be dynamic globals in Gegner_Helper.cpp:
     //      (Moved so they would always get destructed in a place we had control over)
     DirectGraphicsSprite DroneFlame;  // Flamme der Drone
     DirectGraphicsSprite DroneGun;    // Flamme der Zitrone
 
-    GegnerClass *pStart;  // Erstes  Element der Liste
-    GegnerClass *pEnd;    // Letztes Element der Liste
-
-    GegnerListClass();   // Konstruktor
-    ~GegnerListClass();  // Destruktor
+    std::list<std::unique_ptr<GegnerClass>> enemies;
 
     // DKS - GegnerListClass is now a static global, instead of dynamically allocated
     //      pointer, so moved the loading of sprites from its constructor to this new
     //      function:
     void LoadSprites();
 
-    bool PushGegner(float x,
+    GegnerClass* PushGegner(
+                    float x,
                     float y,
                     int Art,  // Gegner "Art" hinzufügen
                     int Value1,
                     int Value2,
                     bool Light,
                     bool atEnd = true);
-    void DelSel(GegnerClass *pTemp);  // Ausgewählten Gegner entfernen
     void ClearAll();                  // Alle Gegner löschen
     int GetNumGegner() const;         // Zahl der Gegner zurückliefern
     void RunAll();                    // Alle Gegner der Liste animieren
diff --git a/Hurrican/src/Player.cpp b/Hurrican/src/Player.cpp
index c407b875..e235e7e3 100644
--- a/Hurrican/src/Player.cpp
+++ b/Hurrican/src/Player.cpp
@@ -880,18 +880,11 @@ void PlayerClass::CheckForExplode() {
         ExplodingTimer = 30.0f;
 
         // Punisher verschwinden lassen
-        GegnerClass *pTemp;
-        GegnerPunisher *pPunisher;
-
-        pTemp = Gegner.pStart;
-
-        while (pTemp != nullptr) {
-            if (pTemp->GegnerArt == PUNISHER) {
-                pPunisher = reinterpret_cast<GegnerPunisher *>(pTemp);
+        for (auto& enemy: Gegner.enemies) {
+            if (enemy->GegnerArt == PUNISHER) {
+                GegnerPunisher *pPunisher = reinterpret_cast<GegnerPunisher *>(enemy.get());
                 pPunisher->Vanish();
             }
-
-            pTemp = pTemp->pNext;
         }
 
         if (Handlung == PlayerActionEnum::SACKREITEN || Handlung == PlayerActionEnum::DREHEN) {
@@ -3633,8 +3626,7 @@ bool PlayerClass::DoLightning() {
         float ys = ystart;
 
         // Blitz auf Kollision mit den Gegnern prüfen
-        GegnerClass *pEnemy = Gegner.pStart;    // Anfang der Gegnerliste
-        while (pEnemy != nullptr)  // Noch nicht alle durch ?
+        for (auto& pEnemy: Gegner.enemies)
         {
             if (pEnemy->Active &&     // Ist der Gegner überhaupt aktiv ?
                 pEnemy->Destroyable)  // und zerstörbar ?
@@ -3669,8 +3661,6 @@ bool PlayerClass::DoLightning() {
                     }
                 }
             }
-
-            pEnemy = pEnemy->pNext;  // Nächsten Gegner testen
         }
 
         // Zerstörbare Wände ?
diff --git a/Hurrican/src/Projectiles.cpp b/Hurrican/src/Projectiles.cpp
index 6c559593..e29fee4b 100644
--- a/Hurrican/src/Projectiles.cpp
+++ b/Hurrican/src/Projectiles.cpp
@@ -12,7 +12,6 @@
 // Include Dateien
 // --------------------------------------------------------------------------------------
 
-#include <cmath>
 
 #include "Console.hpp"
 #include "DX8Font.hpp"
@@ -27,6 +26,9 @@
 #include "Tileengine.hpp"
 #include "Timer.hpp"
 
+#include <cmath>
+#include <algorithm>
+
 // --------------------------------------------------------------------------------------
 // Defines
 // --------------------------------------------------------------------------------------
@@ -113,22 +115,14 @@ void ProjectileClass::CreateShot(float x, float y, int Art, PlayerClass *pTemp)
     switch (Art) {
         case DIAMONDSHOT:  // Diamant, der auf den Punisher fliegt
         {
-            // DKS - Fixed uninitialized variable:
-            // GegnerClass *pAim, *pTemp2;
-            GegnerClass *pAim = nullptr;
-            GegnerClass *pTemp2 = Gegner.pStart;
-
-            while (pTemp2 != nullptr) {
-                if (pTemp2->GegnerArt == PUNISHER) {
-                    pAim = pTemp2;
-                    pTemp2 = nullptr;
-                } else
-                    pTemp2 = pTemp2->pNext;
-            }
+            auto punisher = std::find_if(Gegner.enemies.begin(), Gegner.enemies.end(),
+                         [](const auto& pEnemy) { return pEnemy->GegnerArt == PUNISHER; });
 
-            if (pAim == nullptr)
+            if (punisher == Gegner.enemies.end())
                 return;
 
+            GegnerClass *pAim = punisher->get();
+
             // DKS - Converted to float:
 
             float absx = pAim->xPos + 85 - xPos;  // Differenz der x
@@ -1815,9 +1809,8 @@ void ProjectileClass::CreateShot(float x, float y, int Art, PlayerClass *pTemp)
 // --------------------------------------------------------------------------------------
 
 void ProjectileClass::CheckCollision() {
-    GegnerClass *pEnemy = Gegner.pStart;  // Anfang der Gegnerliste
 
-    while (pEnemy != nullptr)  // Noch nicht alle durch ?
+    for (auto& pEnemy: Gegner.enemies)  // Noch nicht alle durch ?
     {
         if (pEnemy->Active &&                                                // Ist der Gegner überhaupt aktiv ?
             pEnemy->Destroyable &&                                           // und kann man ihn zerstören
@@ -1918,7 +1911,6 @@ void ProjectileClass::CheckCollision() {
                 }
             }
         }
-        pEnemy = pEnemy->pNext;  // Nächsten Gegner testen
     }
 }
 
@@ -3990,8 +3982,7 @@ void ProjectileClass::ExplodeShot() {
             if (ShotArt == BOMBEBIG)
                 schaden = 250;
 
-            pEnemy = Gegner.pStart;  // Anfang der Gegnerliste
-            while (pEnemy != nullptr)   // Noch nicht alle durch ?
+            for (auto& pEnemy: Gegner.enemies)   // Noch nicht alle durch ?
             {
                 xdiff = (xPos + ShotRect[ShotArt].left + (ShotRect[ShotArt].right - ShotRect[ShotArt].left) / 2) -
                         (pEnemy->xPos + GegnerRect[pEnemy->GegnerArt].right / 2);
@@ -4014,7 +4005,6 @@ void ProjectileClass::ExplodeShot() {
 
                     pEnemy->Energy -= (schaden - Abstand) * 1.5f;  // Dann Energy abziehen je nach Abstand
                 }
-                pEnemy = pEnemy->pNext;  // Nächsten Gegner testen
             }
 
             // Prüfen, ob der Spieler in der Nähe war, und falls ja, dann diesen
diff --git a/Hurrican/src/bosses/Boss_Drache.cpp b/Hurrican/src/bosses/Boss_Drache.cpp
index 5df08377..d8d68c46 100644
--- a/Hurrican/src/bosses/Boss_Drache.cpp
+++ b/Hurrican/src/bosses/Boss_Drache.cpp
@@ -337,12 +337,9 @@ void GegnerDrache::DoKI() {
         HeadLocked = true;
 
         // Alle übrigen Mini-Drachen zerstören
-        GegnerClass *pTemp = Gegner.pStart;
-        while (pTemp != nullptr) {
-            if (pTemp->GegnerArt == MINIDRAGON)
-                pTemp->Energy = 0.0f;
-
-            pTemp = pTemp->pNext;
+        for (auto& enemy: Gegner.enemies) {
+            if (enemy->GegnerArt == MINIDRAGON)
+                enemy->Energy = 0.0f;
         }
 
         // Endboss-Musik ausfaden und abschalten
diff --git a/Hurrican/src/bosses/Boss_FahrstuhlBoss.cpp b/Hurrican/src/bosses/Boss_FahrstuhlBoss.cpp
index a1b3e917..23b8cedd 100644
--- a/Hurrican/src/bosses/Boss_FahrstuhlBoss.cpp
+++ b/Hurrican/src/bosses/Boss_FahrstuhlBoss.cpp
@@ -544,15 +544,12 @@ void GegnerFahrstuhlBoss::DoKI() {
         for (int p = 0; p < NUMPLAYERS; p++)
             Player[p].ypos -= A;
 
-        GegnerClass *pTemp3 = Gegner.pStart;  // Zeiger auf den ersten Gegner
-        while (pTemp3 != nullptr)                // Ende der Liste erreicht ?
+        for (auto& enemy: Gegner.enemies)
         {
-            if (pTemp3->GegnerArt >= SPITTER && pTemp3->GegnerArt <= FAHRSTUHL) {
-                pTemp3->yPos -= A;  // Nach oben bewegen
-                pTemp3->yPosOld -= A;
+            if (enemy->GegnerArt >= SPITTER && enemy->GegnerArt <= FAHRSTUHL) {
+                enemy->yPos -= A;  // Nach oben bewegen
+                enemy->yPosOld -= A;
             }
-
-            pTemp3 = pTemp3->pNext;  // Zeiger auf das nächste Element
         }
 
         ProjectileClass *pTemp4 = Projectiles.pStart;  // Zeiger auf den ersten Schuss
diff --git a/Hurrican/src/bosses/Boss_Rollmops.cpp b/Hurrican/src/bosses/Boss_Rollmops.cpp
index d56ad59d..b746dd00 100644
--- a/Hurrican/src/bosses/Boss_Rollmops.cpp
+++ b/Hurrican/src/bosses/Boss_Rollmops.cpp
@@ -33,8 +33,7 @@ GegnerRollmops::GegnerRollmops(int Wert1, int Wert2, bool Light) {
     Gun.LoadImage("rollmops_gun.png", 53, 52, 53, 52, 1, 1);
 
     for (int i = 0; i < NUM_KETTENGLIEDER; i++) {
-        Gegner.PushGegner(0, 0, KETTENGLIED, 0, 0, false);
-        pKettenTeile[i] = reinterpret_cast<GegnerKettenglied *>(Gegner.pEnd);
+        pKettenTeile[i] = reinterpret_cast<GegnerKettenglied *>(Gegner.PushGegner(0, 0, KETTENGLIED, 0, 0, false));
         pKettenTeile[i]->pParent = this;
     }
 }
diff --git a/Hurrican/src/bosses/Boss_Schneekoenig.cpp b/Hurrican/src/bosses/Boss_Schneekoenig.cpp
index 0cb5dfaa..f95f9e44 100644
--- a/Hurrican/src/bosses/Boss_Schneekoenig.cpp
+++ b/Hurrican/src/bosses/Boss_Schneekoenig.cpp
@@ -610,21 +610,17 @@ void GegnerSchneeKoenig::DoKI() {
     }
 
     // Checken, ob der Schneekönig von einer Schneekoppe getroffen wurde =)
-    GegnerClass *pTemp = Gegner.pStart;
-
     if (Handlung != GEGNER::AUSFAHREN)
-        while (pTemp != nullptr) {
-            if (pTemp->GegnerArt == SCHNEEKOPPE)
-                if (SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pTemp->xPos, pTemp->yPos,
-                                    GegnerRect[pTemp->GegnerArt])) {
-                    pTemp->Energy = 0.0f;
+        for (auto& enemy: Gegner.enemies) {
+            if (enemy->GegnerArt == SCHNEEKOPPE)
+                if (SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], enemy->xPos, enemy->yPos,
+                                    GegnerRect[enemy->GegnerArt])) {
+                    enemy->Energy = 0.0f;
                     Energy -= 5000.0f;
 
                     if (Handlung != GEGNER::SPRINGEN)
                         WackelAnim = 8.0f;
                 }
-
-            pTemp = pTemp->pNext;
         }
 
     // kaputt? Dann rausfliegen
diff --git a/Hurrican/src/bosses/Boss_Skull.cpp b/Hurrican/src/bosses/Boss_Skull.cpp
index 3cb6811d..999c437f 100644
--- a/Hurrican/src/bosses/Boss_Skull.cpp
+++ b/Hurrican/src/bosses/Boss_Skull.cpp
@@ -34,16 +34,14 @@ GegnerSkull::GegnerSkull(int Wert1, int Wert2, bool Light) :
     Handlung = GEGNER::SPECIAL;
 
     // Position der Endboss Wand rausfinden
-    GegnerClass *pTemp = Gegner.pStart;
-    while (pTemp != nullptr) {
-        if (pTemp->GegnerArt == THEWALL) {
-            mxPos = pTemp->xPos + 5;
-            myPos = pTemp->yPos + 229;
-            pMachine = pTemp;
-
-            pTemp = nullptr;
-        } else
-            pTemp = pTemp->pNext;
+    for (auto& enemy: Gegner.enemies) {
+        if (enemy->GegnerArt == THEWALL) {
+            mxPos = enemy->xPos + 5;
+            myPos = enemy->yPos + 229;
+            pMachine = enemy.get();
+
+            break;
+        }
     }
 }
 
diff --git a/Hurrican/src/bosses/Boss_TheWall.cpp b/Hurrican/src/bosses/Boss_TheWall.cpp
index c378a8e5..08771ec8 100644
--- a/Hurrican/src/bosses/Boss_TheWall.cpp
+++ b/Hurrican/src/bosses/Boss_TheWall.cpp
@@ -241,13 +241,10 @@ void GegnerTheWall::NeueAktion() {
 // --------------------------------------------------------------------------------------
 
 void GegnerTheWall::ReturnSkull() {
-    GegnerClass *pTemp = Gegner.pStart;
 
-    while (pTemp != nullptr) {
-        if (pTemp->GegnerArt == SKULL)
-            pTemp->Handlung = GEGNER::SPECIAL2;
-
-        pTemp = pTemp->pNext;
+    for (auto& enemy: Gegner.enemies) {
+        if (enemy->GegnerArt == SKULL)
+            enemy->Handlung = GEGNER::SPECIAL2;
     }
 }
 
@@ -452,17 +449,12 @@ void GegnerTheWall::DoKI() {
             AnimCount = 100.0f;
 
             // Den Schädel verschwinden lassen
-            GegnerClass *pTemp;
-            pTemp = Gegner.pStart;
-
-            while (pTemp != nullptr) {
-                if (pTemp->GegnerArt == SKULL) {
-                    pTemp->Value1 = 0;
-                    pTemp->AnimCount = 0.5f;
-                    pTemp->Handlung = GEGNER::SPECIAL3;
+            for (auto& enemy: Gegner.enemies) {
+                if (enemy->GegnerArt == SKULL) {
+                    enemy->Value1 = 0;
+                    enemy->AnimCount = 0.5f;
+                    enemy->Handlung = GEGNER::SPECIAL3;
                 }
-
-                pTemp = pTemp->pNext;
             }
         }
     } else {
diff --git a/Hurrican/src/enemies/Gegner_Diamant.cpp b/Hurrican/src/enemies/Gegner_Diamant.cpp
index 0692e98d..d6674c3d 100644
--- a/Hurrican/src/enemies/Gegner_Diamant.cpp
+++ b/Hurrican/src/enemies/Gegner_Diamant.cpp
@@ -117,18 +117,11 @@ void GegnerDiamant::DoKI() {
                 Player[0].PunisherActive = false;
                 Player[1].PunisherActive = false;
 
-                GegnerClass *pTemp;
-                GegnerPunisher *pPunisher;
-
-                pTemp = Gegner.pStart;
-
-                while (pTemp != nullptr) {
-                    if (pTemp->GegnerArt == PUNISHER) {
-                        pPunisher = reinterpret_cast<GegnerPunisher *>(pTemp);
+                for (auto& enemy: Gegner.enemies) {
+                    if (enemy->GegnerArt == PUNISHER) {
+                        GegnerPunisher *pPunisher = reinterpret_cast<GegnerPunisher *>(enemy.get());
                         pPunisher->Vanish();
                     }
-
-                    pTemp = pTemp->pNext;
                 }
             }
             Energy = 0.0f;
diff --git a/Hurrican/src/enemies/Gegner_SchleimMaul.cpp b/Hurrican/src/enemies/Gegner_SchleimMaul.cpp
index 56a85270..1a4de995 100644
--- a/Hurrican/src/enemies/Gegner_SchleimMaul.cpp
+++ b/Hurrican/src/enemies/Gegner_SchleimMaul.cpp
@@ -41,8 +41,7 @@ GegnerSchleimMaul::GegnerSchleimMaul(float x, float y, int Wert1, int Wert2, boo
         //      radian inputs, while also adding support of deg/rad cos/sin w/ lookup table support:
         // Gegner.PushGegner (x + static_cast<float>(sin(r)) * r1, y + static_cast<float>(cos(r)) * r2, SCHLEIMALIEN, 0,
         // 0, ChangeLight);
-        Gegner.PushGegner(x + sin_deg(r) * r1, y + cos_deg(r) * r2, SCHLEIMALIEN, 0, 0, ChangeLight);
-        pChildren[i] = Gegner.pEnd;
+        pChildren[i] = Gegner.PushGegner(x + sin_deg(r) * r1, y + cos_deg(r) * r2, SCHLEIMALIEN, 0, 0, ChangeLight);
     }
 }
 
@@ -79,8 +78,7 @@ void GegnerSchleimMaul::DoKI() {
             //      radian inputs, while also adding support of deg/rad cos/sin w/ lookup table support:
             // Gegner.PushGegner (xPos + static_cast<float>(sin(r)) * r1, yPos + static_cast<float>(cos(r)) * r2,
             // SCHLEIMALIEN, 20, 0, ChangeLight);
-            Gegner.PushGegner(xPos + sin_deg(r) * r1, yPos + cos_deg(r) * r2, SCHLEIMALIEN, 20, 0, ChangeLight);
-            pChildren[i] = Gegner.pEnd;
+            pChildren[i] = Gegner.PushGegner(xPos + sin_deg(r) * r1, yPos + cos_deg(r) * r2, SCHLEIMALIEN, 20, 0, ChangeLight);
         }
     }
 
diff --git a/Hurrican/src/triggers/Trigger_Bruecke.cpp b/Hurrican/src/triggers/Trigger_Bruecke.cpp
index 213fe839..b09698e4 100644
--- a/Hurrican/src/triggers/Trigger_Bruecke.cpp
+++ b/Hurrican/src/triggers/Trigger_Bruecke.cpp
@@ -44,26 +44,28 @@ void GegnerBruecke::DoKI() {
     if (options_Detail == DETAIL_MAXIMUM) {
         // Irgendein Gegner steht auf der Brücke
         //
-        GegnerClass *pTemp = Gegner.pStart;  // Anfang der Liste
 
-        while (pTemp != nullptr)  // noch nicht alle durch ?
+        for (auto& enemy: Gegner.enemies)
         {
-            if (pTemp->Active == true && pTemp->GegnerArt != BRUECKE && pTemp->GegnerArt != BRUECKE &&
-                pTemp->GegnerArt != STAHLMUECKE && pTemp->ySpeed == 0.0f &&
-                SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pTemp->xPos, pTemp->yPos,
-                                GegnerRect[pTemp->GegnerArt]) == true) {
+            if (enemy->Active == true &&
+                enemy->GegnerArt != BRUECKE &&
+                enemy->GegnerArt != BRUECKE &&
+                enemy->GegnerArt != STAHLMUECKE &&
+                enemy->ySpeed == 0.0f &&
+                SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], enemy->xPos, enemy->yPos,
+                                GegnerRect[enemy->GegnerArt]) == true) {
 
                 // DKS - Optimized
-                // w = (GegnerRect[pTemp->GegnerArt].right  - GegnerRect[pTemp->GegnerArt].left) / 2.0f;
-                // h = (GegnerRect[pTemp->GegnerArt].bottom - GegnerRect[pTemp->GegnerArt].top)  / 2.0f;
-                float w = (GegnerRect[pTemp->GegnerArt].right - GegnerRect[pTemp->GegnerArt].left) * 0.5f;
-                float h = (GegnerRect[pTemp->GegnerArt].bottom - GegnerRect[pTemp->GegnerArt].top) * 0.5f;
+                // w = (GegnerRect[enemy->GegnerArt].right  - GegnerRect[enemy->GegnerArt].left) / 2.0f;
+                // h = (GegnerRect[enemy->GegnerArt].bottom - GegnerRect[enemy->GegnerArt].top)  / 2.0f;
+                float w = (GegnerRect[enemy->GegnerArt].right - GegnerRect[enemy->GegnerArt].left) * 0.5f;
+                float h = (GegnerRect[enemy->GegnerArt].bottom - GegnerRect[enemy->GegnerArt].top) * 0.5f;
 
-                if (pTemp->GegnerArt == DIAMANT)
+                if (enemy->GegnerArt == DIAMANT)
                     h = 2;
 
-                float dx = pTemp->xPos + w - (xPos + 5);
-                float dy = pTemp->yPos + h - (yPos + 5);
+                float dx = enemy->xPos + w - (xPos + 5);
+                float dy = enemy->yPos + h - (yPos + 5);
 
                 // DKS - converted to float:
                 // double a = sqrt ((dx * dx) + (dy * dy));
@@ -72,15 +74,13 @@ void GegnerBruecke::DoKI() {
                 if (a > 40.0f)
                     a = 40.0f;
 
-                if (pTemp->GegnerArt == SPITTER)
+                if (enemy->GegnerArt == SPITTER)
                     a += 13.0f;
 
                 // DKS - Optimized
-                // yPos = float (pTemp->yPos + GegnerRect[pTemp->GegnerArt].bottom - a / 2.5f + 13.0f);
-                yPos = pTemp->yPos + static_cast<float>(GegnerRect[pTemp->GegnerArt].bottom) - a * (1.0f / 2.5f) + 13.0f;
+                // yPos = float (enemy->yPos + GegnerRect[enemy->GegnerArt].bottom - a / 2.5f + 13.0f);
+                yPos = enemy->yPos + static_cast<float>(GegnerRect[enemy->GegnerArt].bottom) - a * (1.0f / 2.5f) + 13.0f;
             }
-
-            pTemp = pTemp->pNext;  // Nächsten Gegner durchgehen
         }
 
         // Spieler steht auf der Brücke
diff --git a/Hurrican/src/triggers/Trigger_SchleuseV.cpp b/Hurrican/src/triggers/Trigger_SchleuseV.cpp
index 4d1ccb14..731c1621 100644
--- a/Hurrican/src/triggers/Trigger_SchleuseV.cpp
+++ b/Hurrican/src/triggers/Trigger_SchleuseV.cpp
@@ -43,20 +43,16 @@ void GegnerSchleuseV::DoKI() {
         }
 
     // Testen, ob ein Gegner die Schleuse berührt hat
-    //
-    GegnerClass *pTemp = Gegner.pStart;  // Anfang der Liste
-
-    while (pTemp != nullptr)  // noch nicht alle durch ?
+    for (auto& pEnemy: Gegner.enemies)
     {
-        if (pTemp->Active == true && SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pTemp->xPos, pTemp->yPos,
-                                                     GegnerRect[pTemp->GegnerArt]) == true) {
-            if (pTemp->xPos < xPos)
-                pTemp->xPos = xPos + GegnerRect[GegnerArt].left - GegnerRect[pTemp->GegnerArt].right;
-            if (pTemp->xPos > xPos)
-                pTemp->xPos = xPos + GegnerRect[GegnerArt].right - GegnerRect[pTemp->GegnerArt].left;
+        if (pEnemy->Active &&
+            SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pEnemy->xPos, pEnemy->yPos,
+                                                     GegnerRect[pEnemy->GegnerArt])) {
+            if (pEnemy->xPos < xPos)
+                pEnemy->xPos = xPos + GegnerRect[GegnerArt].left - GegnerRect[pEnemy->GegnerArt].right;
+            if (pEnemy->xPos > xPos)
+                pEnemy->xPos = xPos + GegnerRect[GegnerArt].right - GegnerRect[pEnemy->GegnerArt].left;
         }
-
-        pTemp = pTemp->pNext;  // Nächsten Gegner durchgehen
     }
 
     switch (Handlung) {
diff --git a/Hurrican/src/triggers/Trigger_Stampfstein.cpp b/Hurrican/src/triggers/Trigger_Stampfstein.cpp
index 9fbf74f0..253ae584 100644
--- a/Hurrican/src/triggers/Trigger_Stampfstein.cpp
+++ b/Hurrican/src/triggers/Trigger_Stampfstein.cpp
@@ -128,17 +128,11 @@ void GegnerStampfstein::DoKI() {
                 Handlung = GEGNER::INIT;
 
                 // Checken, ob Gegner darunter waren
-                GegnerClass *pTemp;
-
-                pTemp = Gegner.pStart;
-
-                while (pTemp != nullptr) {
-                    if (pTemp->Destroyable == true && pTemp != this &&
-                        SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pTemp->xPos, pTemp->yPos,
-                                        GegnerRect[pTemp->GegnerArt]) == true)
-                        pTemp->Energy = 0.0f;
-
-                    pTemp = pTemp->pNext;
+                for (auto& pEnemy: Gegner.enemies) {
+                    if (pEnemy->Destroyable && pEnemy.get() != this &&
+                        SpriteCollision(xPos, yPos, GegnerRect[GegnerArt], pEnemy->xPos, pEnemy->yPos,
+                                        GegnerRect[pEnemy->GegnerArt]) == true)
+                        pEnemy->Energy = 0.0f;
                 }
             }
 
diff --git a/Hurrican/src/triggers/Trigger_Switch.cpp b/Hurrican/src/triggers/Trigger_Switch.cpp
index 709839e8..3db6e428 100644
--- a/Hurrican/src/triggers/Trigger_Switch.cpp
+++ b/Hurrican/src/triggers/Trigger_Switch.cpp
@@ -44,16 +44,12 @@ void GegnerSwitch::DoKI() {
             SoundManager.PlayWave(100, 128, 11025, SOUND::SWITCH);
 
             // Und prüfen, ob ein Objekt aktiviert wird
-            GegnerClass *pTemp = Gegner.pStart;  // Anfang der Liste
-
-            while (pTemp != nullptr)  // noch nicht alle durch ?
+            for (auto& pEnemy: Gegner.enemies)
             {
                 // Value2 stimmt mit dem des Schalters überein? Dann soll dieses Objekt vom Schalter aktiviert werden
-                if (pTemp != this && pTemp->Value2 == Value2) {
-                    pTemp->Handlung = GEGNER::OEFFNEN;
+                if (pEnemy.get() != this && pEnemy->Value2 == Value2) {
+                    pEnemy->Handlung = GEGNER::OEFFNEN;
                 }
-
-                pTemp = pTemp->pNext;  // Nächsten Gegner durchgehen
             }
         }
 }
diff --git a/Hurrican/src/triggers/Trigger_TutorialText.cpp b/Hurrican/src/triggers/Trigger_TutorialText.cpp
index fea946b4..1e080281 100644
--- a/Hurrican/src/triggers/Trigger_TutorialText.cpp
+++ b/Hurrican/src/triggers/Trigger_TutorialText.cpp
@@ -125,15 +125,11 @@ void GegnerTutorialText::DoKI() {
             // die ersten drei augen plattgemacht?
             //
             case 9: {
-                GegnerClass *pTemp = Gegner.pStart;
-
-                while (pTemp != nullptr) {
+                for (auto& pEnemy: Gegner.enemies) {
                     // noch mind. ein Auge am Leben=
                     //
-                    if (pTemp->GegnerArt == AUGE && pTemp->Value2 == 99)
+                    if (pEnemy->GegnerArt == AUGE && pEnemy->Value2 == 99)
                         stillAlive = true;
-
-                    pTemp = pTemp->pNext;
                 }
 
                 if (stillAlive == false) {
@@ -161,23 +157,17 @@ void GegnerTutorialText::DoKI() {
 
             // ersten Powerblock angeschoßen?
             case 16: {
-                GegnerClass *pTemp = Gegner.pStart;
-
-                while (pTemp != nullptr) {
-                    if (pTemp->GegnerArt == POWERBLOCK) {
-                        GegnerPowerBlock *pPower;
-
+                for (auto& pEnemy: Gegner.enemies) {
+                    if (pEnemy->GegnerArt == POWERBLOCK) {
                         // angeschoßenen PowerBlock suchen
                         //
-                        pPower = reinterpret_cast<GegnerPowerBlock *>(pTemp);
+                        GegnerPowerBlock *pPower = reinterpret_cast<GegnerPowerBlock *>(pEnemy.get());
 
                         if (pPower->ExtraType == 7 && pPower->AnimPhase == 1) {
                             Value1 = 17;
-                            pTemp = Gegner.pEnd;
-                        } else
-                            pTemp = pTemp->pNext;
-                    } else
-                        pTemp = pTemp->pNext;
+                            break;
+                        }
+                    }
                 }
             } break;