Iterartoren hinzugefügt

Array.h

@@ -12,8 +12,8 @@ namespace Framework
     struct ArrayEintrag
     {
         TYP var;
-        bool set;
-        ArrayEintrag< TYP > *next;
+        bool set = false;
+        ArrayEintrag< TYP > *next = 0;
 
         // Setzt den Eintrag auf die Werte des anderen Eintrages
         ArrayEintrag &operator=( ArrayEintrag &r )
@@ -26,6 +26,14 @@ namespace Framework
         // Gibt den aktuell gespeicherten Wert zurück
         operator TYP()
         {
+            if( !set )
+            {
+                Text err = "Index out of Range Exception File: ";
+                err += __FILE__;
+                err += " Line: ";
+                err += __LINE__;
+                throw std::out_of_range( (char*)err );
+            }
             return var;
         }
         // inkrementiert durch die Linked List durch
@@ -57,6 +65,123 @@ namespace Framework
             return *next;
         }
     };
+    
+    template< class TYP >
+    class Iterator
+    {
+    private:
+        ArrayEintrag< TYP > *current;
+
+    public:
+        Iterator( ArrayEintrag< TYP > *start )
+        {
+            current = start;
+            while( current && !current->set )
+            {
+                current = current->next;
+            }
+        }
+
+        Iterator( const Iterator &it )
+        {
+            current = it.current;
+        }
+
+        Iterator< TYP > &operator=( Iterator< TYP > &r )
+        {
+            current = r.current;
+            return *this;
+        }
+
+        bool hasNext()
+        {
+            ArrayEintrag< TYP > *next = current->next;
+            while( next && !next->set )
+            {
+                next = next->next;
+            }
+            return next != 0;
+        }
+
+        Iterator< TYP > next()
+        {
+            if( !current )
+            {
+                Text err = "Index out of Range Exception File: ";
+                err += __FILE__;
+                err += " Line: ";
+                err += __LINE__;
+                throw std::out_of_range( (char*)err );
+            }
+            return Iterator( current->next );
+        }
+        
+        operator bool()
+        {
+            return current != 0;
+        }
+        
+        operator TYP()
+        {
+            if( !current || !current->set )
+            {
+                Text err = "Index out of Range Exception File: ";
+                err += __FILE__;
+                err += " Line: ";
+                err += __LINE__;
+                throw std::out_of_range( (char*)err );
+            }
+            return current->var;
+        }
+
+        Iterator< TYP > &operator++() // prefix
+        {
+            Iterator< TYP > temp( *this );
+            do
+            {
+                if( current )
+                    current = current->next;
+            } while( current && !current->set );
+            return temp;
+        }
+        
+        Iterator< TYP > &operator++( int ) // postfix
+        {
+            do
+            {
+                if( current )
+                    current = current->next;
+            } while( current && !current->set );
+            return *this;
+        }
+        
+        TYP operator->()
+        {
+            if( !current || !current->set )
+            {
+                Text err = "Index out of Range Exception File: ";
+                err += __FILE__;
+                err += " Line: ";
+                err += __LINE__;
+                throw std::out_of_range( (char*)err );
+            }
+            return current->var;
+        }
+
+        TYP val()
+        {
+            if( !current || !current->set )
+            {
+                Text err = "Index out of Range Exception File: ";
+                err += __FILE__;
+                err += " Line: ";
+                err += __LINE__;
+                throw std::out_of_range( (char*)err );
+            }
+            return current->var;
+        }
+    };
+#define _ val()
 
     template< class TYP >
     // Eine Linked List von Klassen, die kein Reference Counting berteiben
@@ -270,18 +395,18 @@ namespace Framework
 			entries->next = 0;
         }
 
-        // Gibt das Erste Element der Liste zurück.
+        // Gibt einen Iterator zurück.
         // Mit ++ kann durch die Liste iteriert werden
-        ArrayEintrag< TYP > &getArray()
+        Iterator< TYP > getIterator() const
         {
-            return *entries;
+            return Iterator< TYP >( entries );
         }
 
         // Gibt zurück, wie viele Elemente in der Liste sind
         int getEintragAnzahl() const
         {
             int i = 0;
-            for( ArrayEintrag< TYP > *e = entries; e && ( e->set || e->next ); e = e->next )
+            for( auto it = getIterator(); it; it++ )
                 ++i;
             return i;
         }
@@ -607,18 +732,18 @@ namespace Framework
             entries->next = 0;
         }
 
-        // Gibt das Erste Element der Liste zurück.
+        // Gibt einen Iterator zurück.
         // Mit ++ kann durch die Liste iteriert werden
-        ArrayEintrag< TYP* > &getArray() const
+        Iterator< TYP* > getIterator() const
         {
-            return *entries;
+            return Iterator< TYP* >( entries );
         }
 
         // Gibt zurück, wie viele Elemente in der Liste sind
         int getEintragAnzahl() const
         {
             int i = 0;
-            for( ArrayEintrag< TYP* > *e = entries; e && ( e->set || e->next ); e = e->next )
+            for( auto it = getIterator(); it; it++ )
                 ++i;
             return i;
         }

Bildschirm.cpp

@@ -899,8 +899,8 @@ void Bildschirm3D::tick( double tickval )
 {
     lock();
     __super::tick( tickval );
-    for( auto i = kameras->getArray(); i.set; i++ )
-        rend3D |= i.var->tick( tickval );
+    for( auto i = kameras->getIterator(); i; i++ )
+        rend3D |= i->tick( tickval );
     rend3D |= texturModel->tick( tickval );
     unlock();
 }
@@ -954,8 +954,8 @@ void Bildschirm3D::render() // Zeichnet das Bild
             // Set the depth stencil state.
             d3d11Context->OMSetDepthStencilState( depthStencilState, 1 );
 
-            for( auto i = kameras->getArray(); i.set; i++ )
-                i.var->render( renderObj );
+            for( auto i = kameras->getIterator(); i; i++ )
+                i->render( renderObj );
             rend3D = 0;
         }
         // Set the depth stencil state.

Kamera2D.cpp

@@ -123,7 +123,7 @@ float Kamera2D::getZoom()
     return zoom;
 }
 
-Mat3< float > Kamera2D::getMatrix()
+const Mat3< float > &Kamera2D::getMatrix()
 {
     return matrix;
 }

Kamera2D.h

@@ -36,7 +36,7 @@ namespace Framework
         __declspec( dllexport ) Vertex getWorldPosition();
         __declspec( dllexport ) float getRotation();
         __declspec( dllexport ) float getZoom();
-        __declspec( dllexport ) Mat3< float > getMatrix();
+        __declspec( dllexport ) const Mat3< float > &getMatrix();
         __declspec( dllexport ) Kamera2D *getThis();
         __declspec( dllexport ) Kamera2D *release();
     };

Model2D.cpp

@@ -47,29 +47,29 @@ bool Model2DData::istPunktInnen( Vertex p, int polygonId ) const
     if( p < minP || p > maxP || !polygons )
         return 0;
     int num = 0;
-    auto outListP = outList.getArray();
-    for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++, outListP++ )
+    auto outListP = outList.getIterator();
+    for( auto polygon = polygons->getIterator(); polygon; polygon++, num++, outListP++ )
     {
         if( polygonId >= 0 && num != polygonId )
             continue;
-        int anz = polygon->var.vertex->getEintragAnzahl();
+        int anz = polygon._.vertex->getEintragAnzahl();
         bool c = 0;
         int j = anz - 1;
-        for( auto outListPP = outListP.var->getArray(); outListPP.set; outListPP++ )
+        for( auto outListPP = outListP->getIterator(); outListPP; outListPP++ )
         {
-            Punkt out = outListPP.var;
+            Punkt out = outListPP;
             if( out.x < out.y && j > out.x && j < out.y )
                 j = out.x;
             if( out.x > out.y && ( j > out.x || j < out.y ) )
                 j = out.x;
         }
-        auto point = polygon->var.vertex->getArray();
+        auto point = polygon._.vertex->getIterator();
         for( int i = 0; i < anz; i++, point++ )
         {
             bool cont = 0;
-            for( auto outListPP = outListP.var->getArray(); outListPP.set; outListPP++ )
+            for( auto outListPP = outListP->getIterator(); outListPP; outListPP++ )
             {
-                Punkt out = outListPP.var;
+                Punkt out = outListPP;
                 if( out.x < out.y && i > out.x && i < out.y )
                     cont = 1;
                 if( out.x > out.y && ( i > out.x || i < out.y ) )
@@ -77,8 +77,8 @@ bool Model2DData::istPunktInnen( Vertex p, int polygonId ) const
             }
             if( cont )
                 continue;
-            Vertex a = point.var;
-            Vertex b = polygon->var.vertex->get( j );
+            Vertex a = point;
+            Vertex b = polygon._.vertex->get( j );
             if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
                 c = !c;
             j = i;
@@ -403,15 +403,15 @@ void Model2DData::removeModell() // setzt die Vertex daten zur
 bool Model2DData::calcHitPoint( Vertex pos, Vertex dir, const char *polygonName, Vertex &hitpoint, Vertex &moveSpeed, float &rotSpeed ) const
 {
     bool ret = 0;
-    for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
+    for( auto polygon = polygons->getIterator(); polygon; polygon++ )
     {
-        if( polygon->var.name->istGleich( polygonName ) )
+        if( polygon._.name->istGleich( polygonName ) )
         {
-            int anz = polygon->var.vertex->getEintragAnzahl();
+            int anz = polygon._.vertex->getEintragAnzahl();
             for( int i = 0; i < anz; i++ )
             {
-                Vertex a = polygon->var.vertex->get( i );
-                Vertex b = polygon->var.vertex->get( ( i + 1 ) % anz );
+                Vertex a = polygon._.vertex->get( i );
+                Vertex b = polygon._.vertex->get( ( i + 1 ) % anz );
                 b -= a;
                 float offset = 0;
                 if( dir.y != 0 && dir.x != 0 )
@@ -431,9 +431,9 @@ bool Model2DData::calcHitPoint( Vertex pos, Vertex dir, const char *polygonName,
                         Vertex normal = b.CW90().normalize();
                         Vertex kNorm = Vertex( dir ).normalize();
                         moveSpeed = normal * ( normal * kNorm ) * dir.getLength();
-                        normal = ( point - *polygon->var.schwerpunkt ).CW90().normalize();
+                        normal = ( point - *polygon._.schwerpunkt ).CW90().normalize();
                         Vertex rotKraft = normal * ( normal * kNorm ) * dir.getLength();
-                        rotSpeed = ( (float)sqrt( rotKraft.getLength() * ( point - *polygon->var.schwerpunkt ).getLength() ) / 180.f ) * 3.14f * ( normal * kNorm );
+                        rotSpeed = ( (float)sqrt( rotKraft.getLength() * ( point - *polygon._.schwerpunkt ).getLength() ) / 180.f ) * 3.14f * ( normal * kNorm );
                         hitpoint = point;
                         ret = 1;
                     }
@@ -449,15 +449,15 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
     Vertex originalDir = dir;
     bool ret = 0;
     int num = 0;
-    for( auto *polygon = &polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    for( auto polygon = polygons->getIterator(); polygon; polygon++, num++ )
     {
-        if( polygon->var.name->istGleich( polygonName ) )
+        if( polygon._.name->istGleich( polygonName ) )
         {
             while( istPunktInnen( pos, num ) )
             {
                 pos -= dir;
             }
-            int anz = polygon->var.vertex->getEintragAnzahl();
+            int anz = polygon._.vertex->getEintragAnzahl();
             Vertex startPoint;
             Vertex texturSP;
             int leftI = 0;
@@ -465,13 +465,13 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
             Vertex txtChpPix( 0, 0 );
             for( int i = 0; i < anz; i++ )
             {
-                Vertex a = polygon->var.vertex->get( i );
-                Vertex b = polygon->var.vertex->get( ( i + 1 ) % anz );
+                Vertex a = polygon._.vertex->get( i );
+                Vertex b = polygon._.vertex->get( ( i + 1 ) % anz );
                 b -= a;
                 if( ( txtChpPix.x == 0 || txtChpPix.y == 0 ) && b.x != 0 && b.y != 0 )
                 {
-                    Vertex ta = polygon->var.tKordinaten->get( i );
-                    Vertex tb = polygon->var.tKordinaten->get( ( i + 1 ) % anz );
+                    Vertex ta = polygon._.tKordinaten->get( i );
+                    Vertex tb = polygon._.tKordinaten->get( ( i + 1 ) % anz );
                     tb -= ta;
                     txtChpPix = Vertex( tb.x / b.x, tb.y / b.y );
                 }
@@ -490,22 +490,22 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
                         leftI = i;
                         rightI = ( i + 1 ) % anz;
                         startPoint = point;
-                        texturSP = polygon->var.tKordinaten->get( i ) + ( polygon->var.tKordinaten->get( ( i + 1 ) % anz ) - polygon->var.tKordinaten->get( i ) ) * offset;
+                        texturSP = polygon._.tKordinaten->get( i ) + ( polygon._.tKordinaten->get( ( i + 1 ) % anz ) - polygon._.tKordinaten->get( i ) ) * offset;
                     }
                     ret = 1;
                 }
             }
             if( ret )
             {
-                partA.transparent = polygon->var.transparent;
+                partA.transparent = polygon._.transparent;
                 partA.schwerpunkt = new Vertex( 0, 0 );
                 partA.tKordinaten = new Array< Vertex >();
-                partA.name = new Text( polygon->var.name->getText() );
+                partA.name = new Text( polygon._.name->getText() );
                 partA.vertex = new Array< Vertex >();
-                partB.transparent = polygon->var.transparent;
+                partB.transparent = polygon._.transparent;
                 partB.schwerpunkt = new Vertex( 0, 0 );
                 partB.tKordinaten = new Array< Vertex >();
-                partB.name = new Text( polygon->var.name->getText() );
+                partB.name = new Text( polygon._.name->getText() );
                 partB.vertex = new Array< Vertex >();
                 *partA.schwerpunkt += startPoint;
                 *partB.schwerpunkt += startPoint;
@@ -529,8 +529,8 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
                     {
                         if( i == leftI )
                             continue;
-                        Vertex a = polygon->var.vertex->get( i );
-                        Vertex b = polygon->var.vertex->get( ( i + 1 ) % anz );
+                        Vertex a = polygon._.vertex->get( i );
+                        Vertex b = polygon._.vertex->get( ( i + 1 ) % anz );
                         b -= a;
                         float offset1 = 0;
                         if( dir.y != 0 && dir.x != 0 )
@@ -558,20 +558,20 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
                                 leftIE = i;
                                 rightIE = ( i + 1 ) % anz;
                                 startPoint = point;
-                                texturSP = polygon->var.tKordinaten->get( i ) + ( polygon->var.tKordinaten->get( ( i + 1 ) % anz ) - polygon->var.tKordinaten->get( i ) ) * offset1;
+                                texturSP = polygon._.tKordinaten->get( i ) + ( polygon._.tKordinaten->get( ( i + 1 ) % anz ) - polygon._.tKordinaten->get( i ) ) * offset1;
                             }
                             ret = 1;
                         }
                     }
                     if( needOne && !ret )
                     {
-                        Vertex a = polygon->var.vertex->get( bestI );
-                        Vertex b = polygon->var.vertex->get( ( bestI + 1 ) % anz );
+                        Vertex a = polygon._.vertex->get( bestI );
+                        Vertex b = polygon._.vertex->get( ( bestI + 1 ) % anz );
                         b -= a;
                         leftIE = bestI;
                         rightIE = ( bestI + 1 ) % anz;
                         startPoint = a + ( b * bo1 );
-                        texturSP = polygon->var.tKordinaten->get( bestI ) + ( polygon->var.tKordinaten->get( ( bestI + 1 ) % anz ) - polygon->var.tKordinaten->get( bestI ) ) * bo1;
+                        texturSP = polygon._.tKordinaten->get( bestI ) + ( polygon._.tKordinaten->get( ( bestI + 1 ) % anz ) - polygon._.tKordinaten->get( bestI ) ) * bo1;
                         ret = 1;
                     }
                     if( ret )
@@ -584,7 +584,7 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
                     partB.tKordinaten->add( nextT );
                     startPoint = next;
                     texturSP = nextT;
-                    dir = originalDir.rotation( (float)(random() - 0.5) );
+                    dir = originalDir.rotation( (float)( random() - 0.5 ) );
                 }
                 *partA.schwerpunkt += startPoint;
                 *partB.schwerpunkt += startPoint;
@@ -597,26 +597,26 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
                     i = i % anz;
                     if( i == leftI )
                         break;
-                    *partA.schwerpunkt += polygon->var.vertex->get( i );
-                    partA.vertex->add( polygon->var.vertex->get( i ) );
-                    partA.tKordinaten->add( polygon->var.tKordinaten->get( i ) );
+                    *partA.schwerpunkt += polygon._.vertex->get( i );
+                    partA.vertex->add( polygon._.vertex->get( i ) );
+                    partA.tKordinaten->add( polygon._.tKordinaten->get( i ) );
                 }
-                *partA.schwerpunkt += polygon->var.vertex->get( leftI );
-                partA.vertex->add( polygon->var.vertex->get( leftI ) );
-                partA.tKordinaten->add( polygon->var.tKordinaten->get( leftI ) );
+                *partA.schwerpunkt += polygon._.vertex->get( leftI );
+                partA.vertex->add( polygon._.vertex->get( leftI ) );
+                partA.tKordinaten->add( polygon._.tKordinaten->get( leftI ) );
                 for( int i = leftIE; i != rightI; i-- )
                 {
                     if( i < 0 )
                         i += anz;
                     if( i == rightI )
                         break;
-                    *partB.schwerpunkt += polygon->var.vertex->get( i );
-                    partB.vertex->add( polygon->var.vertex->get( i ) );
-                    partB.tKordinaten->add( polygon->var.tKordinaten->get( i ) );
+                    *partB.schwerpunkt += polygon._.vertex->get( i );
+                    partB.vertex->add( polygon._.vertex->get( i ) );
+                    partB.tKordinaten->add( polygon._.tKordinaten->get( i ) );
                 }
-                *partB.schwerpunkt += polygon->var.vertex->get( rightI );
-                partB.vertex->add( polygon->var.vertex->get( rightI ) );
-                partB.tKordinaten->add( polygon->var.tKordinaten->get( rightI ) );
+                *partB.schwerpunkt += polygon._.vertex->get( rightI );
+                partB.vertex->add( polygon._.vertex->get( rightI ) );
+                partB.tKordinaten->add( polygon._.tKordinaten->get( rightI ) );
                 *partA.schwerpunkt /= (float)partA.vertex->getEintragAnzahl();
                 *partB.schwerpunkt /= (float)partB.vertex->getEintragAnzahl();
                 posA = (Punkt)*partA.schwerpunkt;
@@ -636,20 +636,20 @@ bool Model2DData::split( Vertex pos, Vertex dir, char *polygonName, Polygon2D &p
 float Model2DData::getMasse() const
 {
     float m = 0;
-    for( auto p = polygons->getArray(); p.set; p++ )
+    for( auto p = polygons->getIterator(); p; p++ )
     {
-        if( p.var.transparent )
+        if( p._.transparent )
             continue;
-        int anz = p.var.vertex->getEintragAnzahl();
+        int anz = p._.vertex->getEintragAnzahl();
         if( anz < 3 )
             continue;
-        Vertex p1 = p.var.vertex->get( anz - 1 );
-        Vertex p2 = p.var.vertex->get( 0 );
+        Vertex p1 = p._.vertex->get( anz - 1 );
+        Vertex p2 = p._.vertex->get( 0 );
         m += ( p1.y + p2.y ) * ( p1.x - p2.x );
         for( int i = 1; i < anz; i++ )
         {
-            p1 = p.var.vertex->get( i - 1 );
-            p2 = p.var.vertex->get( i );
+            p1 = p._.vertex->get( i - 1 );
+            p2 = p._.vertex->get( i );
             m += ( p1.y + p2.y ) * ( p1.x - p2.x );
         }
     }
@@ -705,7 +705,7 @@ void Model2DObject::setTextur( Textur2D *t )
     int index = 0;
     if( rData )
     {
-        for( auto i = rData->polygons->getArray(); i.set; i++ )
+        for( auto i = rData->polygons->getIterator(); i; i++ )
             textur->set( t->getThis(), index++ );
     }
     t->release();
@@ -723,9 +723,9 @@ void Model2DObject::impuls( Vertex start, Vertex speed )
         Vertex mSpeed;
         float rSpeed;
         float dist = INFINITY;
-        for( auto p = rData->polygons->getArray(); p.set; p++ )
+        for( auto p = rData->polygons->getIterator(); p; p++ )
         {
-            if( !p.var.transparent && rData->calcHitPoint( start, speed, p.var.name->getText(), hp, mSpeed, rSpeed ) )
+            if( !p._.transparent && rData->calcHitPoint( start, speed, p._.name->getText(), hp, mSpeed, rSpeed ) )
             {
                 float f = ( hp.x - start.x ) / speed.x;
                 if( !speed.x )
@@ -750,9 +750,9 @@ void Model2DObject::impuls( Vertex start, Vertex speed )
 void Model2DObject::setTextur( Textur2D *t, const char *polygonName )
 {
     int index = 0;
-    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    for( auto i = rData->polygons->getIterator(); i; i++, index++ )
     {
-        if( i.var.name->istGleich( polygonName ) )
+        if( i._.name->istGleich( polygonName ) )
             textur->set( t->getThis(), index );
     }
     t->release();
@@ -763,29 +763,29 @@ void Model2DObject::render( Mat3< float > &kamMat, Bild &zRObj )
     if( !rData || !rData->polygons || !textur )
         return;
     int num = 0;
-    for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
+    for( auto p = rData->vListen->getIterator(); p; p++, num++ )
     {
         Mat3< float > mat = kamMat * getObjectMatrix();
         if( textur->z( num ) )
         {
             Bild *txt = textur->z( num )->zTextur();
-            for( auto *i = &p->var->getArray(); i && i->set && txt; i = i->next )
+            for( auto i = p->getIterator(); i && txt; i++ )
             {
-                for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                for( auto j = i->zListe()->getIterator(); j.hasNext() && j.next().hasNext(); j++ )
                 {
-                    Vertex a = mat * *j->var->punkt;
-                    Vertex b = mat * *j->next->var->punkt;
-                    Vertex c = mat * *j->next->next->var->punkt;
-                    Punkt ta = (Punkt)Vertex( j->var->textur->x * (float)txt->getBreite(), j->var->textur->y * (float)txt->getHeight() );
-                    Punkt tb = (Punkt)Vertex( j->next->var->textur->x * (float)txt->getBreite(), j->next->var->textur->y * (float)txt->getHeight() );
-                    Punkt tc = (Punkt)Vertex( j->next->next->var->textur->x * (float)txt->getBreite(), j->next->next->var->textur->y * (float)txt->getHeight() );
+                    Vertex a = mat * *j->punkt;
+                    Vertex b = mat * *j.next()->punkt;
+                    Vertex c = mat * *j.next().next()->punkt;
+                    Punkt ta = (Punkt)Vertex( j->textur->x * (float)txt->getBreite(), j->textur->y * (float)txt->getHeight() );
+                    Punkt tb = (Punkt)Vertex( j.next()->textur->x * (float)txt->getBreite(), j.next()->textur->y * (float)txt->getHeight() );
+                    Punkt tc = (Punkt)Vertex( j.next().next()->textur->x * (float)txt->getBreite(), j.next().next()->textur->y * (float)txt->getHeight() );
                     zRObj.drawDreieckTexturAlpha( a, b, c, ta, tb, tc, *txt );
                 }
             }
         }
     }
     /* Draws 2D Mesh
-    for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
+    for( auto *p = &rData->vListen->getIterator(); p && p->set; p = p->next, num++ )
     {
         Mat3< float > mat = kamMat * getObjectMatrix();
         for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
@@ -815,19 +815,19 @@ bool Model2DObject::istPunktInnen( Vertex p ) const
     int num = 0;
     Mat3< float > mat = Mat3< float >::rotation( -rotation ) * Mat3< float >::scaling( 1 / size );
     p = mat * p;
-    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    for( auto polygon = rData->polygons->getIterator(); polygon; polygon++, num++ )
     {
-        if( polygon->var.transparent )
+        if( polygon._.transparent )
             continue;
         bool c = 0;
-        for( auto point = polygon->var.vertex->getArray(); point.set; point++ )
+        for( auto point = polygon._.vertex->getIterator(); point; point++ )
         {
             Vertex a;
-            if( point.next )
-                a = point.next->var;
+            if( point.next() )
+                a = point.next();
             else
-                a = polygon->var.vertex->get( 0 );
-            Vertex b = point.var;
+                a = polygon._.vertex->get( 0 );
+            Vertex b = point;
             if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
                 c = !c;
         }
@@ -890,17 +890,17 @@ bool Model2DObject::istModelInnen( const Object2D *zObj, Vertex *sp, bool end )
             return 0;
     }
     Mat3< float > mat = getObjectMatrix();
-    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
+    for( auto polygon = rData->polygons->getIterator(); polygon; polygon++ )
     {
-        if( polygon->var.transparent )
+        if( polygon._.transparent )
             continue;
-        int anz = polygon->var.vertex->getEintragAnzahl();
+        int anz = polygon._.vertex->getEintragAnzahl();
         for( int i = 0; i < anz; i++ )
         {
-            if( zObj->istPunktInnen( mat * polygon->var.vertex->get( i ) ) )
+            if( zObj->istPunktInnen( mat * polygon._.vertex->get( i ) ) )
             {
                 if( sp )
-                    *sp = mat * polygon->var.vertex->get( i );
+                    *sp = mat * polygon._.vertex->get( i );
                 return 1;
             }
         }
@@ -927,9 +927,9 @@ bool Model2DObject::calcHitPoint( Vertex pos, Vertex dir, Vertex &hitpoint ) con
     float dist = INFINITY;
     if( rData )
     {
-        for( auto p = rData->polygons->getArray(); p.set; p++ )
+        for( auto p = rData->polygons->getIterator(); p; p++ )
         {
-            if( !p.var.transparent && rData->calcHitPoint( pos, dir, p.var.name->getText(), hp, ms, rs ) )
+            if( !p._.transparent && rData->calcHitPoint( pos, dir, p._.name->getText(), hp, ms, rs ) )
             {
                 float f = ( hp.x - pos.x ) / dir.x;
                 if( !speed.x )
@@ -960,13 +960,13 @@ float Model2DObject::getLuftWiederstand() const
     Mat3< float > m = Mat3< float >::rotation( rotation + faktor * angle ) * Mat3< float >::scaling( size );
     float yMin = INFINITY;
     float yMax = -INFINITY;
-    for( auto p = rData->polygons->getArray(); p.set; p++ )
+    for( auto p = rData->polygons->getIterator(); p; p++ )
     {
-        if( p.var.transparent )
+        if( p._.transparent )
             continue;
-        for( auto point = p.var.vertex->getArray(); point.set; point++ )
+        for( auto point = p._.vertex->getIterator(); point; point++ )
         {
-            Vertex v = m * point.var;
+            Vertex v = m * point._;
             if( v.y > yMax )
                 yMax = v.y;
             if( v.y < yMin )
@@ -998,9 +998,9 @@ Textur2D *Model2DObject::getTextur() const
 Textur2D *Model2DObject::getTextur( const char *polygonName ) const
 {
     int index = 0;
-    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    for( auto i = rData->polygons->getIterator(); i; i++, index++ )
     {
-        if( i.var.name->istGleich( polygonName ) )
+        if( i._.name->istGleich( polygonName ) )
             return textur->get( index );
     }
     return 0;
@@ -1017,9 +1017,9 @@ Textur2D *Model2DObject::zTextur() const
 Textur2D *Model2DObject::zTextur( const char *polygonName ) const
 {
     int index = 0;
-    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    for( auto i = rData->polygons->getIterator(); i; i++, index++ )
     {
-        if( i.var.name->istGleich( polygonName ) )
+        if( i._.name->istGleich( polygonName ) )
             return textur->z( index );
     }
     return 0;
@@ -1104,7 +1104,7 @@ void Model2D::setTextur( Textur2D *t )
     int index = 0;
     if( rData )
     {
-        for( auto i = rData->polygons->getArray(); i.set; i++ )
+        for( auto i = rData->polygons->getIterator(); i; i++ )
             textur->set( t->getThis(), index++ );
     }
     t->release();
@@ -1113,9 +1113,9 @@ void Model2D::setTextur( Textur2D *t )
 void Model2D::setTextur( Textur2D *t, const char *polygonName )
 {
     int index = 0;
-    for( auto i = rData->polygons->getArray(); i.set; i++, index++ )
+    for( auto i = rData->polygons->getIterator(); i; i++, index++ )
     {
-        if( i.var.name->istGleich( polygonName ) )
+        if( i._.name->istGleich( polygonName ) )
             textur->set( t->getThis(), index );
     }
     t->release();
@@ -1152,20 +1152,20 @@ void Model2D::render( Bild &zRObj )
         return;
     Zeichnung::render( zRObj );
     int num = 0;
-    for( auto *p = &rData->vListen->getArray(); p && p->set; p = p->next, num++ )
+    for( auto p = rData->vListen->getIterator(); p; p++, num++ )
     {
         Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
         if( hatStyle( Model2D::Style::Textur ) )
         {
             if( !textur || !textur->z( num ) || !textur->z( num )->zTextur() || !rData->polygons->get( num ).tKordinaten )
             {
-                for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+                for( auto i = p->getIterator(); i; i++ )
                 {
-                    for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                    for( auto j = i->zListe()->getIterator(); j.hasNext() && j.next().hasNext(); j++ )
                     {
-                        Vertex a = mat * *j->var->punkt;
-                        Vertex b = mat * *j->next->var->punkt;
-                        Vertex c = mat * *j->next->next->var->punkt;
+                        Vertex a = mat * *j->punkt;
+                        Vertex b = mat * *j.next()->punkt;
+                        Vertex c = mat * *j.next().next()->punkt;
                         if( hatStyle( Model2D::Style::Alpha ) )
                             zRObj.drawDreieckAlpha( a, b, c, farbe );
                         else
@@ -1176,16 +1176,16 @@ void Model2D::render( Bild &zRObj )
             else
             {
                 Bild *txt = textur->z( num )->zTextur();
-                for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+                for( auto i = p->getIterator(); i; i++ )
                 {
-                    for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                    for( auto j = i->zListe()->getIterator(); j.hasNext() && j.next().hasNext(); j++ )
                     {
-                        Vertex a = mat * *j->var->punkt;
-                        Vertex b = mat * *j->next->var->punkt;
-                        Vertex c = mat * *j->next->next->var->punkt;
-                        Punkt ta = (Punkt)Vertex( j->var->textur->x * (float)txt->getBreite(), j->var->textur->y * (float)txt->getHeight() );
-                        Punkt tb = (Punkt)Vertex( j->next->var->textur->x * (float)txt->getBreite(), j->next->var->textur->y * (float)txt->getHeight() );
-                        Punkt tc = (Punkt)Vertex( j->next->next->var->textur->x * (float)txt->getBreite(), j->next->next->var->textur->y * (float)txt->getHeight() );
+                        Vertex a = mat * *j->punkt;
+                        Vertex b = mat * *j.next()->punkt;
+                        Vertex c = mat * *j.next().next()->punkt;
+                        Punkt ta = (Punkt)Vertex( j->textur->x * (float)txt->getBreite(), j->textur->y * (float)txt->getHeight() );
+                        Punkt tb = (Punkt)Vertex( j.next()->textur->x * (float)txt->getBreite(), j.next()->textur->y * (float)txt->getHeight() );
+                        Punkt tc = (Punkt)Vertex( j.next().next()->textur->x * (float)txt->getBreite(), j.next().next()->textur->y * (float)txt->getHeight() );
                         if( hatStyle( Model2D::Style::Alpha ) )
                             zRObj.drawDreieckTexturAlpha( a, b, c, ta, tb, tc, *txt );
                         else
@@ -1196,13 +1196,13 @@ void Model2D::render( Bild &zRObj )
         }
         if( hatStyle( Model2D::Style::Mesh ) )
         {
-            for( auto *i = &p->var->getArray(); i && i->set; i = i->next )
+            for( auto i = p->getIterator(); i; i++ )
             {
-                for( auto *j = &i->var->zListe()->getArray(); j->next->next && j->next->next->set; j = j->next )
+                for( auto j = i->zListe()->getIterator(); j.hasNext() && j.next().hasNext(); j++ )
                 {
-                    Vertex a = mat * *j->var->punkt;
-                    Vertex b = mat * *j->next->var->punkt;
-                    Vertex c = mat * *j->next->next->var->punkt;
+                    Vertex a = mat * *j->punkt;
+                    Vertex b = mat * *j.next()->punkt;
+                    Vertex c = mat * *j.next().next()->punkt;
                     if( hatStyle( Model2D::Style::Alpha ) )
                     {
                         zRObj.drawLinieAlpha( a, b, farbe );
@@ -1220,24 +1220,24 @@ void Model2D::render( Bild &zRObj )
         }
         if( hatStyle( Model2D::Style::Rahmen ) )
         {
-            ArrayEintrag< Vertex > &beg = rData->polygons->get( num ).vertex->getArray();
-            if( beg.set )
+            auto beg = rData->polygons->get( num ).vertex->getIterator();
+            if( beg )
             {
-                ArrayEintrag< Vertex > *letzter = 0;
-                for( ArrayEintrag< Vertex > *e = &beg; e && e->next && e->set && e->next->set; e = e->next )
+                Vertex letzter;
+                for( auto e = beg; e && e.hasNext(); e++ )
                 {
                     if( hatStyle( Model2D::Style::Alpha ) )
-                        zRObj.drawLinieAlpha( mat * e->var, mat * e->next->var, farbe );
+                        zRObj.drawLinieAlpha( mat * e._, mat * e.next()._, farbe );
                     else
-                        zRObj.drawLinie( mat * e->var, mat * e->next->var, farbe );
-                    letzter = e->next;
+                        zRObj.drawLinie( mat * e._, mat * e.next()._, farbe );
+                    letzter = e.next();
                 }
-                if( letzter && letzter->set )
+                if( beg.hasNext() )
                 {
                     if( hatStyle( Model2D::Style::Alpha ) )
-                        zRObj.drawLinieAlpha( mat * letzter->var, mat * beg.var, farbe );
+                        zRObj.drawLinieAlpha( mat * letzter, mat * beg._, farbe );
                     else
-                        zRObj.drawLinie( mat * letzter->var, mat * beg.var, farbe );
+                        zRObj.drawLinie( mat * letzter, mat * beg._, farbe );
                 }
             }
         }
@@ -1263,18 +1263,18 @@ bool Model2D::istPunktInnen( Vertex p ) const
     if( p < Mat3< float >::scaling( size ) * rData->minP || p > Mat3< float >::scaling( size ) * rData->maxP || !rData->polygons )
         return 0;
     int num = 0;
-    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next, num++ )
+    for( auto polygon = rData->polygons->getIterator(); polygon; polygon++, num++ )
     {
-        if( polygon->var.transparent )
+        if( polygon._.transparent )
             continue;
         Mat3< float > mat = Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
-        int anz = polygon->var.vertex->getEintragAnzahl();
+        int anz = polygon._.vertex->getEintragAnzahl();
         bool c = 0;
         int j = anz - 1;
         for( int i = 0; i < anz; i++ )
         {
-            Vertex a = mat * polygon->var.vertex->get( i );
-            Vertex b = mat * polygon->var.vertex->get( j );
+            Vertex a = mat * polygon._.vertex->get( i );
+            Vertex b = mat * polygon._.vertex->get( j );
             if( ( ( a.y >= p.y ) != ( b.y >= p.y ) ) && ( p.x <= ( b.x - a.x ) * ( p.y - a.y ) / (float)( b.y - a.y ) + a.x ) )
                 c = !c;
             j = i;
@@ -1342,14 +1342,14 @@ bool Model2D::istModelInnen( const Model2D *zMdl, bool end ) const
             return 0;
     }
     Mat3< float > mat = Mat3< float >::translation( pos ) * Mat3< float >::rotation( drehung ) * Mat3< float >::scaling( size );
-    for( auto *polygon = &rData->polygons->getArray(); polygon && polygon->set; polygon = polygon->next )
+    for( auto polygon = rData->polygons->getIterator(); polygon; polygon++ )
     {
-        if( polygon->var.transparent )
+        if( polygon._.transparent )
             continue;
-        int anz = polygon->var.vertex->getEintragAnzahl();
+        int anz = polygon._.vertex->getEintragAnzahl();
         for( int i = 0; i < anz; i++ )
         {
-            if( zMdl->istPunktInnen( mat * polygon->var.vertex->get( i ) ) )
+            if( zMdl->istPunktInnen( mat * polygon._.vertex->get( i ) ) )
                 return 1;
         }
     }

Model3D.cpp

@@ -271,8 +271,8 @@ void Model3DData::clearModel()
 {
     delete[] vertexList;
     vertexList = 0;
-    for( auto i = polygons->getArray(); i.set; i++ )
-        delete i.var;
+    for( auto i = polygons->getIterator(); i; i++ )
+        delete i;
     polygons->leeren();
     if( skelett )
         skelett->release();
@@ -323,32 +323,32 @@ void Model3DData::copyModel2D( Model2DData *model, float z )
     {
         clearModel();
         int vAnz = 0;
-        for( auto i = model->polygons->getArray(); i.set; i++ )
-            vAnz += i.var.vertex->getEintragAnzahl();
+        for( auto i = model->polygons->getIterator(); i; i++ )
+            vAnz += i._.vertex->getEintragAnzahl();
         vertexList = new Vertex3D[ vAnz ];
         vertexBuffer->setData( vertexList );
         vertexBuffer->setLength( (int)sizeof( Vertex3D ) * vAnz );
         int index = 0;
-        for( auto i = model->vListen->getArray(); i.set; i++ )
+        for( auto i = model->vListen->getIterator(); i; i++ )
         {
             Polygon3D *p = new Polygon3D();
             p->indexAnz = 0;
-            for( auto j = i.var->getArray(); j.set; j++ )
+            for( auto j = i->getIterator(); j; j++ )
             {
-                for( auto *k = &j.var->zListe()->getArray(); k->next->next && k->next->next->set; k = k->next )
+                for( auto k = j->zListe()->getIterator(); k.hasNext() && k.next().hasNext(); k++ )
                     p->indexAnz += 3;
             }
             p->indexList = new int[ p->indexAnz ];
             p->indexBuffer->setData( p->indexList );
             p->indexBuffer->setLength( (int)sizeof( int ) * p->indexAnz );
             p->indexAnz = 0;
-            for( auto j = i.var->getArray(); j.set; j++ )
+            for( auto j = i->getIterator(); j; j++ )
             {
-                for( auto *k = &j.var->zListe()->getArray(); k && k->set; k = k->next )
+                for( auto k = j->zListe()->getIterator(); k; k++ )
                 {
-                    vertexList[ index ].pos = Vec3< float >( k->var->punkt->x, k->var->punkt->y, z );
-                    vertexList[ index ].tPos = ( Vec2< float > )*k->var->textur;
-                    if( k->next && k->next->set && k->next->next && k->next->next->set )
+                    vertexList[ index ].pos = Vec3< float >( k->punkt->x, k->punkt->y, z );
+                    vertexList[ index ].tPos = ( Vec2< float > )*k->textur;
+                    if( k.hasNext() && k.next().hasNext() )
                     {
                         p->indexList[ p->indexAnz ] = index;
                         p->indexAnz++;
@@ -401,14 +401,14 @@ int Model3DData::kalkulateMatrix( Mat4< float > &modelMatrix, Mat4< float > *mat
 void Model3DData::render( Mat4< float > &welt, const Model3DTextur *zTxt, Render3D *zRObj )
 {
     int ind = 0;
-    for( auto *i = &polygons->getArray(); i && i->set; i = i->next )
+    for( auto i = polygons->getIterator(); i; i++ )
     {
-        i->var->indexBuffer->copieren( zRObj );
+        i->indexBuffer->copieren( zRObj );
         Textur *t = zTxt->zPolygonTextur( ind );
         if( t && t->brauchtUpdate() )
             t->updateTextur( zRObj );
 #ifdef WIN32
-        zRObj->draw( i->var->indexBuffer, t );
+        zRObj->draw( i->indexBuffer, t );
 #endif
         ind++;
     }
@@ -628,10 +628,10 @@ bool Model3D::tick( double tickval )
     if( skelett )
     {
         radius += skelett->getRadius();
-        for( auto i = animations->getArray(); i.set && i.var; i++ )
+        for( auto i = animations->getIterator(); i && i._; i++ )
         {
-            rend = i.var->speed > 0;
-            i.var->a->apply( skelett, i.var->offset, tickval * i.var->speed );
+            rend = i->speed > 0;
+            i->a->apply( skelett, i->offset, tickval * i->speed );
         }
     }
     return Zeichnung3D::tick( tickval );

Model3DList.cpp

@@ -31,9 +31,9 @@ Model3DList::~Model3DList()
 bool Model3DList::addModel( Model3DData *mdl, const char *name )
 {
     cs.lock();
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             mdl->release();
             cs.unlock();
@@ -53,9 +53,9 @@ void Model3DList::removeModel( const char *name )
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             names->remove( index );
             models->remove( index );
@@ -73,9 +73,9 @@ void Model3DList::removeModel( const char *name )
 bool Model3DList::hatModel( const char *name ) const
 {
     cs.lock();
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return 1;
@@ -91,9 +91,9 @@ Model3DData *Model3DList::getModel( const char *name ) const
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return models->get( index );
@@ -110,9 +110,9 @@ Model3DData *Model3DList::zModel( const char *name ) const
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return models->z( index );

Textur2D.cpp

@@ -20,10 +20,10 @@ Textur2D::~Textur2D()
 {
     if( txt )
         txt->release();
-    for( auto i = animData->getArray(); i.set; i++ )
+    for( auto i = animData->getIterator(); i; i++ )
     {
-        i.var->data->release();
-        delete i.var;
+        i->data->release();
+        delete i;
     }
     animData->release();
 }

TexturList.cpp

@@ -38,9 +38,9 @@ __declspec( dllexport ) void TexturList::leeren()
 bool TexturList::addTextur( Textur *t, const char *name )
 {
     cs.lock();
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             t->release();
             cs.unlock();
@@ -60,9 +60,9 @@ void TexturList::removeTextur( const char *name )
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             names->remove( index );
             textures->remove( index );
@@ -80,9 +80,9 @@ void TexturList::removeTextur( const char *name )
 bool TexturList::hatTextur( const char *name ) const
 {
     cs.lock();
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return 1;
@@ -98,9 +98,9 @@ Textur *TexturList::getTextur( const char *name ) const
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return textures->get( index );
@@ -116,12 +116,12 @@ Textur *TexturList::getTextur( const char *name ) const
 Textur *TexturList::getTextur( int id ) const
 {
     cs.lock();
-    for( auto i = textures->getArray(); i.set; i++ )
+    for( auto i = textures->getIterator(); i; i++ )
     {
-        if( i.var->getId() == id )
+        if( i->getId() == id )
         {
             cs.unlock();
-            return i.var->getThis();
+            return i->getThis();
         }
     }
     cs.unlock();
@@ -134,9 +134,9 @@ Textur *TexturList::zTextur( const char *name ) const
 {
     cs.lock();
     int index = 0;
-    for( auto i = names->getArray(); i.set; i++ )
+    for( auto i = names->getIterator(); i; i++ )
     {
-        if( i.var->istGleich( name ) )
+        if( i->istGleich( name ) )
         {
             cs.unlock();
             return textures->z( index );
@@ -152,12 +152,12 @@ Textur *TexturList::zTextur( const char *name ) const
 Textur *TexturList::zTextur( int id ) const
 {
     cs.lock();
-    for( auto i = textures->getArray(); i.set; i++ )
+    for( auto i = textures->getIterator(); i; i++ )
     {
-        if( i.var->getId() == id )
+        if( i->getId() == id )
         {
             cs.unlock();
-            return i.var;
+            return i;
         }
     }
     cs.unlock();

Thread.cpp

@@ -215,12 +215,12 @@ void ThreadRegister::addClosedThread( pthread_t handle )
 Thread *ThreadRegister::zThread( pthread_t handle )
 {
     EnterCriticalSection( &cs );
-    for( auto i = threads.getArray(); i.set; i++ )
+    for( auto i = threads.getIterator(); i; i++ )
     {
-        if( i.var->getThreadHandle() && GetThreadId( i.var->getThreadHandle() ) == GetThreadId( handle ) )
+        if( i->getThreadHandle() && GetThreadId( i->getThreadHandle() ) == GetThreadId( handle ) )
         {
             LeaveCriticalSection( &cs );
-            return i.var;
+            return i;
         }
     }
     LeaveCriticalSection( &cs );

Welt2D.cpp

@@ -297,7 +297,7 @@ void Welt2D::removeAll()
 void Welt2D::explosion( Vertex worldPos, float intensity, float maxRad )
 {
     maxRad = maxRad * maxRad;
-    for( auto obj = objects->getArray(); obj.set; obj++ )
+    for( auto obj = objects->getIterator(); obj; obj++ )
     {
         if( info.circular && info.hasSize && info.size.x && info.size.y )
         {
@@ -315,18 +315,18 @@ void Welt2D::explosion( Vertex worldPos, float intensity, float maxRad )
             float minDist = INFINITY;
             for( Vertex p : offsets )
             {
-                float dist = ( obj.var->getPosition() - (worldPos - p) ).getLengthSq();
+                float dist = ( obj->getPosition() - (worldPos - p) ).getLengthSq();
                 if( dist < minDist )
                 {
                     minDist = dist;
                     offset = p;
                 }
             }
-            if( ( obj.var->getPosition() - (worldPos - offset) ).getLengthSq() < maxRad )
-                obj.var->explosion( worldPos - offset, intensity );
+            if( ( obj->getPosition() - (worldPos - offset) ).getLengthSq() < maxRad )
+                obj->explosion( worldPos - offset, intensity );
         }
-        else if( ( obj.var->getPosition() - worldPos ).getLengthSq() < maxRad )
-            obj.var->explosion( worldPos, intensity );
+        else if( ( obj->getPosition() - worldPos ).getLengthSq() < maxRad )
+            obj->explosion( worldPos, intensity );
     }
 }
 
@@ -335,14 +335,14 @@ void Welt2D::impuls( Vertex worldPos, Vertex worldDir )
     Vertex hitPoint;
     float dist = INFINITY;
     Object2D *o = 0;
-    for( auto obj = objects->getArray(); obj.set; obj++ )
+    for( auto obj = objects->getIterator(); obj; obj++ )
     {
-        if( obj.var->calcHitPoint( worldPos, worldDir, hitPoint ) )
+        if( obj->calcHitPoint( worldPos, worldDir, hitPoint ) )
         {
             if( ( hitPoint - worldPos ).getLengthSq() < dist )
             {
                 dist = ( hitPoint - worldPos ).getLengthSq();
-                o = obj.var;
+                o = obj;
             }
         }
     }
@@ -353,23 +353,23 @@ void Welt2D::impuls( Vertex worldPos, Vertex worldDir )
 bool Welt2D::tick( double zeit )
 {
     bool ret = 0;
-    for( auto obj = objects->getArray(); obj.set; obj++ )
+    for( auto obj = objects->getIterator(); obj; obj++ )
     {
-        if( obj.next )
+        if( obj.hasNext() )
         {
-            for( auto obj2 = *obj.next; obj2.set; obj2++ )
-                obj.var->handleCollision( obj2 );
+            for( auto obj2 = obj.next(); obj2; obj2++ )
+                obj->handleCollision( obj2 );
         }
-        ret |= obj.var->tick( info, zeit );
+        ret |= obj->tick( info, zeit );
     }
     return ret;
 }
 
 void Welt2D::render( Mat3< float > &kamMat, Punkt size, Bild &zRObj, int xOffset, int yOffset )
 {
-    for( auto obj = objects->getArray(); obj.set; obj++ )
+    for( auto obj = objects->getIterator(); obj; obj++ )
     {
-        Rect2< float > bnd = obj.var->getBoundingBox();
+        Rect2< float > bnd = obj->getBoundingBox();
         Vertex topRight = Vertex( bnd.topLeft.y, bnd.bottomRight.x );
         Vertex bottomLeft = Vertex( bnd.topLeft.x, bnd.bottomRight.y );
         Mat3< float > km = kamMat * Mat3<float>::translation( Vertex( (float)xOffset, (float)yOffset ) );
@@ -385,7 +385,7 @@ void Welt2D::render( Mat3< float > &kamMat, Punkt size, Bild &zRObj, int xOffset
             ( topRight.y >= 0 && topRight.y < size.y ) ||
             ( bottomLeft.x >= 0 && bottomLeft.x < size.x ) ||
             ( bottomLeft.y >= 0 && bottomLeft.y < size.y ) )
-            obj.var->render( km, zRObj );
+            obj->render( km, zRObj );
     }
 }
 
@@ -393,9 +393,9 @@ void Welt2D::render( Mat3< float > &kamMat, Punkt size, Bild &zRObj )
 {
     if( !info.hasSize || !info.circular )
     {
-        for( auto obj = objects->getArray(); obj.set; obj++ )
+        for( auto obj = objects->getIterator(); obj; obj++ )
         {
-            Rect2< float > bnd = obj.var->getBoundingBox();
+            Rect2< float > bnd = obj->getBoundingBox();
             Vertex topRight = Vertex( bnd.topLeft.y, bnd.bottomRight.x );
             Vertex bottomLeft = Vertex( bnd.topLeft.x, bnd.bottomRight.y );
             bnd.bottomRight = kamMat * bnd.bottomRight;
@@ -410,7 +410,7 @@ void Welt2D::render( Mat3< float > &kamMat, Punkt size, Bild &zRObj )
                 ( topRight.y >= 0 && topRight.y < size.y ) ||
                 ( bottomLeft.x >= 0 && bottomLeft.x < size.x ) ||
                 ( bottomLeft.y >= 0 && bottomLeft.y < size.y ) )
-                obj.var->render( kamMat, zRObj );
+                obj->render( kamMat, zRObj );
         }
     }
     else if( info.circular )