Weniger code durch besseres Triggersystem

StickmanWorldOnline/Aktionen.cpp

@@ -2,86 +2,139 @@
 #include "Trigger.h"
 #include "Spiel.h"
 
-Aktion::Aktion( AktionTyp typ )
+
+Aktion::Aktion( AktionTyp typ, RCArray< Aktion > *subActions )
     : Variable( AKTION )
 {
+    this->subActions = subActions;
+    for( int i = 0; i < subActions->getEintragAnzahl(); i++ )
+        erlaubteTypen.add( ALLE );
     this->typ = typ;
 }
 
 Aktion::~Aktion()
+{
+    subActions->release();
+}
+
+Variable *Aktion::zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
+{
+    return zMemory->zVariable( zPC->getUniqueString() + "R" + number + "__" );
+}
+
+Variable *Aktion::getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
+{
+    return zMemory->getVariable( zPC->getUniqueString() + "R" + number + "__" );
+}
+
+bool Aktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( waitCount > 0 )
+        return 0;
+    zPC->stepIn();
+    // evaluate parameters
+    for( int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++ )
+    {
+        if( !subActions->z( i )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        {
+            zPC->stepOut();
+            return 0;
+        }
+        Variable *result = zMemory->zVariable( "__return__" );
+        if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || result->getVariableTyp() != erlaubteTypen.get( i ) )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        if( result )
+            zMemory->setVar( zPC->getUniqueString() + "R" + i + "__", result->getThis() );
+        zPC->count();
+        if( waitCount > 0 )
+        {
+            zPC->stepOut();
+            return 0;
+        }
+    }
+    if( zPC->currentPosition() == subActions->getEintragAnzahl() )
+    {
+        // evaluate result
+        run( zSpiel, zEreignis, zMemory, zPC, waitCount );
+        zPC->stepOut();
+        return 1;
+    }
+    zPC->stepOut();
+    return 0;
+}
+
+void Aktion::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {}
 
 
 KonstantNichts::KonstantNichts()
-    : Aktion( KONSTANT_NICHTS )
+    : Aktion( KONSTANT_NICHTS, new RCArray< Aktion >() )
 {}
 
-bool KonstantNichts::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", new Variable( NICHTS ) );
-    return 1;
 }
 
 
 KonstantInteger::KonstantInteger( int val )
-    : Aktion( KONSTANT_INTEGER )
+    : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
 {
     this->value = val;
 }
 
-bool KonstantInteger::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", new Integer( value ) );
-    return 1;
 }
 
 
 KonstantBoolean::KonstantBoolean( bool val )
-    : Aktion( KONSTANT_BOOLEAN )
+    : Aktion( KONSTANT_BOOLEAN, new RCArray< Aktion >() )
 {
     value = val;
 }
 
-bool KonstantBoolean::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", new Boolean( value ) );
-    return 1;
 }
 
 
 KonstantString::KonstantString( Text val )
-    : Aktion( KONSTANT_STRING )
+    : Aktion( KONSTANT_STRING, new RCArray< Aktion >() )
 {
     value = val;
 }
 
-bool KonstantString::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", new String( value ) );
-    return 1;
 }
 
 
 KonstantFloat::KonstantFloat( float val )
-    : Aktion( KONSTANT_FLOAT )
+    : Aktion( KONSTANT_FLOAT, new RCArray< Aktion >() )
 {
     value = val;
 }
 
-bool KonstantFloat::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", new Float( value ) );
-    return 1;
 }
 
 
 KonstantVariable::KonstantVariable( Text name )
-    : Aktion( KONSTANT_VARIABLE )
+    : Aktion( KONSTANT_VARIABLE, new RCArray< Aktion >() )
 {
     this->name = name;
 }
 
-bool KonstantVariable::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     if( zMemory->zVariable( name ) )
         zMemory->setVar( "__return__", zMemory->getVariable( name ) );
@@ -91,61 +144,37 @@ bool KonstantVariable::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory
         zMemory->setVar( "__return__", zSpiel->getVariable( name ) );
     else
         zMemory->setVar( "__return__", new Variable( NICHTS ) );
-    return 1;
 }
 
 
-Warten::Warten( Aktion *seconds )
-    : Aktion( WARTEN )
+Warten::Warten( RCArray< Aktion > *subActions )
+    : Aktion( WARTEN, subActions )
 {
-    this->seconds = seconds;
+    this->erlaubteTypen.add( FLOAT );
 }
 
 Warten::~Warten()
-{
-    seconds->release();
-}
+{}
 
-bool Warten::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    bool finished = seconds->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
-    if( finished )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != FLOAT )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        waitCount += ( (Float *)t )->getValue();
-    }
-    return finished;
+    waitCount += ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue();
 }
 
 
-WennDannSonst::WennDannSonst( Aktion *wenn, Aktion *dann, Aktion *sonst )
-    : Aktion( WENN_DANN_SONST )
-{
-    this->wenn = wenn;
-    this->dann = dann;
-    this->sonst = sonst;
-}
+WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions )
+    : Aktion( WENN_DANN_SONST, subActions )
+{}
 
 WennDannSonst::~WennDannSonst()
-{
-    wenn->release();
-    if( dann )
-        dann->release();
-    if( sonst )
-        sonst->release();
-}
+{}
 
 bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
     if( zPC->currentPosition() == 0 )
     {
-        bool finished = wenn->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
+        bool finished = subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
         if( finished )
         {
             Variable *ret = zMemory->zVariable( "__return__" );
@@ -153,7 +182,7 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
             if( !isTrue( ret ) )
             {
                 zPC->count();
-                if( !sonst )
+                if( !subActions->z( 2 ) )
                 {
                     zPC->stepOut();
                     return 1;
@@ -161,7 +190,7 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
             }
             else
             {
-                if( !dann )
+                if( !subActions->z( 1 ) )
                 {
                     zPC->stepOut();
                     return 1;
@@ -171,7 +200,7 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     }
     if( zPC->currentPosition() == 1 && waitCount <= 0 )
     {
-        bool finished = dann->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
+        bool finished = subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
         if( finished )
         {
             zPC->stepOut();
@@ -180,7 +209,7 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     }
     if( zPC->currentPosition() == 2 && waitCount <= 0 )
     {
-        bool finished = sonst->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
+        bool finished = subActions->z( 2 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
         if( finished )
         {
             zPC->stepOut();
@@ -192,51 +221,37 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
 }
 
 
-SetVariable::SetVariable( Text name, Aktion *value )
-    : Aktion( SET_VARIABLE )
+SetVariable::SetVariable( Text name, RCArray< Aktion > *subActions )
+    : Aktion( SET_VARIABLE, subActions )
 {
     this->name = name;
-    this->value = value;
 }
 
 SetVariable::~SetVariable()
-{
-    value->release();
-}
+{}
 
-bool SetVariable::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    bool finished = value->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
-    if( finished )
-    {
-        if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
-            zMemory->setVar( name, zMemory->getVariable( "__return__" ) );
-        else
-            zSpiel->setVariable( name, zMemory->getVariable( "__return__" ) );
-    }
-    return finished;
+    if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
+        zMemory->setVar( name, getEvaluatedParam( 0, zMemory, zPC ) );
+    else
+        zSpiel->setVariable( name, getEvaluatedParam( 0, zMemory, zPC ) );
 }
 
 
-TriggerAktion::TriggerAktion( Aktion *number, Aktion *triggerName )
-    : Aktion( TRIGGER_AKTION )
-{
-    this->number = number;
-    trigger = triggerName;
-}
+TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
+    : Aktion( TRIGGER_AKTION, subActions )
+{}
 
 TriggerAktion::~TriggerAktion()
-{
-    number->release();
-    trigger->release();
-}
+{}
 
 bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
     if( zPC->currentPosition() == 0 )
     {
-        if( number->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
             if( !t || t->getVariableTyp() != INTEGER )
@@ -250,7 +265,7 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     }
     if( zPC->currentPosition() == 1 && waitCount <= 0 )
     {
-        if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
             if( !t || t->getVariableTyp() != TRIGGER )
@@ -258,7 +273,7 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
                 zPC->stepOut();
                 return 1;
             }
-            int id = ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue();
+            int id = ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue();
             if( id >= ( (Trigger *)t )->getAktionAnzahl() )
             {
                 zPC->stepOut();
@@ -270,7 +285,7 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     }
     if( zPC->currentPosition() == 2 && waitCount <= 0 )
     {
-        if( ( (Aktion *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( ( (Aktion *)zEvaluatedParam( 0, zMemory, zPC ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             zPC->stepOut();
             return 1;
@@ -281,3023 +296,1145 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
 }
 
 
-SpielerNachricht::SpielerNachricht( Aktion *spieler, Aktion *nachricht )
-    : Aktion( SPIELER_NACHRICHT )
+SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_NACHRICHT, subActions )
 {
-    this->spieler = spieler;
-    this->nachricht = nachricht;
+    erlaubteTypen.add( SPIELER );
+    erlaubteTypen.add( STRING );
 }
 
 SpielerNachricht::~SpielerNachricht()
-{
-    spieler->release();
-    nachricht->release();
-}
+{}
 
-bool SpielerNachricht::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerNachricht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( nachricht->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( t->getVariableTyp() != STRING )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            // this is handeld on client side directly (no need to send the message to the player)
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    // this is handeld on client side directly (no need to send the message to the player)
 }
 
 
-DisplayText::DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht )
-    : Aktion( DISPLAY_TEXT )
+DisplayText::DisplayText( RCArray< Aktion > *subActions )
+    : Aktion( DISPLAY_TEXT, subActions )
 {
-    this->x = x;
-    this->y = y;
-    this->color = f;
-    this->dauer = dauer;
-    this->nachricht = nachricht;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( STRING );
 }
 
 DisplayText::~DisplayText()
-{
-    x->release();
-    y->release();
-    color->release();
-    dauer->release();
-    nachricht->release();
-}
+{}
 
-bool DisplayText::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( dauer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 3 && waitCount <= 0 )
-    {
-        if( color->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || ( t->getVariableTyp() != INTEGER ) )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R3__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 4 && waitCount <= 0 )
-    {
-        if( color->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || ( t->getVariableTyp() != STRING ) )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            //Float *xv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" );
-            //Float *yv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" );
-            //Float *dauerv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R2__" );
-            //Integer *farbev = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R3__" );
-            // do nothing because the server does not need to show text
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    // do nothing because the server does not need to show text
 }
 
 
-SpielPause::SpielPause( Aktion *paused )
-    : Aktion( SPIEL_PAUSE )
+SpielPause::SpielPause( RCArray< Aktion > *subActions )
+    : Aktion( SPIEL_PAUSE, subActions )
 {
-    this->paused = paused;
+    erlaubteTypen.add( BOOLEAN );
 }
 
 SpielPause::~SpielPause()
+{}
+
+void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    paused->release();
+    zSpiel->setPausiert( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool SpielPause::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+SpielEnde::SpielEnde( RCArray< Aktion > *subActions )
+    : Aktion( SPIEL_ENDE, subActions )
+{}
+
+SpielEnde::~SpielEnde()
+{}
+
+void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( paused->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || ( t->getVariableTyp() != BOOLEAN ) )
-            return 1;
-        zSpiel->setPausiert( ( (Boolean *)t )->getValue() );
-        return 1;
-    }
-    return 0;
+    Variable *t = zEvaluatedParam( 0, zMemory, zPC );
+    if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM )
+        t = 0;
+    zSpiel->setEnde( t->getVariableTyp() == NICHTS ? 0 : (Team *)t );
 }
 
 
-SpielEnde::SpielEnde( Aktion *gewinnerTeam )
-    : Aktion( SPIEL_ENDE )
+SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_LEVEL, subActions )
 {
-    this->gewinnerTeam = gewinnerTeam;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielEnde::~SpielEnde()
+SpielerSetLevel::~SpielerSetLevel()
+{}
+
+void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    gewinnerTeam->release();
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLevel( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool SpielEnde::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_GIVE_ITEM, subActions )
 {
-    if( gewinnerTeam->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || ( t->getVariableTyp() != TEAM && t->getVariableTyp() != NICHTS ) )
-            return 1;
-        zSpiel->setEnde( t->getVariableTyp() == NICHTS ? 0 : (Team *)t );
-        return 1;
-    }
-    return 0;
+    erlaubteTypen.add( GEGENSTAND_TYP );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
 }
 
+SpielerGiveItem::~SpielerGiveItem()
+{}
 
-SpielerSetLevel::SpielerSetLevel( Aktion *level, Aktion *spieler )
-    : Aktion( SPIELER_SET_LEVEL )
+void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->level = level;
-    this->spieler = spieler;
+    ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->addItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(),
+        ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(), zSpiel );
 }
 
-SpielerSetLevel::~SpielerSetLevel()
+
+SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_REMOVE_ITEM, subActions )
 {
-    level->release();
-    spieler->release();
+    erlaubteTypen.add( GEGENSTAND_TYP );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
 }
 
-bool SpielerSetLevel::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+SpielerRemoveItem::~SpielerRemoveItem()
+{}
+
+void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( level->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setLevel( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->removeItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(),
+        ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
 }
 
 
-SpielerGiveItem::SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler )
-    : Aktion( SPIELER_GIVE_ITEM )
+SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_LEBEN, subActions )
 {
-    this->item = item;
-    this->anzahl = anzahl;
-    this->spieler = spieler;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielerGiveItem::~SpielerGiveItem()
+SpielerSetLeben::~SpielerSetLeben()
 {}
 
-bool SpielerGiveItem::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( item->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GEGENSTAND_TYP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( anzahl->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->addItem( ( (GegenstandTypVar *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
-                ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue(), zSpiel );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLeben( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-SpielerRemoveItem::SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler )
-    : Aktion( SPIELER_REMOVE_ITEM )
+SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_LEBEN, subActions )
 {
-    this->item = item;
-    this->anzahl = anzahl;
-    this->spieler = spieler;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielerRemoveItem::~SpielerRemoveItem()
+SpielerSetMaxLeben::~SpielerSetMaxLeben()
+{}
+
+void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    item->release();
-    anzahl->release();
-    spieler->release();
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxLeben( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool SpielerRemoveItem::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_ERFAHRUNG, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( item->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GEGENSTAND_TYP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( anzahl->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->removeItem( ( (GegenstandTypVar *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
-                ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
+SpielerSetErfahrung::~SpielerSetErfahrung()
+{}
 
-SpielerSetLeben::SpielerSetLeben( Aktion *leben, Aktion *spieler )
-    : Aktion( SPIELER_SET_LEBEN )
+void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->leben = leben;
-    this->spieler = spieler;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setErfahrung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-SpielerSetLeben::~SpielerSetLeben()
-{
-    leben->release();
-    spieler->release();
-}
 
-bool SpielerSetLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_MAX_ERFAHRUNG, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( leben->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setLeben( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
 }
 
+SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung()
+{}
 
-SpielerSetMaxLeben::SpielerSetMaxLeben( Aktion *leben, Aktion *spieler )
-    : Aktion( SPIELER_SET_LEBEN )
+void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->leben = leben;
-    this->spieler = spieler;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxErfahrung( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-SpielerSetMaxLeben::~SpielerSetMaxLeben()
+
+SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_TEMPO, subActions )
 {
-    leben->release();
-    spieler->release();
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-bool SpielerSetMaxLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+SpielerSetTempo::~SpielerSetTempo()
+{}
+
+void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( leben->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setMaxLeben( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLaufTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-SpielerSetErfahrung::SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler )
-    : Aktion( SPIELER_SET_ERFAHRUNG )
+SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_GESCHOSS_TEMPO, subActions )
 {
-    this->erfahrung = erfahrung;
-    this->spieler = spieler;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetErfahrung::~SpielerSetErfahrung()
+SpielerSetWaffenTempo::~SpielerSetWaffenTempo()
 {}
 
-bool SpielerSetErfahrung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( erfahrung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setErfahrung( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setGeschossTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler )
-    : Aktion( SPIELER_SET_MAX_ERFAHRUNG )
+SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_ARMOR, subActions )
 {
-    this->erfahrung = erfahrung;
-    this->spieler = spieler;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung()
+SpielerSetArmor::~SpielerSetArmor()
+{}
+
+void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    erfahrung->release();
-    spieler->release();
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setArmor( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool SpielerSetMaxErfahrung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_SCHADEN_BONUS, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( erfahrung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setMaxErfahrung( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
+SpielerSetSchadenBonus::~SpielerSetSchadenBonus()
+{}
 
-SpielerSetTempo::SpielerSetTempo( Aktion *tempo, Aktion *spieler )
-    : Aktion( SPIELER_SET_TEMPO )
+void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->tempo = tempo;
-    this->spieler = spieler;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setSchadenBonus( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-SpielerSetTempo::~SpielerSetTempo()
+
+SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
 {
-    tempo->release();
-    spieler->release();
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-bool SpielerSetTempo::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+SpielerSetLebensraub::~SpielerSetLebensraub()
+{}
+
+void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( tempo->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setLaufTempo( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRaub( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-SpielerSetWaffenTempo::SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler )
-    : Aktion( SPIELER_SET_GESCHOSS_TEMPO )
+SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
 {
-    this->tempo = tempo;
-    this->spieler = spieler;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetWaffenTempo::~SpielerSetWaffenTempo()
+SpielerSetLebensregeneration::~SpielerSetLebensregeneration()
+{}
+
+void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    tempo->release();
-    spieler->release();
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRegeneration( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool SpielerSetWaffenTempo::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( tempo->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setGeschossTempo( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( SPIELER );
 }
 
+SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung()
+{}
 
-SpielerSetArmor::SpielerSetArmor( Aktion *armor, Aktion *spieler )
-    : Aktion( SPIELER_SET_ARMOR )
+void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->armor = armor;
-    this->spieler = spieler;
+    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setAbklingZeitVerringerung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-SpielerSetArmor::~SpielerSetArmor()
+
+DropSetTime::DropSetTime( RCArray< Aktion > *subActions )
+    : Aktion( DROP_SET_TIME, subActions )
 {
-    armor->release();
-    spieler->release();
-}
-
-bool SpielerSetArmor::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( armor->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setArmor( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SpielerSetSchadenBonus::SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler )
-    : Aktion( SPIELER_SET_SCHADEN_BONUS )
-{
-    this->bonus = bonus;
-    this->spieler = spieler;
-}
-
-SpielerSetSchadenBonus::~SpielerSetSchadenBonus()
-{
-    bonus->release();
-    spieler->release();
-}
-
-bool SpielerSetSchadenBonus::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( bonus->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setSchadenBonus( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SpielerSetLebensraub::SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler )
-    : Aktion( SPIELER_SET_LEBENSRAUB )
-{
-    this->lebensraub = lebensraub;
-    this->spieler = spieler;
-}
-
-SpielerSetLebensraub::~SpielerSetLebensraub()
-{
-    lebensraub->release();
-    spieler->release();
-}
-
-bool SpielerSetLebensraub::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( lebensraub->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setLebensRaub( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SpielerSetLebensregeneration::SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler )
-    : Aktion( SPIELER_SET_LEBENSRAUB )
-{
-    this->regeneration = regeneration;
-    this->spieler = spieler;
-}
-
-SpielerSetLebensregeneration::~SpielerSetLebensregeneration()
-{
-    regeneration->release();
-    spieler->release();
-}
-
-bool SpielerSetLebensregeneration::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( regeneration->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setLebensRegeneration( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler )
-    : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG )
-{
-    this->verringerung = verringerung;
-    this->spieler = spieler;
-}
-
-SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung()
-{
-    verringerung->release();
-    spieler->release();
-}
-
-bool SpielerSetAbklingzeitverringerung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( verringerung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setAbklingZeitVerringerung( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-DropSetTime::DropSetTime( Aktion *time, Aktion *drop )
-    : Aktion( DROP_SET_TIME )
-{
-    this->time = time;
-    this->drop = drop;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( DROP );
 }
 
 DropSetTime::~DropSetTime()
-{
-    time->release();
-    drop->release();
-}
-
-bool DropSetTime::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( time->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != DROP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Drop *)t )->setTime( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-DropSetMaxTime::DropSetMaxTime( Aktion *time, Aktion *drop )
-    : Aktion( DROP_SET_MAX_TIME )
-{
-    this->time = time;
-    this->drop = drop;
-}
-
-DropSetMaxTime::~DropSetMaxTime()
-{
-    time->release();
-    drop->release();
-}
-
-bool DropSetMaxTime::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( time->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != DROP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Drop *)t )->setMaxTime( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-DropSetArea::DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop )
-    : Aktion( DROP_SET_AREA )
-{
-    this->minX = minX;
-    this->maxX = maxX;
-    this->minY = minY;
-    this->maxY = maxY;
-    this->drop = drop;
-}
-
-DropSetArea::~DropSetArea()
-{
-    minX->release();
-    maxX->release();
-    minY->release();
-    maxY->release();
-    drop->release();
-}
-
-bool DropSetArea::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( minX->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( maxX->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( minY->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 3 && waitCount <= 0 )
-    {
-        if( maxY->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R3__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 4 && waitCount <= 0 )
-    {
-        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != DROP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Drop *)t )->setMinX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Drop *)t )->setMaxX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            ( (Drop *)t )->setMinY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R2__" ) )->getValue() );
-            ( (Drop *)t )->setMaxY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R3__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-DropDoDrop::DropDoDrop( Aktion *drop )
-    : Aktion( DROP_DO_DROP )
-{
-    this->drop = drop;
-}
-
-DropDoDrop::~DropDoDrop()
 {}
-
-bool DropDoDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != DROP )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        ( (Drop *)t )->doDrop( zSpiel );
-        return 1;
-    }
-    return 0;
-}
-
-
-BariereBewegung::BariereBewegung( Aktion *bariere )
-    : Aktion( BARIERE_BEWEGUNG )
-{
-    this->bariere = bariere;
-}
-
-BariereBewegung::~BariereBewegung()
-{
-    bariere->release();
-}
-
-bool BariereBewegung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != BARIERE )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        ( (Bariere *)t )->startAutoVerschiebung( zSpiel );
-        return 1;
-    }
-    return 0;
-}
-
-
-BariereSetEingeschaltet::BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere )
-    : Aktion( BARIERE_SET_EINGESCHALTET )
-{
-    this->eingeschaltet = eingeschaltet;
-    this->bariere = bariere;
-}
-
-BariereSetEingeschaltet::~BariereSetEingeschaltet()
-{
-    eingeschaltet->release();
-    bariere->release();
-}
-
-bool BariereSetEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( eingeschaltet->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BARIERE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Bariere *)t )->setEingeschaltet( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-GameObjektSetPosition::GameObjektSetPosition( Aktion *x, Aktion *y, Aktion *objekt )
-    : Aktion( GAME_OBJEKT_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->objekt = objekt;
-}
-
-GameObjektSetPosition::~GameObjektSetPosition()
-{
-    x->release();
-    y->release();
-    objekt->release();
-}
-
-bool GameObjektSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BARIERE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (GameObject *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (GameObject *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-GameObjektSetSize::GameObjektSetSize( Aktion *x, Aktion *y, Aktion *objekt )
-    : Aktion( GAME_OBJEKT_SET_SIZE )
-{
-    this->x = x;
-    this->y = y;
-    this->objekt = objekt;
-}
-
-GameObjektSetSize::~GameObjektSetSize()
-{
-    x->release();
-    y->release();
-    objekt->release();
-}
-
-bool GameObjektSetSize::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BARIERE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (GameObject *)t )->setWidth( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (GameObject *)t )->setHeight( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-BariereSetTeam::BariereSetTeam( Aktion *team, Aktion *bariere )
-    : Aktion( BARIERE_SET_TEAM )
-{
-    this->team = team;
-    this->bariere = bariere;
-}
-
-BariereSetTeam::~BariereSetTeam()
-{
-    team->release();
-    bariere->release();
-}
-
-bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TEAM )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BARIERE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Bariere *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SchalterSetErlaubt::SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter )
-    : Aktion( SCHALTER_SET_ERLAUBT )
-{
-    this->erlaubt = erlaubt;
-    this->schalter = schalter;
-}
-
-SchalterSetErlaubt::~SchalterSetErlaubt()
-{
-    erlaubt->release();
-    schalter->release();
-}
-
-bool SchalterSetErlaubt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( erlaubt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SCHALTER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Schalter *)t )->setAktive( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SchalterAktivieren::SchalterAktivieren( Aktion *schalter )
-    : Aktion( SCHALTER_AKTIVIEREN )
-{
-    this->schalter = schalter;
-}
-
-SchalterAktivieren::~SchalterAktivieren()
-{
-    schalter->release();
-}
-
-bool SchalterAktivieren::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != SCHALTER )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zSpiel->activateShalter( ( (Schalter *)t )->getId() );
-        return 1;
-    }
-    return 0;
-}
-
-
-TunnelSetZielPosition::TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel )
-    : Aktion( TUNNEL_SET_ZIEL_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->tunnel = tunnel;
-}
-
-TunnelSetZielPosition::~TunnelSetZielPosition()
-{
-    x->release();
-    y->release();
-    tunnel->release();
-}
-
-bool TunnelSetZielPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TUNNEL )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Tunnel *)t )->setZielX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Tunnel *)t )->setZielY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-TunnelSetErlaubt::TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel )
-    : Aktion( TUNNEL_SET_ERLAUBT )
-{
-    this->erlaubt = erlaubt;
-    this->tunnel = tunnel;
-}
-
-TunnelSetErlaubt::~TunnelSetErlaubt()
-{
-    erlaubt->release();
-    tunnel->release();
-}
-
-bool TunnelSetErlaubt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( erlaubt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TUNNEL )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Tunnel *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+
+void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    ( (Drop *)zEvaluatedParam( 1, zMemory, zPC ) )->setTime( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-UmlenkungSetRichtung::UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung )
-    : Aktion( UMLENKUNG_SET_RICHTUNG )
+DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions )
+    : Aktion( DROP_SET_MAX_TIME, subActions )
 {
-    this->richtung = richtung;
-    this->umlenkung = umlenkung;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( DROP );
 }
 
-UmlenkungSetRichtung::~UmlenkungSetRichtung()
+DropSetMaxTime::~DropSetMaxTime()
+{}
+
+void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    richtung->release();
-    umlenkung->release();
+    ( (Drop *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxTime( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool UmlenkungSetRichtung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+DropSetArea::DropSetArea( RCArray< Aktion > *subActions )
+    : Aktion( DROP_SET_AREA, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != RICHTUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != UMLENKUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Umlenkung *)t )->setRichtung( getRichtungFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( DROP );
 }
 
+DropSetArea::~DropSetArea()
+{}
 
-UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung )
-    : Aktion( UMLENKUNG_SET_MAX_ABK )
+void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->abk = abk;
-    this->umlenkung = umlenkung;
+    ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMinX( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMaxX( ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
+    ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMinY( ( (Integer *)zEvaluatedParam( 2, zMemory, zPC ) )->getValue() );
+    ( (Drop *)zEvaluatedParam( 4, zMemory, zPC ) )->setMaxY( ( (Integer *)zEvaluatedParam( 3, zMemory, zPC ) )->getValue() );
 }
 
-UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk()
+
+DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions )
+    : Aktion( DROP_DO_DROP, subActions )
 {
-    abk->release();
-    umlenkung->release();
+    erlaubteTypen.add( DROP );
 }
 
-bool UmlenkungSetMaxAbk::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+DropDoDrop::~DropDoDrop()
+{}
+
+void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( abk->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != UMLENKUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Umlenkung *)t )->setMaxAbklingzeit( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->doDrop( zSpiel );
 }
 
 
-UmlenkungSetEnabled::UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung )
-    : Aktion( UMLENKUNG_SET_ERLAUBT )
+BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions )
+    : Aktion( BARIERE_BEWEGUNG, subActions )
 {
-    this->enabled = enabled;
-    this->umlenkung = umlenkung;
+    erlaubteTypen.add( BARIERE );
 }
 
-UmlenkungSetEnabled::~UmlenkungSetEnabled()
+BariereBewegung::~BariereBewegung()
+{}
+
+void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    enabled->release();
-    umlenkung->release();
+    ( (Bariere *)zEvaluatedParam( 0, zMemory, zPC ) )->startAutoVerschiebung( zSpiel );
 }
 
-bool UmlenkungSetEnabled::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions )
+    : Aktion( BARIERE_SET_EINGESCHALTET, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( enabled->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != UMLENKUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Umlenkung *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( DROP );
 }
 
+BariereSetEingeschaltet::~BariereSetEingeschaltet()
+{}
 
-BaseSetTeam::BaseSetTeam( Aktion *team, Aktion *base )
-    : Aktion( BASE_SET_TEAM )
+void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->team = team;
-    this->base = base;
+    ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setEingeschaltet( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-BaseSetTeam::~BaseSetTeam()
+
+GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions )
+    : Aktion( GAME_OBJEKT_SET_POSITION, subActions )
 {
-    team->release();
-    base->release();
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( GAME_OBJEKT );
 }
 
-bool BaseSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+GameObjektSetPosition::~GameObjektSetPosition()
+{}
+
+void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TEAM )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( base->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BASE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Base *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setX( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setY( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
 }
 
-TriggerRunStart::TriggerRunStart( Aktion *trigger )
-    : Aktion( TRIGGER_RUN_START )
+
+GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions )
+    : Aktion( GAME_OBJEKT_SET_SIZE, subActions )
 {
-    this->trigger = trigger;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( GAME_OBJEKT );
 }
 
-TriggerRunStart::~TriggerRunStart()
+GameObjektSetSize::~GameObjektSetSize()
+{}
+
+void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    trigger->release();
+    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setWidth( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setHeight( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
 }
 
-bool TriggerRunStart::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions )
+    : Aktion( BARIERE_SET_TEAM, subActions )
 {
-    if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != TRIGGER )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zSpiel->addTriggerRun( ( (Trigger *)t )->runTrigger( zEreignis->getThis(), zSpiel ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    erlaubteTypen.add( TEAM );
+    erlaubteTypen.add( BARIERE );
 }
 
+BariereSetTeam::~BariereSetTeam()
+{}
 
-TriggerSetEnabled::TriggerSetEnabled( Aktion *enabled, Aktion *trigger )
-    : Aktion( TRIGGER_SET_ENABLED )
+void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->enabled = enabled;
-    this->trigger = trigger;
+    ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) );
 }
 
-TriggerSetEnabled::~TriggerSetEnabled()
+
+SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions )
+    : Aktion( SCHALTER_SET_ERLAUBT, subActions )
 {
-    enabled->release();
-    trigger->release();
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( SCHALTER );
 }
 
-bool TriggerSetEnabled::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+SchalterSetErlaubt::~SchalterSetErlaubt()
+{}
+
+void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( enabled->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TRIGGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Trigger *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Schalter *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktive( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-TeamSetPunkte::TeamSetPunkte( Aktion *punkte, Aktion *team )
-    : Aktion( TEAM_SET_PUNKTE )
+SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions )
+    : Aktion( SCHALTER_AKTIVIEREN, subActions )
 {
-    this->punkte = punkte;
-    this->team = team;
+    erlaubteTypen.add( SCHALTER );
 }
 
-TeamSetPunkte::~TeamSetPunkte()
+SchalterAktivieren::~SchalterAktivieren()
+{}
+
+void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    punkte->release();
-    team->release();
+    zSpiel->activateShalter( ( (Schalter *)zEvaluatedParam( 0, zMemory, zPC ) )->getId() );
 }
 
-bool TeamSetPunkte::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions )
+    : Aktion( TUNNEL_SET_ZIEL_POSITION, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( punkte->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TEAM )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Team *)t )->setPunkte( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( TUNNEL );
 }
 
+TunnelSetZielPosition::~TunnelSetZielPosition()
+{}
 
-TimerSetPause::TimerSetPause( Aktion *pause, Aktion *timer )
-    : Aktion( TIMER_SET_PAUSE )
+void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->pause = pause;
-    this->timer = timer;
+    ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielX( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielY( ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
 }
 
-TimerSetPause::~TimerSetPause()
+
+TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions )
+    : Aktion( TUNNEL_SET_ERLAUBT, subActions )
+{
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( TUNNEL );
+}
+
+TunnelSetErlaubt::~TunnelSetErlaubt()
+{}
+
+void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    pause->release();
-    timer->release();
+    ( (Tunnel *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool TimerSetPause::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions )
+    : Aktion( UMLENKUNG_SET_RICHTUNG, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( pause->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TIMER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Timer *)t )->setPause( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( RICHTUNG );
+    erlaubteTypen.add( UMLENKUNG );
 }
 
+UmlenkungSetRichtung::~UmlenkungSetRichtung()
+{}
 
-TimerStart::TimerStart( Aktion *timer )
-    : Aktion( TIMER_START )
+void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->timer = timer;
+    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
 }
 
-TimerStart::~TimerStart()
+
+UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions )
+    : Aktion( UMLENKUNG_SET_MAX_ABK, subActions )
 {
-    timer->release();
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( UMLENKUNG );
 }
 
-bool TimerStart::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk()
+{}
+
+void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != TIMER )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        ( (Timer *)t )->start( zSpiel );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxAbklingzeit( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-TimerSetZeit::TimerSetZeit( Aktion *zeit, Aktion *timer )
-    : Aktion( TIMER_SET_ZEIT )
+UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions )
+    : Aktion( UMLENKUNG_SET_ERLAUBT, subActions )
 {
-    this->zeit = zeit;
-    this->timer = timer;
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( UMLENKUNG );
 }
 
-TimerSetZeit::~TimerSetZeit()
+UmlenkungSetEnabled::~UmlenkungSetEnabled()
+{}
+
+void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zeit->release();
-    timer->release();
+    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool TimerSetZeit::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
+    : Aktion( BASE_SET_TEAM, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( zeit->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TIMER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Timer *)t )->setZeit( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( TEAM );
+    erlaubteTypen.add( BASE );
 }
 
+BaseSetTeam::~BaseSetTeam()
+{}
 
-TimerSetSichtbar::TimerSetSichtbar( Aktion *sichtbar, Aktion *timer )
-    : Aktion( TIMER_SET_SICHTBAR )
+void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->sichtbar = sichtbar;
-    this->timer = timer;
+    ( (Base *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) );
 }
 
-TimerSetSichtbar::~TimerSetSichtbar()
+TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
+    : Aktion( TRIGGER_RUN_START, subActions )
 {
-    sichtbar->release();
-    timer->release();
+    erlaubteTypen.add( TRIGGER );
 }
 
-bool TimerSetSichtbar::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+TriggerRunStart::~TriggerRunStart()
+{}
+
+void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( sichtbar->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BOOLEAN )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TIMER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Timer *)t )->setSichtbar( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    zSpiel->addTriggerRun( ( (Trigger *)zEvaluatedParam( 0, zMemory, zPC ) )->runTrigger( zEreignis->getThis(), zSpiel ) );
 }
 
 
-GeschossNeu::GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung )
-    : Aktion( GESCHOSS_NEU )
+TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions )
+    : Aktion( TRIGGER_SET_ENABLED, subActions )
 {
-    this->x = x;
-    this->y = y;
-    this->typ = typ;
-    this->richtung = richtung;
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( TRIGGER );
 }
 
-GeschossNeu::~GeschossNeu()
+TriggerSetEnabled::~TriggerSetEnabled()
+{}
+
+void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    x->release();
-    y->release();
-    typ->release();
-    richtung->release();
+    ( (Trigger *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-bool GeschossNeu::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions )
+    : Aktion( TEAM_SET_PUNKTE, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( typ->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS_TYP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 3 && waitCount <= 0 )
-    {
-        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != RICHTUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
-                                        getGeschossTypFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ),
-                                        getRichtungFromString( ( (String *)t )->getValue() ),
-                                        ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
-                                        ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue(), 0 );
-            zSpiel->addGeschoss( (Geschoss *)g->getThis() );
-            zMemory->setVar( "__return__", g );
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( TEAM );
 }
 
+TeamSetPunkte::~TeamSetPunkte()
+{}
 
-GeschossSetSpeed::GeschossSetSpeed( Aktion *speed, Aktion *geschoss )
-    : Aktion( GESCHOSS_SET_SPEED )
+void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->speed = speed;
-    this->geschoss = geschoss;
+    ( (Team *)zEvaluatedParam( 1, zMemory, zPC ) )->setPunkte( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-GeschossSetSpeed::~GeschossSetSpeed()
+
+TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
+    : Aktion( TIMER_SET_PAUSE, subActions )
 {
-    speed->release();
-    geschoss->release();
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( TIMER );
 }
 
-bool GeschossSetSpeed::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+TimerSetPause::~TimerSetPause()
+{}
+
+void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( speed->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Geschoss *)t )->setSpeed( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setPause( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
 
-GeschossSetPlayer::GeschossSetPlayer( Aktion *player, Aktion *geschoss )
-    : Aktion( GESCHOSS_SET_PLAYER )
+TimerStart::TimerStart( RCArray< Aktion > *subActions )
+    : Aktion( TIMER_START, subActions )
 {
-    this->player = player;
-    this->geschoss = geschoss;
+    erlaubteTypen.add( TIMER );
 }
 
-GeschossSetPlayer::~GeschossSetPlayer()
+TimerStart::~TimerStart()
+{}
+
+void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    player->release();
-    geschoss->release();
+    ( (Timer *)zEvaluatedParam( 0, zMemory, zPC ) )->start( zSpiel );
 }
 
-bool GeschossSetPlayer::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+
+TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions )
+    : Aktion( TIMER_SET_ZEIT, subActions )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( player->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Geschoss *)t )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( TIMER );
 }
 
+TimerSetZeit::~TimerSetZeit()
+{}
 
-GeschossSetRichtung::GeschossSetRichtung( Aktion *richtung, Aktion *geschoss )
-    : Aktion( GESCHOSS_SET_RICHTUNG )
+void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->richtung = richtung;
-    this->geschoss = geschoss;
+    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setZeit( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
 }
 
-GeschossSetRichtung::~GeschossSetRichtung()
+
+TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions )
+    : Aktion( TIMER_SET_SICHTBAR, subActions )
 {
-    richtung->release();
-    geschoss->release();
+    erlaubteTypen.add( BOOLEAN );
+    erlaubteTypen.add( TIMER );
 }
 
-bool GeschossSetRichtung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+TimerSetSichtbar::~TimerSetSichtbar()
+{}
+
+void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != RICHTUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Geschoss *)t )->setRichtung( getRichtungFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setSichtbar( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+}
+
+
+GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions )
+    : Aktion( GESCHOSS_NEU, subActions )
+{
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( GESCHOSS_TYP );
+    erlaubteTypen.add( RICHTUNG );
+}
+
+GeschossNeu::~GeschossNeu()
+{}
+
+void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
+                                getGeschossTypFromString( ( (String *)zEvaluatedParam( 2, zMemory, zPC ) )->getValue() ),
+                                getRichtungFromString( ( (String *)zEvaluatedParam( 3, zMemory, zPC ) )->getValue() ),
+                                ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(),
+                                ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(), 0 );
+    zSpiel->addGeschoss( (Geschoss *)g->getThis() );
+    zMemory->setVar( "__return__", g );
+}
+
+
+GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions )
+    : Aktion( GESCHOSS_SET_SPEED, subActions )
+{
+    erlaubteTypen.add( FLOAT );
+    erlaubteTypen.add( GESCHOSS );
+}
+
+GeschossSetSpeed::~GeschossSetSpeed()
+{}
+
+void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setSpeed( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+}
+
+
+GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions )
+    : Aktion( GESCHOSS_SET_PLAYER, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+    erlaubteTypen.add( GESCHOSS );
 }
 
+GeschossSetPlayer::~GeschossSetPlayer()
+{}
 
-GeschossSetType::GeschossSetType( Aktion *type, Aktion *geschoss )
-    : Aktion( GESCHOSS_SET_TYPE )
+void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    this->type = type;
-    this->geschoss = geschoss;
+    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
 }
 
-GeschossSetType::~GeschossSetType()
+
+GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions )
+    : Aktion( GESCHOSS_SET_RICHTUNG, subActions )
 {
-    type->release();
-    geschoss->release();
+    erlaubteTypen.add( RICHTUNG );
+    erlaubteTypen.add( GESCHOSS );
 }
 
-bool GeschossSetType::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+GeschossSetRichtung::~GeschossSetRichtung()
+{}
+
+void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( type->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS_TYP )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Geschoss *)t )->setTyp( getGeschossTypFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
+}
+
+
+GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions )
+    : Aktion( GESCHOSS_SET_TYPE, subActions )
+{
+    erlaubteTypen.add( GESCHOSS_TYP );
+    erlaubteTypen.add( GESCHOSS );
+}
+
+GeschossSetType::~GeschossSetType()
+{}
+
+void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setTyp( getGeschossTypFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
 }
 
 
 TriggerZufall::TriggerZufall()
-    : Aktion( TRIGGER_ZUFALL )
+    : Aktion( TRIGGER_ZUFALL, new RCArray< Aktion >() )
 {}
 
-bool TriggerZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getRandomTrigger() );
-    return 1;
 }
 
 
 TriggerLastRunned::TriggerLastRunned()
-    : Aktion( TRIGGER_LAST_RUNNED )
+    : Aktion( TRIGGER_LAST_RUNNED, new RCArray< Aktion >() )
 {}
 
-bool TriggerLastRunned::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getLastRunnedTrigger() );
-    return 1;
 }
 
 
 BariereZufall::BariereZufall()
-    : Aktion( BARIERE_ZUFALL )
+    : Aktion( BARIERE_ZUFALL, new RCArray< Aktion >() )
 {}
 
-bool BariereZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getRandomBariere() );
-    return 1;
 }
 
 
 BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
-    : Aktion( BARIERE_ZULETZT_EINGESCHALTET )
+    : Aktion( BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >() )
 {}
 
-bool BariereZuletztEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getZuletztEingeschalteteBariere() );
-    return 1;
 }
 
 
 BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
-    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET )
+    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >() )
 {}
 
-bool BariereZuletztAusgeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getZuletztAusgeschalteteBariere() );
-    return 1;
 }
 
 
 BariereZuletztBewegt::BariereZuletztBewegt()
-    : Aktion( BARIERE_ZULETZT_BEWEGT )
+    : Aktion( BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >() )
 {}
 
-bool BariereZuletztBewegt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getZuletztBewegteBariere() );
-    return 1;
 }
 
 
 BaseZufall::BaseZufall()
-    : Aktion( BASE_ZUFALL )
+    : Aktion( BASE_ZUFALL, new RCArray< Aktion >() )
 {}
 
-bool BaseZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getRandomBase() );
-    return 1;
 }
 
 
 BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
-    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT )
+    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >() )
 {}
 
-bool BaseZuletztBesitzerGewechselt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getLastTeamChangedBase() );
-    return 1;
 }
 
 
 DropZufall::DropZufall()
-    : Aktion( DROP_ZUFALL )
+    : Aktion( DROP_ZUFALL, new RCArray< Aktion >() )
 {}
 
-bool DropZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getRandomDrop() );
-    return 1;
 }
 
 
 DropZuletztGedropt::DropZuletztGedropt()
-    : Aktion( DROP_ZULETZT_GEDROPT )
+    : Aktion( DROP_ZULETZT_GEDROPT, new RCArray< Aktion >() )
 {}
 
-bool DropZuletztGedropt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zMemory->setVar( "__return__", zSpiel->getLastDrop() );
-    return 1;
 }
 
 
-IntegerRechnen::IntegerRechnen( Aktion *left, Aktion *right, Operator op )
-    : Aktion( INTEGER_RECHNEN )
+IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op )
+    : Aktion( INTEGER_RECHNEN, subActions )
 {
-    this->left = left;
-    this->right = right;
-    this->op = op;
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
 }
 
 IntegerRechnen::~IntegerRechnen()
-{
-    left->release();
-    if( right )
-        right->release();
-}
-
-bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    bool finished = 0;
-    if( zPC->currentPosition() == 0 )
-    {
-        if( left->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            if( !isBinary( op ) )
-                finished = 1;
-            else
-                zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( right->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            finished = 1;
-        }
-    }
-    if( finished )
-    {
-        Integer *l = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" );
-        Integer *r = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" );
-        switch( op )
-        {
-        case PLUS:
-            zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) );
-            break;
-        case MINUS:
-            zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) );
-            break;
-        case MAHL:
-            zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) );
-            break;
-        case GETEILT:
-            zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) );
-            break;
-        case HOCH:
-            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
-            break;
-        case WURZEL:
-            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
-            break;
-        case BIT_ODER:
-            zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) );
-            break;
-        case BIT_UND:
-            zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) );
-            break;
-        case BIT_XOR:
-            zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) );
-            break;
-        case BIT_FLIP:
-            zMemory->setVar( "__return__", new Integer( ~l->getValue() ) );
-            break;
-        case BIT_SHIFT_LEFT:
-            zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) );
-            break;
-        case BIT_SHIFT_RIGHT:
-            zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) );
-            break;
-        case INVERT_SIGN:
-            zMemory->setVar( "__return__", new Integer( -l->getValue() ) );
-            break;
-        case PLUS_PLUS_LEFT:
-            l->setValue( l->getValue() + 1 );
-            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
-            break;
-        case PLUS_PLUS_RIGHT:
-        {
-            int tmp = l->getValue();
-            l->setValue( l->getValue() + 1 );
-            zMemory->setVar( "__return__", new Integer( tmp ) );
-            break;
-        }
-        case MINUS_MINUS_LEFT:
-            l->setValue( l->getValue() - 1 );
-            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
-            break;
-        case MINUS_MINUS_RIGHT:
-        {
-            int tmp = l->getValue();
-            l->setValue( l->getValue() - 1 );
-            zMemory->setVar( "__return__", new Integer( tmp ) );
-            break;
-        }
-        case LOGARITHM:
-            zMemory->setVar( "__return__", new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
-            break;
-        case MODULO:
-            zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
-            break;
-        default:
-            break;
-        }
-        zPC->stepOut();
-        return 1;
-    }
-    zPC->stepOut();
-    return 0;
-}
-
+{}
 
-IntegerZufall::IntegerZufall( Aktion *min, Aktion *max )
-    : Aktion( INTEGER_ZUFALL )
-{
-    this->min = 0;
-    this->max = 0;
+void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    Integer *l = (Integer *)zEvaluatedParam( 0, zMemory, zPC );
+    Integer *r = (Integer *)zEvaluatedParam( 1, zMemory, zPC );
+    switch( op )
+    {
+    case PLUS:
+        zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) );
+        break;
+    case MINUS:
+        zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) );
+        break;
+    case MAHL:
+        zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) );
+        break;
+    case GETEILT:
+        zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) );
+        break;
+    case HOCH:
+        zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
+        break;
+    case WURZEL:
+        zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
+        break;
+    case BIT_ODER:
+        zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) );
+        break;
+    case BIT_UND:
+        zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) );
+        break;
+    case BIT_XOR:
+        zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) );
+        break;
+    case BIT_FLIP:
+        zMemory->setVar( "__return__", new Integer( ~l->getValue() ) );
+        break;
+    case BIT_SHIFT_LEFT:
+        zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) );
+        break;
+    case BIT_SHIFT_RIGHT:
+        zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) );
+        break;
+    case INVERT_SIGN:
+        zMemory->setVar( "__return__", new Integer( -l->getValue() ) );
+        break;
+    case PLUS_PLUS_LEFT:
+        l->setValue( l->getValue() + 1 );
+        zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+        break;
+    case PLUS_PLUS_RIGHT:
+    {
+        int tmp = l->getValue();
+        l->setValue( l->getValue() + 1 );
+        zMemory->setVar( "__return__", new Integer( tmp ) );
+        break;
+    }
+    case MINUS_MINUS_LEFT:
+        l->setValue( l->getValue() - 1 );
+        zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+        break;
+    case MINUS_MINUS_RIGHT:
+    {
+        int tmp = l->getValue();
+        l->setValue( l->getValue() - 1 );
+        zMemory->setVar( "__return__", new Integer( tmp ) );
+        break;
+    }
+    case LOGARITHM:
+        zMemory->setVar( "__return__", new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
+        break;
+    case MODULO:
+        zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
+        break;
+    default:
+        break;
+    }
+}
+
+
+IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_ZUFALL, subActions )
+{
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
 }
 
 IntegerZufall::~IntegerZufall()
-{
-    min->release();
-    max->release();
-}
+{}
 
-bool IntegerZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( min->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( max->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            int mi = ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue();
-            int ma = ( (Integer *)t )->getValue();
-            zMemory->setVar( "__return__", new Integer( (int)( zSpiel->getRand() * ( ma - mi ) + mi ) ) );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+    int mi = ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue();
+    int ma = ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue();
+    zMemory->setVar( "__return__", new Integer( (int)( zSpiel->getRand() * ( ma - mi ) + mi ) ) );
 }
 
 
-IntegerAusText::IntegerAusText( Aktion *text )
-    : Aktion( INTEGER_AUS_TEXT )
+IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_AUS_TEXT, subActions )
 {
-    this->text = text;
+    erlaubteTypen.add( STRING );
 }
 
 IntegerAusText::~IntegerAusText()
-{
-    this->text->release();
-}
+{}
 
-bool IntegerAusText::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( text->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != STRING )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (String *)t )->getValue() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
 }
 
 
-FloatXVonGameObjekt::FloatXVonGameObjekt( Aktion *objekt )
-    : Aktion( FLOAT_X_VON_GAME_OBJEKT )
+FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions )
+    : Aktion( FLOAT_X_VON_GAME_OBJEKT, subActions )
 {
-    this->objekt = objekt;
+    erlaubteTypen.add( GAME_OBJEKT );
 }
 
 FloatXVonGameObjekt::~FloatXVonGameObjekt()
-{
-    objekt->release();
-}
+{}
 
-bool FloatXVonGameObjekt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != GAME_OBJEKT )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Float( ( (GameObject *)t )->getX() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getX() ) );
 }
 
 
-FloatYVonGameObjekt::FloatYVonGameObjekt( Aktion *objekt )
-    : Aktion( FLOAT_Y_VON_GAME_OBJEKT )
+FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions )
+    : Aktion( FLOAT_Y_VON_GAME_OBJEKT, subActions )
 {
-    this->objekt = objekt;
+    erlaubteTypen.add( GAME_OBJEKT );
 }
 
 FloatYVonGameObjekt::~FloatYVonGameObjekt()
-{
-    objekt->release();
-}
+{}
 
-bool FloatYVonGameObjekt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != GAME_OBJEKT )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Float( ( (GameObject *)t )->getY() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getY() ) );
 }
 
 
-IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( Aktion *tunnel )
-    : Aktion( INTEGER_X_VON_TUNNEL_ZIEL )
+IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_X_VON_TUNNEL_ZIEL, subActions )
 {
-    this->tunnel = tunnel;
+    erlaubteTypen.add( TUNNEL );
 }
 
 IntegerXVonTunnelZiel::~IntegerXVonTunnelZiel()
-{
-    tunnel->release();
-}
+{}
 
-bool IntegerXVonTunnelZiel::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != TUNNEL )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Tunnel *)t )->getZielX() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielX() ) );
 }
 
 
-IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( Aktion *tunnel )
-    : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL )
+IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL, subActions )
 {
-    this->tunnel = tunnel;
+    erlaubteTypen.add( TUNNEL );
 }
 
 IntegerYVonTunnelZiel::~IntegerYVonTunnelZiel()
-{
-    tunnel->release();
-}
+{}
 
-bool IntegerYVonTunnelZiel::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != TUNNEL )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Tunnel *)t )->getZielY() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielY() ) );
 }
 
 
-IntegerMinXVonDrop::IntegerMinXVonDrop( Aktion *drop )
-    : Aktion( INTEGER_MIN_X_VON_DROP )
+IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_MIN_X_VON_DROP, subActions )
 {
-    this->drop = drop;
+    erlaubteTypen.add( DROP );
 }
 
 IntegerMinXVonDrop::~IntegerMinXVonDrop()
-{
-    drop->release();
-}
+{}
 
-bool IntegerMinXVonDrop::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != DROP )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMinX() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinX() ) );
 }
 
 
-IntegerMinYVonDrop::IntegerMinYVonDrop( Aktion *drop )
-    : Aktion( INTEGER_MIN_Y_VON_DROP )
+IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_MIN_Y_VON_DROP, subActions )
 {
-    this->drop = drop;
+    erlaubteTypen.add( DROP );
 }
 
 IntegerMinYVonDrop::~IntegerMinYVonDrop()
-{
-    drop->release();
-}
+{}
 
-bool IntegerMinYVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != DROP )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMinY() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinY() ) );
 }
 
 
-IntegerMaxXVonDrop::IntegerMaxXVonDrop( Aktion *drop )
-    : Aktion( INTEGER_MAX_X_VON_DROP )
+IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_MAX_X_VON_DROP, subActions )
 {
-    this->drop = drop;
+    erlaubteTypen.add( DROP );
 }
 
 IntegerMaxXVonDrop::~IntegerMaxXVonDrop()
-{
-    drop->release();
-}
+{}
 
-bool IntegerMaxXVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != DROP )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMaxX() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxX() ) );
 }
 
 
-IntegerMaxYVonDrop::IntegerMaxYVonDrop( Aktion *drop )
-    : Aktion( INTEGER_MAX_Y_VON_DROP )
+IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_MAX_Y_VON_DROP, subActions )
 {
-    this->drop = drop;
+    erlaubteTypen.add( DROP );
 }
 
 IntegerMaxYVonDrop::~IntegerMaxYVonDrop()
-{
-    drop->release();
-}
+{}
 
-bool IntegerMaxYVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != DROP )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMaxY() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxY() ) );
 }
 
 
-IntegerSpielerLevel::IntegerSpielerLevel( Aktion *spieler )
-    : Aktion( INTEGER_SPIELER_LEVEL )
+IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions )
+    : Aktion( INTEGER_SPIELER_LEVEL, subActions )
 {
-    this->spieler = spieler;
+    erlaubteTypen.add( SPIELER );
 }
 
 IntegerSpielerLevel::~IntegerSpielerLevel()
-{
-    spieler->release();
-}
+{}
 
-bool IntegerSpielerLevel::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != SPIELER )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Integer( ( (Spieler *)t )->getLevel() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Integer( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLevel() ) );
 }
 
 
-FloatSpielerLeben::FloatSpielerLeben( Aktion *spieler )
-    : Aktion( FLOAT_SPIELER_LEBEN )
+FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions )
+    : Aktion( FLOAT_SPIELER_LEBEN, subActions )
 {
-    this->spieler = spieler;
+    erlaubteTypen.add( SPIELER );
 }
 
 FloatSpielerLeben::~FloatSpielerLeben()
-{
-    spieler->release();
-}
+{}
 
-bool FloatSpielerLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-    {
-        Variable *t = zMemory->zVariable( "__return__" );
-        if( !t || t->getVariableTyp() != SPIELER )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        zMemory->setVar( "__return__", new Float( ( (Spieler *)t )->getLeben() ) );
-        zPC->stepOut();
-        return 1;
-    }
-    return 0;
+    zMemory->setVar( "__return__", new Float( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLeben() ) );
 }

StickmanWorldOnline/Aktionen.h

@@ -27,9 +27,7 @@ enum AktionTyp
     BOOLEAN_BARIERE_IST_AKTIV,
     BOOLEAN_BARIERE_IST_SCHALTEND,
     BOOLEAN_BASE_IST_NEUTRAL,
-    BOOLEAN_GLEICH,
-    BOOLEAN_NICHT,
-    BOOLEAN_ODER,
+    BOOLEAN_RECHNUNG,
     BOOLEAN_SCHALTER_IST_AKTIV,
     BOOLEAN_SPIELER_AM_LEBEN,
     BOOLEAN_SPIELER_HAT_GEGENSTAND,
@@ -43,7 +41,6 @@ enum AktionTyp
     BOOLEAN_TUNNEL_IST_AKTIV,
     BOOLEAN_UMLENKUNG_HAT_ABK,
     BOOLEAN_UMLENKUNG_IST_DREHEND,
-    BOOLEAN_UND,
     BOOLEAN_ZUFALL,
     DISPLAY_TEXT,
     DROP_DO_DROP,
@@ -246,21 +243,26 @@ bool isBinary( Operator op );
 
 class Aktion : public Variable
 {
-private:
+protected:
+    RCArray< Aktion > *subActions;
+    Array< VariableTyp > erlaubteTypen;
     AktionTyp typ;
+    Variable *zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );
+    Variable *getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );
 
 public:
-    Aktion( AktionTyp typ );
+    Aktion( AktionTyp typ, RCArray< Aktion > *subActions );
     virtual ~Aktion();
     // gibt 1 zurück, wenn die aktion vollständig ausgeführt wurde
-    virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) = 0;
+    virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount );
+    virtual void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount );
 };
 
 class KonstantNichts : public Aktion
 {
 public:
     KonstantNichts();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantInteger : public Aktion
@@ -270,7 +272,7 @@ private:
 
 public:
     KonstantInteger( int val );
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantBoolean : public Aktion
@@ -280,7 +282,7 @@ private:
 
 public:
     KonstantBoolean( bool val );
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantString : public Aktion
@@ -290,7 +292,7 @@ private:
 
 public:
     KonstantString( Text val );
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantFloat : public Aktion
@@ -300,7 +302,7 @@ private:
 
 public:
     KonstantFloat( float val );
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantVariable : public Aktion
@@ -310,29 +312,23 @@ private:
 
 public:
     KonstantVariable( Text name );
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class Warten : public Aktion
 {
-private:
-    Aktion *seconds;
-
 public:
-    Warten( Aktion *seconds );
+    // zeit
+    Warten( RCArray< Aktion > *subActions );
     ~Warten();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class WennDannSonst : public Aktion
 {
-private:
-    Aktion *wenn;
-    Aktion *dann;
-    Aktion *sonst;
-
 public:
-    WennDannSonst( Aktion *wenn, Aktion *dann, Aktion *sonst );
+    // wenn, dann, sonst
+    WennDannSonst( RCArray< Aktion > *subActions );
     ~WennDannSonst();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
@@ -341,453 +337,309 @@ class SetVariable : public Aktion
 {
 private:
     Text name;
-    Aktion *value;
 
 public:
-    SetVariable( Text name, Aktion *value );
+    // value
+    SetVariable( Text name, RCArray< Aktion > *subActions );
     ~SetVariable();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerAktion : public Aktion
 {
-private:
-    Aktion *number;
-    Aktion *trigger;
-
 public:
-    TriggerAktion( Aktion *number, Aktion *triggerName );
+    // number, triggerName
+    TriggerAktion( RCArray< Aktion > *subActions );
     ~TriggerAktion();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerNachricht : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *nachricht;
-
 public:
-    SpielerNachricht( Aktion *spieler, Aktion *nachricht );
+    // Spieler, Nachricht
+    SpielerNachricht( RCArray< Aktion > *subActions );
     ~SpielerNachricht();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DisplayText : public Aktion
 {
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *color;
-    Aktion *dauer;
-    Aktion *nachricht;
-
 public:
-    DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht );
+    // x, y, color, dauer, nachricht
+    DisplayText( RCArray< Aktion > *subActions );
     ~DisplayText();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielPause : public Aktion
 {
-private:
-    Aktion *paused;
-
 public:
-    SpielPause( Aktion *paused );
+    // paused
+    SpielPause( RCArray< Aktion > *subActions );
     ~SpielPause();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielEnde : public Aktion
 {
-private:
-    Aktion *gewinnerTeam;
-
 public:
-    SpielEnde( Aktion *gewinnerTeam );
+    // gewinner team
+    SpielEnde( RCArray< Aktion > *subActions );
     ~SpielEnde();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLevel : public Aktion
 {
-private:
-    Aktion *level;
-    Aktion *spieler;
-
 public:
-    SpielerSetLevel( Aktion *level, Aktion *spieler );
+    // level, spieler
+    SpielerSetLevel( RCArray< Aktion > *subActions );
     ~SpielerSetLevel();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerGiveItem : public Aktion
 {
-private:
-    Aktion *item;
-    Aktion *anzahl;
-    Aktion *spieler;
-
 public:
-    SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
+    // item, anzahl, spieler
+    SpielerGiveItem( RCArray< Aktion > *subActions );
     ~SpielerGiveItem();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerRemoveItem : public Aktion
 {
-private:
-    Aktion *item;
-    Aktion *anzahl;
-    Aktion *spieler;
-
 public:
-    SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
+    // item, anzahl, spieler
+    SpielerRemoveItem( RCArray< Aktion > *subActions );
     ~SpielerRemoveItem();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLeben : public Aktion
 {
-private:
-    Aktion *leben;
-    Aktion *spieler;
-
 public:
-    SpielerSetLeben( Aktion *leben, Aktion *spieler );
+    // leben, spieler
+    SpielerSetLeben( RCArray< Aktion > *subActions );
     ~SpielerSetLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetMaxLeben : public Aktion
 {
-private:
-    Aktion *leben;
-    Aktion *spieler;
-
 public:
-    SpielerSetMaxLeben( Aktion *leben, Aktion *spieler );
+    // leben, spieler
+    SpielerSetMaxLeben( RCArray< Aktion > *subActions );
     ~SpielerSetMaxLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetErfahrung : public Aktion
 {
-private:
-    Aktion *erfahrung;
-    Aktion *spieler;
-
 public:
-    SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler );
+    // erfahrung, spieler
+    SpielerSetErfahrung( RCArray< Aktion > *subActions );
     ~SpielerSetErfahrung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetMaxErfahrung : public Aktion
 {
-private:
-    Aktion *erfahrung;
-    Aktion *spieler;
-
 public:
-    SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler );
+    // erfahrung, spieler
+    SpielerSetMaxErfahrung( RCArray< Aktion > *subActions );
     ~SpielerSetMaxErfahrung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetTempo : public Aktion
 {
-private:
-    Aktion *tempo;
-    Aktion *spieler;
-
 public:
-    SpielerSetTempo( Aktion *tempo, Aktion *spieler );
+    // tempo, spieler
+    SpielerSetTempo( RCArray< Aktion > *subActions );
     ~SpielerSetTempo();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetWaffenTempo : public Aktion
 {
-private:
-    Aktion *tempo;
-    Aktion *spieler;
-
 public:
-    SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler );
+    // tempo, spieler
+    SpielerSetWaffenTempo( RCArray< Aktion > *subActions );
     ~SpielerSetWaffenTempo();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetArmor : public Aktion
 {
-private:
-    Aktion *armor;
-    Aktion *spieler;
-
 public:
-    SpielerSetArmor( Aktion *armor, Aktion *spieler );
+    // armor, spieler
+    SpielerSetArmor( RCArray< Aktion > *subActions );
     ~SpielerSetArmor();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetSchadenBonus : public Aktion
 {
-private:
-    Aktion *bonus;
-    Aktion *spieler;
-
 public:
-    SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler );
+    // bonus, spieler
+    SpielerSetSchadenBonus( RCArray< Aktion > *subActions );
     ~SpielerSetSchadenBonus();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLebensraub : public Aktion
 {
-private:
-    Aktion *lebensraub;
-    Aktion *spieler;
-
 public:
-    SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler );
+    // lebensrauf, spieler
+    SpielerSetLebensraub( RCArray< Aktion > *subActions );
     ~SpielerSetLebensraub();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLebensregeneration : public Aktion
 {
-private:
-    Aktion *regeneration;
-    Aktion *spieler;
-
 public:
-    SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler );
+    // regeneration, spieler
+    SpielerSetLebensregeneration( RCArray< Aktion > *subActions );
     ~SpielerSetLebensregeneration();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetAbklingzeitverringerung : public Aktion
 {
-private:
-    Aktion *verringerung;
-    Aktion *spieler;
-
 public:
-    SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler );
+    // verringerung, spieler
+    SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions );
     ~SpielerSetAbklingzeitverringerung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetTime : public Aktion
 {
-private:
-    Aktion *time;
-    Aktion *drop;
-
 public:
-    DropSetTime( Aktion *time, Aktion *drop );
+    // time, drop
+    DropSetTime( RCArray< Aktion > *subActions );
     ~DropSetTime();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetMaxTime : public Aktion
 {
-private:
-    Aktion *time;
-    Aktion *drop;
-
 public:
-    DropSetMaxTime( Aktion *time, Aktion *drop );
+    // time, drop
+    DropSetMaxTime( RCArray< Aktion > *subActions );
     ~DropSetMaxTime();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetArea : public Aktion
 {
-private:
-    Aktion *minX;
-    Aktion *maxX;
-    Aktion *minY;
-    Aktion *maxY;
-    Aktion *drop;
-
 public:
-    DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop );
+    // minX, maxX, minY, maxY, drop
+    DropSetArea( RCArray< Aktion > *subActions );
     ~DropSetArea();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropDoDrop : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    DropDoDrop( Aktion *drop );
+    // drop
+    DropDoDrop( RCArray< Aktion > *subActions );
     ~DropDoDrop();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereBewegung : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    BariereBewegung( Aktion *bariere );
+    // bariere
+    BariereBewegung( RCArray< Aktion > *subActions );
     ~BariereBewegung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereSetEingeschaltet : public Aktion
 {
-private:
-    Aktion *eingeschaltet;
-    Aktion *bariere;
-
 public:
-    BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere );
+    // eingeschaltet, bariere
+    BariereSetEingeschaltet( RCArray< Aktion > *subActions );
     ~BariereSetEingeschaltet();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GameObjektSetPosition : public Aktion
 {
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *objekt;
-
 public:
-    GameObjektSetPosition( Aktion *x, Aktion *y, Aktion *objekt );
+    // x, y, objekt
+    GameObjektSetPosition( RCArray< Aktion > *subActions );
     ~GameObjektSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GameObjektSetSize : public Aktion
 {
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *objekt;
-
 public:
-    GameObjektSetSize( Aktion *x, Aktion *y, Aktion *objekt );
+    // x, y, objekt
+    GameObjektSetSize( RCArray< Aktion > *subActions );
     ~GameObjektSetSize();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereSetTeam : public Aktion
 {
-private:
-    Aktion *team;
-    Aktion *bariere;
-
 public:
-    BariereSetTeam( Aktion *team, Aktion *bariere );
+    // team, bariere
+    BariereSetTeam( RCArray< Aktion > *subActions );
     ~BariereSetTeam();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class SchalterSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *schalter;
-
-public:
-    SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter );
-    ~SchalterSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterSetErlaubt : public Aktion
 {
-private:
-    Aktion *erlaubt;
-    Aktion *schalter;
-
 public:
-    SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter );
+    // erlaubt, schalter
+    SchalterSetErlaubt( RCArray< Aktion > *subActions );
     ~SchalterSetErlaubt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterAktivieren : public Aktion
 {
-private:
-    Aktion *schalter;
-
 public:
-    SchalterAktivieren( Aktion *schalter );
+    // schalter
+    SchalterAktivieren( RCArray< Aktion > *subActions );
     ~SchalterAktivieren();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class TunnelSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *tunnel;
-
-public:
-    TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel );
-    ~TunnelSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelSetZielPosition : public Aktion
 {
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *tunnel;
-
 public:
-    TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel );
+    // x, y, tunnel
+    TunnelSetZielPosition( RCArray< Aktion > *subActions );
     ~TunnelSetZielPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelSetErlaubt : public Aktion
 {
-private:
-    Aktion *erlaubt;
-    Aktion *tunnel;
-
 public:
-    TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel );
+    // erlaubt, tunnel
+    TunnelSetErlaubt( RCArray< Aktion > *subActions );
     ~TunnelSetErlaubt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class UmlenkungSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *umlenkung;
-
-public:
-    UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung );
-    ~UmlenkungSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetRichtung : public Aktion
 {
-private:
-    Aktion *richtung;
-    Aktion *umlenkung;
-
 public:
-    UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung );
+    // richtung, umlenkung
+    UmlenkungSetRichtung( RCArray< Aktion > *subActions );
     ~UmlenkungSetRichtung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetMaxAbk : public Aktion
@@ -797,9 +649,10 @@ private:
     Aktion *umlenkung;
 
 public:
-    UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung );
+    // abk, umlenkung
+    UmlenkungSetMaxAbk( RCArray< Aktion > *subActions );
     ~UmlenkungSetMaxAbk();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetEnabled : public Aktion
@@ -809,1611 +662,1305 @@ private:
     Aktion *umlenkung;
 
 public:
-    UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung );
+    // enabled, umlenkung
+    UmlenkungSetEnabled( RCArray< Aktion > *subActions );
     ~UmlenkungSetEnabled();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class BaseSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *base;
-
-public:
-    BaseSetPosition( Aktion *x, Aktion *y, Aktion *base );
-    ~BaseSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseSetTeam : public Aktion
 {
-private:
-    Aktion *team;
-    Aktion *base;
-
 public:
-    BaseSetTeam( Aktion *team, Aktion *base );
+    // team, base
+    BaseSetTeam( RCArray< Aktion > *subActions );
     ~BaseSetTeam();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerRunStart : public Aktion
 {
-private:
-    Aktion *trigger;
-
 public:
-    TriggerRunStart( Aktion *trigger );
+    // trigger
+    TriggerRunStart( RCArray< Aktion > *subActions );
     ~TriggerRunStart();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerSetEnabled : public Aktion
 {
-private:
-    Aktion *enabled;
-    Aktion *trigger;
-
 public:
-    TriggerSetEnabled( Aktion *enabled, Aktion *trigger );
+    // enabled, trigger
+    TriggerSetEnabled( RCArray< Aktion > *subActions );
     ~TriggerSetEnabled();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamSetPunkte : public Aktion
 {
-private:
-    Aktion *punkte;
-    Aktion *team;
-
 public:
-    TeamSetPunkte( Aktion *punkte, Aktion *team );
+    // punkte, team
+    TeamSetPunkte( RCArray< Aktion > *subActions );
     ~TeamSetPunkte();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class TimerSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *timer;
-
-public:
-    TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer );
-    ~TimerSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetPause : public Aktion
 {
-private:
-    Aktion *pause;
-    Aktion *timer;
-
 public:
-    TimerSetPause( Aktion *pause, Aktion *timer );
+    // pause, timer
+    TimerSetPause( RCArray< Aktion > *subActions );
     ~TimerSetPause();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerStart : public Aktion
 {
-private:
-    Aktion *timer;
-
 public:
-    TimerStart( Aktion *timer );
+    // timer
+    TimerStart( RCArray< Aktion > *subActions );
     ~TimerStart();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetZeit : public Aktion
 {
-private:
-    Aktion *zeit;
-    Aktion *timer;
-
 public:
-    TimerSetZeit( Aktion *zeit, Aktion *timer );
+    // zeit, timer
+    TimerSetZeit( RCArray< Aktion > *subActions );
     ~TimerSetZeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetSichtbar : public Aktion
 {
-private:
-    Aktion *sichtbar;
-    Aktion *timer;
-
 public:
-    TimerSetSichtbar( Aktion *sichtbar, Aktion *timer );
+    // sichtbar, timer
+    TimerSetSichtbar( RCArray< Aktion > *subActions );
     ~TimerSetSichtbar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossNeu : public Aktion
 {
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *typ;
-    Aktion *richtung;
-
 public:
-    GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung );
+    // x, y, typ, richtung
+    GeschossNeu( RCArray< Aktion > *subActions );
     ~GeschossNeu();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class GeschossSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *geschoss;
-
-public:
-    GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss );
-    ~GeschossSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetSpeed : public Aktion
 {
-private:
-    Aktion *speed;
-    Aktion *geschoss;
-
 public:
-    GeschossSetSpeed( Aktion *speed, Aktion *geschoss );
+    // speed, geschoss
+    GeschossSetSpeed( RCArray< Aktion > *subActions );
     ~GeschossSetSpeed();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetPlayer : public Aktion
 {
-private:
-    Aktion *player;
-    Aktion *geschoss;
-
 public:
-    GeschossSetPlayer( Aktion *player, Aktion *geschoss );
+    // player, geschoss
+    GeschossSetPlayer( RCArray< Aktion > *subActions );
     ~GeschossSetPlayer();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetRichtung : public Aktion
 {
-private:
-    Aktion *richtung;
-    Aktion *geschoss;
-
 public:
-    GeschossSetRichtung( Aktion *richtung, Aktion *geschoss );
+    // richtung, geschoss
+    GeschossSetRichtung( RCArray< Aktion > *subActions );
     ~GeschossSetRichtung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetType : public Aktion
 {
-private:
-    Aktion *type;
-    Aktion *geschoss;
-
 public:
-    GeschossSetType( Aktion *type, Aktion *geschoss );
+    // typ, geschoss
+    GeschossSetType( RCArray< Aktion > *subActions );
     ~GeschossSetType();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerZufall : public Aktion
 {
 public:
     TriggerZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerLastRunned : public Aktion
 {
 public:
     TriggerLastRunned();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZufall : public Aktion
 {
 public:
     BariereZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztEingeschaltet : public Aktion
 {
 public:
     BariereZuletztEingeschaltet();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztAusgeschaltet : public Aktion
 {
 public:
     BariereZuletztAusgeschaltet();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztBewegt : public Aktion
 {
 public:
     BariereZuletztBewegt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseZufall : public Aktion
 {
 public:
     BaseZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseZuletztBesitzerGewechselt : public Aktion
 {
 public:
     BaseZuletztBesitzerGewechselt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropZufall : public Aktion
 {
 public:
     DropZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropZuletztGedropt : public Aktion
 {
 public:
     DropZuletztGedropt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerRechnen : public Aktion
 {
 private:
-    Aktion *left;
-    Aktion *right;
     Operator op;
 
 public:
-    IntegerRechnen( Aktion *left, Aktion *right, Operator op );
+    // left, right
+    IntegerRechnen( RCArray< Aktion > *subActions, Operator op );
     ~IntegerRechnen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerZufall : public Aktion
 {
-private:
-    Aktion *min;
-    Aktion *max;
-
 public:
-    IntegerZufall( Aktion *min, Aktion *max );
+    // min, max
+    IntegerZufall( RCArray< Aktion > *subActions );
     ~IntegerZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerAusText : public Aktion
 {
-private:
-    Aktion *text;
-
 public:
-    IntegerAusText( Aktion *text );
+    // text
+    IntegerAusText( RCArray< Aktion > *subActions );
     ~IntegerAusText();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatXVonGameObjekt : public Aktion
 {
-private:
-    Aktion *objekt;
-
 public:
-    FloatXVonGameObjekt( Aktion *objekt );
+    // objekt
+    FloatXVonGameObjekt( RCArray< Aktion > *subActions );
     ~FloatXVonGameObjekt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatYVonGameObjekt : public Aktion
 {
-private:
-    Aktion *objekt;
-
 public:
-    FloatYVonGameObjekt( Aktion *objekt );
+    // objekt
+    FloatYVonGameObjekt( RCArray< Aktion > *subActions );
     ~FloatYVonGameObjekt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonTunnelZiel : public Aktion
 {
-private:
-    Aktion *tunnel;
-
 public:
-    IntegerXVonTunnelZiel( Aktion *tunnel );
+    // tunnel
+    IntegerXVonTunnelZiel( RCArray< Aktion > *subActions );
     ~IntegerXVonTunnelZiel();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonTunnelZiel : public Aktion
 {
-private:
-    Aktion *tunnel;
-
 public:
-    IntegerYVonTunnelZiel( Aktion *tunnel );
+    // tunnel
+    IntegerYVonTunnelZiel( RCArray< Aktion > *subActions );
     ~IntegerYVonTunnelZiel();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMinXVonDrop : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    IntegerMinXVonDrop( Aktion *drop );
+    // drop
+    IntegerMinXVonDrop( RCArray< Aktion > *subActions );
     ~IntegerMinXVonDrop();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMinYVonDrop : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    IntegerMinYVonDrop( Aktion *drop );
+    // drop
+    IntegerMinYVonDrop( RCArray< Aktion > *subActions );
     ~IntegerMinYVonDrop();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMaxXVonDrop : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    IntegerMaxXVonDrop( Aktion *drop );
+    // drop
+    IntegerMaxXVonDrop( RCArray< Aktion > *subActions );
     ~IntegerMaxXVonDrop();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMaxYVonDrop : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    IntegerMaxYVonDrop( Aktion *drop );
+    // drop
+    IntegerMaxYVonDrop( RCArray< Aktion > *subActions );
     ~IntegerMaxYVonDrop();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerLevel : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerLevel( Aktion *spieler );
+    // spieler
+    IntegerSpielerLevel( RCArray< Aktion > *subActions );
     ~IntegerSpielerLevel();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerLeben : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerLeben( Aktion *spieler );
+    // spieler
+    FloatSpielerLeben( RCArray< Aktion > *subActions );
     ~FloatSpielerLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerMaxLeben : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerMaxLeben( Aktion *spieler );
+    // spieler
+    IntegerSpielerMaxLeben( RCArray< Aktion > *subActions );
     ~IntegerSpielerMaxLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerErfahrung : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerErfahrung( Aktion *spieler );
+    // spieler
+    FloatSpielerErfahrung( RCArray< Aktion > *subActions );
     ~FloatSpielerErfahrung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerMaxErfahrung : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerMaxErfahrung( Aktion *spieler );
+    // spieler
+    IntegerSpielerMaxErfahrung( RCArray< Aktion > *subActions );
     ~IntegerSpielerMaxErfahrung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerTempo : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerTempo( Aktion *spieler );
+    // spieler
+    FloatSpielerTempo( RCArray< Aktion > *subActions );
     ~FloatSpielerTempo();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerGeschossTempo : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerGeschossTempo( Aktion *spieler );
+    // spieler
+    FloatSpielerGeschossTempo( RCArray< Aktion > *subActions );
     ~FloatSpielerGeschossTempo();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerArmor : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerArmor( Aktion *spieler );
+    // spieler
+    FloatSpielerArmor( RCArray< Aktion > *subActions );
     ~FloatSpielerArmor();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerSchadenBonus : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerSchadenBonus( Aktion *spieler );
+    // spieler
+    FloatSpielerSchadenBonus( RCArray< Aktion > *subActions );
     ~FloatSpielerSchadenBonus();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerLebensraub : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerLebensraub( Aktion *spieler );
+    // spieler
+    FloatSpielerLebensraub( RCArray< Aktion > *subActions );
     ~FloatSpielerLebensraub();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerLebensregeneration : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerLebensregeneration( Aktion *spieler );
+    // spieler
+    FloatSpielerLebensregeneration( RCArray< Aktion > *subActions );
     ~FloatSpielerLebensregeneration();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerAbklingzeitVerringerung : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerAbklingzeitVerringerung( Aktion *spieler );
+    // spieler
+    FloatSpielerAbklingzeitVerringerung( RCArray< Aktion > *subActions );
     ~FloatSpielerAbklingzeitVerringerung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTode : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerTode( Aktion *spieler );
+    // spieler
+    IntegerSpielerTode( RCArray< Aktion > *subActions );
     ~IntegerSpielerTode();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerKills : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerKills( Aktion *spieler );
+    // spieler
+    IntegerSpielerKills( RCArray< Aktion > *subActions );
     ~IntegerSpielerKills();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTreffer : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerTreffer( Aktion *spieler );
+    // spieler
+    IntegerSpielerTreffer( RCArray< Aktion > *subActions );
     ~IntegerSpielerTreffer();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGetroffen : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerGetroffen( Aktion *spieler );
+    // spieler
+    IntegerSpielerGetroffen( RCArray< Aktion > *subActions );
     ~IntegerSpielerGetroffen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerErlittenerSchaden : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerErlittenerSchaden( Aktion *spieler );
+    // spieler
+    FloatSpielerErlittenerSchaden( RCArray< Aktion > *subActions );
     ~FloatSpielerErlittenerSchaden();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerSchaden : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerSchaden( Aktion *spieler );
+    // spieler
+    FloatSpielerSchaden( RCArray< Aktion > *subActions );
     ~FloatSpielerSchaden();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatSpielerGeheiltesLeben : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    FloatSpielerGeheiltesLeben( Aktion *spieler );
+    // spieler
+    FloatSpielerGeheiltesLeben( RCArray< Aktion > *subActions );
     ~FloatSpielerGeheiltesLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsAufgehoben : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerItemsAufgehoben( Aktion *spieler );
+    // spieler
+    IntegerSpielerItemsAufgehoben( RCArray< Aktion > *subActions );
     ~IntegerSpielerItemsAufgehoben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsVerwendet : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerItemsVerwendet( Aktion *spieler );
+    // spieler
+    IntegerSpielerItemsVerwendet( RCArray< Aktion > *subActions );
     ~IntegerSpielerItemsVerwendet();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsInInventar : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerItemsInInventar( Aktion *spieler );
+    // spieler
+    IntegerSpielerItemsInInventar( RCArray< Aktion > *subActions );
     ~IntegerSpielerItemsInInventar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsTypeInInventar : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *item;
-
 public:
-    IntegerSpielerItemsTypeInInventar( Aktion *item, Aktion *spieler );
+    // item, spieler
+    IntegerSpielerItemsTypeInInventar( RCArray< Aktion > *subActions );
     ~IntegerSpielerItemsTypeInInventar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTunnelBenutzt : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerTunnelBenutzt( Aktion *spieler );
+    // spieler
+    IntegerSpielerTunnelBenutzt( RCArray< Aktion > *subActions );
     ~IntegerSpielerTunnelBenutzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerSchalterAktiviert : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerSchalterAktiviert( Aktion *spieler );
+    // spieler
+    IntegerSpielerSchalterAktiviert( RCArray< Aktion > *subActions );
     ~IntegerSpielerSchalterAktiviert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGeschossen : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    IntegerSpielerGeschossen( Aktion *spieler );
+    // spieler
+    IntegerSpielerGeschossen( RCArray< Aktion > *subActions );
     ~IntegerSpielerGeschossen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatDropZeit : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    FloatDropZeit( Aktion *drop );
+    // drop
+    FloatDropZeit( RCArray< Aktion > *subActions );
     ~FloatDropZeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerDropMaxZeit : public Aktion
 {
-private:
-    Aktion *drop;
-
 public:
-    IntegerDropMaxZeit( Aktion *drop );
+    // drop
+    IntegerDropMaxZeit( RCArray< Aktion > *subActions );
     ~IntegerDropMaxZeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatGameObjektBreite : public Aktion
 {
-private:
-    Aktion *objekt;
-
 public:
-    FloatGameObjektBreite( Aktion *objekt );
+    // objekt
+    FloatGameObjektBreite( RCArray< Aktion > *subActions );
     ~FloatGameObjektBreite();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatGameObjektHeight : public Aktion
 {
-private:
-    Aktion *objekt;
-
 public:
-    FloatGameObjektHeight( Aktion *objekt );
+    // objekt
+    FloatGameObjektHeight( RCArray< Aktion > *subActions );
     ~FloatGameObjektHeight();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereVerschiebungen : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    IntegerBariereVerschiebungen( Aktion *bariere );
+    // bariere
+    IntegerBariereVerschiebungen( RCArray< Aktion > *subActions );
     ~IntegerBariereVerschiebungen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereSchaltungen : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    IntegerBariereSchaltungen( Aktion *bariere );
+    // bariere
+    IntegerBariereSchaltungen( RCArray< Aktion > *subActions );
     ~IntegerBariereSchaltungen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSchalterAktivierungen : public Aktion
 {
-private:
-    Aktion *schalter;
-
 public:
-    IntegerSchalterAktivierungen( Aktion *schalter );
+    // schalter
+    IntegerSchalterAktivierungen( RCArray< Aktion > *subActions );
     ~IntegerSchalterAktivierungen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTunnelBenutzungen : public Aktion
 {
-private:
-    Aktion *tunnel;
-
 public:
-    IntegerTunnelBenutzungen( Aktion *tunnel );
+    // tunnel
+    IntegerTunnelBenutzungen( RCArray< Aktion > *subActions );
     ~IntegerTunnelBenutzungen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerUmlenkungBenutzungen : public Aktion
 {
-private:
-    Aktion *umlenkung;
-
 public:
-    IntegerUmlenkungBenutzungen( Aktion *umlenkung );
+    // umlenkung
+    IntegerUmlenkungBenutzungen( RCArray< Aktion > *subActions );
     ~IntegerUmlenkungBenutzungen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamPunkte : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    IntegerTeamPunkte( Aktion *team );
+    // team
+    IntegerTeamPunkte( RCArray< Aktion > *subActions );
     ~IntegerTeamPunkte();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamKills : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    IntegerTeamKills( Aktion *team );
+    // team
+    IntegerTeamKills( RCArray< Aktion > *subActions );
     ~IntegerTeamKills();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamTode : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    IntegerTeamTode( Aktion *team );
+    // team
+    IntegerTeamTode( RCArray< Aktion > *subActions );
     ~IntegerTeamTode();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatTeamWiederbelegungszeit : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    FloatTeamWiederbelegungszeit( Aktion *team );
+    // team
+    FloatTeamWiederbelegungszeit( RCArray< Aktion > *subActions );
     ~FloatTeamWiederbelegungszeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamSpieleranzahl : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    IntegerTeamSpieleranzahl( Aktion *team );
+    // team
+    IntegerTeamSpieleranzahl( RCArray< Aktion > *subActions );
     ~IntegerTeamSpieleranzahl();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatTimerAktuelleZeit : public Aktion
 {
-private:
-    Aktion *timer;
-
 public:
-    FloatTimerAktuelleZeit( Aktion *timer );
+    // timer
+    FloatTimerAktuelleZeit( RCArray< Aktion > *subActions );
     ~FloatTimerAktuelleZeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTimerMaxZeit : public Aktion
 {
-private:
-    Aktion *timer;
-
 public:
-    IntegerTimerMaxZeit( Aktion *timer );
+    // timer
+    IntegerTimerMaxZeit( RCArray< Aktion > *subActions );
     ~IntegerTimerMaxZeit();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTriggerRunns : public Aktion
 {
-private:
-    Aktion *trigger;
-
 public:
-    IntegerTriggerRunns( Aktion *trigger );
+    // trigger
+    IntegerTriggerRunns( RCArray< Aktion > *subActions );
     ~IntegerTriggerRunns();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemSpielerInventar : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *index;
-
 public:
-    ItemSpielerInventar( Aktion *index, Aktion *spieler );
+    // index, spieler
+    ItemSpielerInventar( RCArray< Aktion > *subActions );
     ~ItemSpielerInventar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztAufgehoben : public Aktion
 {
 public:
     ItemZuletztAufgehoben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztAktiviert : public Aktion
 {
 public:
     ItemZuletztAktiviert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztGedropt : public Aktion
 {
 public:
     ItemZuletztGedropt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZufall : public Aktion
 {
 public:
     ItemZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZufall : public Aktion
 {
 public:
     GeschossZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztAbgefeuert : public Aktion
 {
 public:
     GeschossZuletztAbgefeuert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztUmgelenkt : public Aktion
 {
 public:
     GeschossZuletztUmgelenkt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztBarjereGetroffen : public Aktion
 {
 public:
     GeschossZuletztBarjereGetroffen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztTunnelBenutzt : public Aktion
 {
 public:
     GeschossZuletztTunnelBenutzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztGeschossGetroffen : public Aktion
 {
 public:
     GeschossZuletztGeschossGetroffen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungZufall : public Aktion
 {
 public:
     RichtungZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungVonUmlenkung : public Aktion
 {
-private:
-    Aktion *umlenkung;
-
 public:
-    RichtungVonUmlenkung( Aktion *umlenkung );
+    // umlenkung
+    RichtungVonUmlenkung( RCArray< Aktion > *subActions );
     ~RichtungVonUmlenkung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungVonGeschoss : public Aktion
 {
-private:
-    Aktion *geschoss;
-
 public:
-    RichtungVonGeschoss( Aktion *geschoss );
+    // geschoss
+    RichtungVonGeschoss( RCArray< Aktion > *subActions );
     ~RichtungVonGeschoss();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterZufall : public Aktion
 {
 public:
     SchalterZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterZuletztAktiviert : public Aktion
 {
 public:
     SchalterZuletztAktiviert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZufall : public Aktion
 {
 public:
     SpielerZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZufallAusTeam : public Aktion
 {
-private:
-    Aktion *team;
-
 public:
-    SpielerZufallAusTeam( Aktion *team );
+    // team
+    SpielerZufallAusTeam( RCArray< Aktion > *subActions );
     ~SpielerZufallAusTeam();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchadenGemacht : public Aktion
 {
 public:
     SpielerZuletztSchadenGemacht();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchadenGenommen : public Aktion
 {
 public:
     SpielerZuletztSchadenGenommen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGeheilt : public Aktion
 {
 public:
     SpielerZuletztGeheilt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztLevelUp : public Aktion
 {
 public:
     SpielerZuletztLevelUp();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztErfahrungBekommen : public Aktion
 {
 public:
     SpielerZuletztErfahrungBekommen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGegenstandAktiviert : public Aktion
 {
 public:
     SpielerZuletztGegenstandAktiviert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGegenstandAufgehoben : public Aktion
 {
 public:
     SpielerZuletztGegenstandAufgehoben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchalterAktiviert : public Aktion
 {
 public:
     SpielerZuletztSchalterAktiviert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztTunnelBenutzt : public Aktion
 {
 public:
     SpielerZuletztTunnelBenutzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGestorben : public Aktion
 {
 public:
     SpielerZuletztGestorben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztWiederbelebent : public Aktion
 {
 public:
     SpielerZuletztWiederbelebent();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGeschossGeschossen : public Aktion
 {
 public:
     SpielerZuletztGeschossGeschossen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextConcat : public Aktion
 {
-private:
-    Aktion *t1;
-    Aktion *t2;
-
 public:
-    TextConcat( Aktion *t1, Aktion *t2 );
+    // t1, t2
+    TextConcat( RCArray< Aktion > *subActions );
     ~TextConcat();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusInteger : public Aktion
 {
-private:
-    Aktion *zahl;
-
 public:
-    TextAusInteger( Aktion *zahl );
+    // integer
+    TextAusInteger( RCArray< Aktion > *subActions );
     ~TextAusInteger();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusRichtung : public Aktion
 {
-private:
-    Aktion *richtung;
-
 public:
-    TextAusRichtung( Aktion *richtung );
+    // richtung
+    TextAusRichtung( RCArray< Aktion > *subActions );
     ~TextAusRichtung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusBoolean : public Aktion
 {
-private:
-    Aktion *boolean;
-
 public:
-    TextAusBoolean( Aktion *boolean );
+    // boolean
+    TextAusBoolean( RCArray< Aktion > *subActions );
     ~TextAusBoolean();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextSpielerName : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    TextSpielerName( Aktion *spieler );
+    // spieler
+    TextSpielerName( RCArray< Aktion > *subActions );
     ~TextSpielerName();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextItemName : public Aktion
 {
-private:
-    Aktion *item;
-
 public:
-    TextItemName( Aktion *item );
+    // item
+    TextItemName( RCArray< Aktion > *subActions );
     ~TextItemName();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextTriggerName : public Aktion
 {
-private:
-    Aktion *trigger;
-
 public:
-    TextTriggerName( Aktion *trigger );
+    // trigger
+    TextTriggerName( RCArray< Aktion > *subActions );
     ~TextTriggerName();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextTeilVonText : public Aktion
 {
-private:
-    Aktion *start;
-    Aktion *ende;
-    Aktion *text;
-
 public:
-    TextTeilVonText( Aktion *start, Aktion *ende, Aktion *text );
+    // start, ende, text
+    TextTeilVonText( RCArray< Aktion > *subActions );
     ~TextTeilVonText();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamZufall : public Aktion
 {
 public:
     TeamZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamVonSpieler : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    TeamVonSpieler( Aktion *spieler );
+    // spieler
+    TeamVonSpieler( RCArray< Aktion > *subActions );
     ~TeamVonSpieler();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamVonBariere : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    TeamVonBariere( Aktion *bariere );
+    // bariere
+    TeamVonBariere( RCArray< Aktion > *subActions );
     ~TeamVonBariere();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZufall : public Aktion
 {
 public:
     TimerZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztAbgelaufen : public Aktion
 {
 public:
     TimerZuletztAbgelaufen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztGestartet : public Aktion
 {
 public:
     TimerZuletztGestartet();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztPausiert : public Aktion
 {
 public:
     TimerZuletztPausiert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztFortgesetzt : public Aktion
 {
 public:
     TimerZuletztFortgesetzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelZufall : public Aktion
 {
 public:
     TunnelZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelZuletztBenutzt : public Aktion
 {
 public:
     TunnelZuletztBenutzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungZufall : public Aktion
 {
 public:
     UmlenkungZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungZuletztBenutzt : public Aktion
 {
 public:
     UmlenkungZuletztBenutzt();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanZufall : public Aktion
 {
 public:
     BooleanZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielPausiert : public Aktion
 {
 public:
     BooleanSpielPausiert();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerAmLeben : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    BooleanSpielerAmLeben( Aktion *spieler );
+    // spieler
+    BooleanSpielerAmLeben( RCArray< Aktion > *subActions );
     ~BooleanSpielerAmLeben();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerHatGegenstand : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *item;
-
 public:
-    BooleanSpielerHatGegenstand( Aktion *item, Aktion *spieler );
+    // item, spieler
+    BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions );
     ~BooleanSpielerHatGegenstand();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerInTeam : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *team;
-
 public:
-    BooleanSpielerInTeam( Aktion *team, Aktion *spieler );
+    // team, spieler
+    BooleanSpielerInTeam( RCArray< Aktion > *subActions );
     ~BooleanSpielerInTeam();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerIstVerwundbar : public Aktion
 {
-private:
-    Aktion *spieler;
-
 public:
-    BooleanSpielerIstVerwundbar( Aktion *spieler );
+    // spieler
+    BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions );
     ~BooleanSpielerIstVerwundbar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerKannItemBenutzen : public Aktion
 {
-private:
-    Aktion *spieler;
-    Aktion *item;
-
 public:
-    BooleanSpielerKannItemBenutzen( Aktion *item, Aktion *spieler );
+    // item, spieler
+    BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions );
     ~BooleanSpielerKannItemBenutzen();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanUmlenkungHatAbk : public Aktion
 {
-private:
-    Aktion *umlenkung;
-
 public:
-    BooleanUmlenkungHatAbk( Aktion *umlenkung );
+    // umlenkung
+    BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions );
     ~BooleanUmlenkungHatAbk();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanUmlenkungIstDrehend : public Aktion
 {
-private:
-    Aktion *umlenkung;
-
 public:
-    BooleanUmlenkungIstDrehend( Aktion *umlenkung );
+    // umlenkung
+    BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions );
     ~BooleanUmlenkungIstDrehend();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereBewegtSich : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    BooleanBariereBewegtSich( Aktion *bariere );
+    // bariere
+    BooleanBariereBewegtSich( RCArray< Aktion > *subActions );
     ~BooleanBariereBewegtSich();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereIstSchaltend : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    BooleanBariereIstSchaltend( Aktion *bariere );
+    // bariere
+    BooleanBariereIstSchaltend( RCArray< Aktion > *subActions );
     ~BooleanBariereIstSchaltend();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereIstAktiv : public Aktion
 {
-private:
-    Aktion *bariere;
-
 public:
-    BooleanBariereIstAktiv( Aktion *bariere );
+    // bariere
+    BooleanBariereIstAktiv( RCArray< Aktion > *subActions );
     ~BooleanBariereIstAktiv();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSchalterIstAktiv : public Aktion
 {
-private:
-    Aktion *schalter;
-
 public:
-    BooleanSchalterIstAktiv( Aktion *schalter );
+    // schalter
+    BooleanSchalterIstAktiv( RCArray< Aktion > *subActions );
     ~BooleanSchalterIstAktiv();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTunnelIstAktiv : public Aktion
 {
-private:
-    Aktion *tunnel;
-
 public:
-    BooleanTunnelIstAktiv( Aktion *tunnel );
+    // tunnel
+    BooleanTunnelIstAktiv( RCArray< Aktion > *subActions );
     ~BooleanTunnelIstAktiv();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBaseIstNeutral : public Aktion
 {
-private:
-    Aktion *base;
-
 public:
-    BooleanBaseIstNeutral( Aktion *base );
+    // base
+    BooleanBaseIstNeutral( RCArray< Aktion > *subActions );
     ~BooleanBaseIstNeutral();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTimerIsRunning : public Aktion
 {
-private:
-    Aktion *timer;
-
 public:
-    BooleanTimerIsRunning( Aktion *timer );
+    BooleanTimerIsRunning( RCArray< Aktion > *subActions );
     ~BooleanTimerIsRunning();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTimerIstSichtbar : public Aktion
 {
-private:
-    Aktion *timer;
-
 public:
-    BooleanTimerIstSichtbar( Aktion *timer );
+    // timer
+    BooleanTimerIstSichtbar( RCArray< Aktion > *subActions );
     ~BooleanTimerIstSichtbar();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanAusText : public Aktion
 {
-private:
-    Aktion *text;
-
 public:
-    BooleanAusText( Aktion *text );
+    // text
+    BooleanAusText( RCArray< Aktion > *subActions );
     ~BooleanAusText();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTriggerIstAktiv : public Aktion
 {
-private:
-    Aktion *trigger;
-
 public:
-    BooleanTriggerIstAktiv( Aktion *trigger );
+    // trigger
+    BooleanTriggerIstAktiv( RCArray< Aktion > *subActions );
     ~BooleanTriggerIstAktiv();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class BooleanGleich : public Aktion
-{
-private:
-    Aktion *v1;
-    Aktion *v2;
-
-public:
-    BooleanGleich( Aktion *v1, Aktion *v2 );
-    ~BooleanGleich();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class BooleanNicht : public Aktion
-{
-private:
-    Aktion *boolean;
-
-public:
-    BooleanNicht( Aktion *boolean );
-    ~BooleanNicht();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class BooleanUnd : public Aktion
-{
-private:
-    Aktion *v1;
-    Aktion *v2;
-
-public:
-    BooleanUnd( Aktion *v1, Aktion *v2 );
-    ~BooleanUnd();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class BooleanOder : public Aktion
+class BooleanRechnung : public Aktion
 {
 private:
-    Aktion *v1;
-    Aktion *v2;
+    Operator op;
 
 public:
-    BooleanOder( Aktion *v1, Aktion *v2 );
-    ~BooleanOder();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    // v1, v2
+    BooleanRechnung( RCArray< Aktion > *subActions, Operator op );
+    ~BooleanRechnung();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class Sequenz : public Aktion
 {
-private:
-    RCArray< Aktion > *aktions;
-
 public:
     Sequenz( RCArray< Aktion > *aktions );
     ~Sequenz();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatRechnung : public Aktion
 {
 private:
-    Aktion *left;
-    Aktion *right;
     Operator op;
 
 public:
-    FloatRechnung( Aktion *left, Aktion *right, Operator op );
+    // left, right
+    FloatRechnung( RCArray< Aktion > *subActions, Operator op );
     ~FloatRechnung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatAusInteger : public Aktion
 {
-private:
-    Aktion *integer;
-
 public:
-    FloatAusInteger( Aktion *integer );
+    // integer
+    FloatAusInteger( RCArray< Aktion > *subActions );
     ~FloatAusInteger();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatAusText : public Aktion
 {
-private:
-    Aktion *text;
-
 public:
-    FloatAusText( Aktion *text );
+    // text
+    FloatAusText( RCArray< Aktion > *subActions );
     ~FloatAusText();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusFloat : public Aktion
 {
-private:
-    Aktion *f;
-
 public:
-    TextAusFloat( Aktion *f );
+    // f
+    TextAusFloat( RCArray< Aktion > *subActions );
     ~TextAusFloat();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class FloatZufall : public Aktion
 {
-private:
-    Aktion *min;
-    Aktion *max;
-
 public:
-    FloatZufall( Aktion *min, Aktion *max );
+    // min, max
+    FloatZufall( RCArray< Aktion > *subActions );
     ~FloatZufall();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerAusFloat : public Aktion
 {
-private:
-    Aktion *f;
-
 public:
-    IntegerAusFloat( Aktion *f );
+    // f
+    IntegerAusFloat( RCArray< Aktion > *subActions );
     ~IntegerAusFloat();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };

StickmanWorldOnline/Reader.cpp

@@ -36,257 +36,278 @@ Aktion *MapReader::readAktion( Datei &dat )
     dat.lese( (char *)& id, 4 );
     char pAnz = 0;
     dat.lese( &pAnz, 1 );
-    Aktion *params[ 255 ];
+    RCArray< Aktion > *params = new RCArray< Aktion >();
     for( int i = 0; i < pAnz; i++ )
-        params[ i ] = readAktion( dat );
+        params->add( readAktion( dat ) );
     switch( id )
     {
     case BARIERE_BEWEGUNG:
-        return new BariereBewegung( params[ 0 ] );
+        return new BariereBewegung( params );
     case BARIERE_SET_EINGESCHALTET:
-        return new BariereSetEingeschaltet( params[ 0 ], params[ 1 ] );
+        return new BariereSetEingeschaltet( params );
     case GAME_OBJEKT_SET_POSITION:
-        return new GameObjektSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new GameObjektSetPosition( params );
     case GAME_OBJEKT_SET_SIZE:
-        return new GameObjektSetSize( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new GameObjektSetSize( params );
     case BARIERE_SET_TEAM:
-        return new BariereSetTeam( params[ 0 ], params[ 1 ] );
+        return new BariereSetTeam( params );
     case BARIERE_ZUFALL:
+        params->release();
         return new BariereZufall();
     case BARIERE_ZULETZT_AUSGESCHALTET:
+        params->release();
         return new BariereZuletztAusgeschaltet();
     case BARIERE_ZULETZT_BEWEGT:
+        params->release();
         return new BariereZuletztBewegt();
     case BARIERE_ZULETZT_EINGESCHALTET:
+        params->release();
         return new BariereZuletztEingeschaltet();
     case BASE_SET_TEAM:
-        return new BaseSetTeam( params[ 0 ], params[ 1 ] );
+        return new BaseSetTeam( params );
     case BASE_ZUFALL:
+        params->release();
         return new BaseZufall();
     case BASE_ZULETZT_BESITZER_GEWECHSELT:
+        params->release();
         return new BaseZuletztBesitzerGewechselt();
     case BOOLEAN_AUS_TEXT:
-        return new BooleanAusText( params[ 0 ] );
+        return new BooleanAusText( params );
     case BOOLEAN_BARIERE_BEWEGT_SICH:
-        return new BooleanBariereBewegtSich( params[ 0 ] );
+        return new BooleanBariereBewegtSich( params );
     case BOOLEAN_BARIERE_IST_AKTIV:
-        return new BooleanBariereIstAktiv( params[ 0 ] );
+        return new BooleanBariereIstAktiv( params );
     case BOOLEAN_BARIERE_IST_SCHALTEND:
-        return new BooleanBariereIstSchaltend( params[ 0 ] );
+        return new BooleanBariereIstSchaltend( params );
     case BOOLEAN_BASE_IST_NEUTRAL:
-        return new BooleanBaseIstNeutral( params[ 0 ] );
-    case BOOLEAN_GLEICH:
-        return new BooleanGleich( params[ 0 ], params[ 1 ] );
-    case BOOLEAN_NICHT:
-        return new BooleanNicht( params[ 0 ] );
-    case BOOLEAN_ODER:
-        return new BooleanOder( params[ 0 ], params[ 1 ] );
+        return new BooleanBaseIstNeutral( params );
+    case BOOLEAN_RECHNUNG:
+    {
+        char op;
+        dat.lese( &op, 1 );
+        return new BooleanRechnung( params, (Operator)op );
+    }
     case BOOLEAN_SCHALTER_IST_AKTIV:
-        return new BooleanSchalterIstAktiv( params[ 0 ] );
+        return new BooleanSchalterIstAktiv( params );
     case BOOLEAN_SPIELER_AM_LEBEN:
-        return new BooleanSpielerAmLeben( params[ 0 ] );
+        return new BooleanSpielerAmLeben( params );
     case BOOLEAN_SPIELER_HAT_GEGENSTAND:
-        return new BooleanSpielerHatGegenstand( params[ 0 ], params[ 1 ] );
+        return new BooleanSpielerHatGegenstand( params );
     case BOOLEAN_SPIELER_IN_TEAM:
-        return new BooleanSpielerInTeam( params[ 0 ], params[ 1 ] );
+        return new BooleanSpielerInTeam( params );
     case BOOLEAN_SPIELER_IST_VERWUNDBAR:
-        return new BooleanSpielerIstVerwundbar( params[ 0 ] );
+        return new BooleanSpielerIstVerwundbar( params );
     case BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN:
-        return new BooleanSpielerKannItemBenutzen( params[ 0 ], params[ 1 ] );
+        return new BooleanSpielerKannItemBenutzen( params );
     case BOOLEAN_SPIEL_PAUSIERT:
+        params->release();
         return new BooleanSpielPausiert();
     case BOOLEAN_TIMER_IS_RUNNING:
-        return new BooleanTimerIsRunning( params[ 0 ] );
+        return new BooleanTimerIsRunning( params );
     case BOOLEAN_TIMER_IST_SICHTBAR:
-        return new BooleanTimerIstSichtbar( params[ 0 ] );
+        return new BooleanTimerIstSichtbar( params );
     case BOOLEAN_TRIGGER_IST_AKTIV:
-        return new BooleanTriggerIstAktiv( params[ 0 ] );
+        return new BooleanTriggerIstAktiv( params );
     case BOOLEAN_TUNNEL_IST_AKTIV:
-        return new BooleanTunnelIstAktiv( params[ 0 ] );
+        return new BooleanTunnelIstAktiv( params );
     case BOOLEAN_UMLENKUNG_HAT_ABK:
-        return new BooleanUmlenkungHatAbk( params[ 0 ] );
+        return new BooleanUmlenkungHatAbk( params );
     case BOOLEAN_UMLENKUNG_IST_DREHEND:
-        return new BooleanUmlenkungIstDrehend( params[ 0 ] );
-    case BOOLEAN_UND:
-        return new BooleanUnd( params[ 0 ], params[ 1 ] );
+        return new BooleanUmlenkungIstDrehend( params );
     case BOOLEAN_ZUFALL:
+        params->release();
         return new BooleanZufall();
     case DISPLAY_TEXT:
-        return new DisplayText( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ] );
+        return new DisplayText( params );
     case DROP_DO_DROP:
-        return new DropDoDrop( params[ 0 ] );
+        return new DropDoDrop( params );
     case DROP_SET_AREA:
-        return new DropSetArea( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ] );
+        return new DropSetArea( params );
     case DROP_SET_MAX_TIME:
-        return new DropSetMaxTime( params[ 0 ], params[ 1 ] );
+        return new DropSetMaxTime( params );
     case DROP_SET_TIME:
-        return new DropSetTime( params[ 0 ], params[ 1 ] );
+        return new DropSetTime( params );
     case DROP_ZUFALL:
+        params->release();
         return new DropZufall();
     case DROP_ZULETZT_GEDROPT:
+        params->release();
         return new DropZuletztGedropt();
     case GESCHOSS_NEU:
-        return new GeschossNeu( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ] );
+        return new GeschossNeu( params );
     case GESCHOSS_SET_PLAYER:
-        return new GeschossSetPlayer( params[ 0 ], params[ 1 ] );
+        return new GeschossSetPlayer( params );
     case GESCHOSS_SET_RICHTUNG:
-        return new GeschossSetRichtung( params[ 0 ], params[ 1 ] );
+        return new GeschossSetRichtung( params );
     case GESCHOSS_SET_SPEED:
-        return new GeschossSetSpeed( params[ 0 ], params[ 1 ] );
+        return new GeschossSetSpeed( params );
     case GESCHOSS_SET_TYPE:
-        return new GeschossSetType( params[ 0 ], params[ 1 ] );
+        return new GeschossSetType( params );
     case GESCHOSS_ZUFALL:
+        params->release();
         return new GeschossZufall();
     case GESCHOSS_ZULETZT_ABGEFEUERT:
+        params->release();
         return new GeschossZuletztAbgefeuert();
     case GESCHOSS_ZULETZT_BARIERE_GETROFFEN:
+        params->release();
         return new GeschossZuletztBarjereGetroffen();
     case GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN:
+        params->release();
         return new GeschossZuletztGeschossGetroffen();
     case GESCHOSS_ZULETZT_TUNNEL_BENUTZT:
+        params->release();
         return new GeschossZuletztTunnelBenutzt();
     case GESCHOSS_ZULETZT_UMGELENKT:
+        params->release();
         return new GeschossZuletztUmgelenkt();
     case INTEGER_AUS_TEXT:
-        return new IntegerAusText( params[ 0 ] );
+        return new IntegerAusText( params );
     case FLOAT_GAME_OBJEKT_BREITE:
-        return new FloatGameObjektBreite( params[ 0 ] );
+        return new FloatGameObjektBreite( params );
     case FLOAT_GAME_OBJEKT_HEIGHT:
-        return new FloatGameObjektHeight( params[ 0 ] );
+        return new FloatGameObjektHeight( params );
     case INTEGER_BARIERE_SCHALTUNGEN:
-        return new IntegerBariereSchaltungen( params[ 0 ] );
+        return new IntegerBariereSchaltungen( params );
     case INTEGER_BARIERE_VERSCHIEBUNGEN:
-        return new IntegerBariereVerschiebungen( params[ 0 ] );
+        return new IntegerBariereVerschiebungen( params );
     case INTEGER_DROP_MAX_ZEIT:
-        return new IntegerDropMaxZeit( params[ 0 ] );
+        return new IntegerDropMaxZeit( params );
     case FLOAT_DROP_ZEIT:
-        return new FloatDropZeit( params[ 0 ] );
+        return new FloatDropZeit( params );
     case INTEGER_MAX_X_VON_DROP:
-        return new IntegerMaxXVonDrop( params[ 0 ] );
+        return new IntegerMaxXVonDrop( params );
     case INTEGER_MAX_Y_VON_DROP:
-        return new IntegerMaxYVonDrop( params[ 0 ] );
+        return new IntegerMaxYVonDrop( params );
     case INTEGER_MIN_X_VON_DROP:
-        return new IntegerMinXVonDrop( params[ 0 ] );
+        return new IntegerMinXVonDrop( params );
     case INTEGER_MIN_Y_VON_DROP:
-        return new IntegerMinYVonDrop( params[ 0 ] );
+        return new IntegerMinYVonDrop( params );
     case INTEGER_RECHNEN:
     {
         char op;
         dat.lese( &op, 1 );
-        return new IntegerRechnen( params[ 0 ], params[ 1 ], (Operator)op );
+        return new IntegerRechnen( params, (Operator)op );
     }
     case INTEGER_SCHALTER_AKTIVIERUNGEN:
-        return new IntegerSchalterAktivierungen( params[ 0 ] );
+        return new IntegerSchalterAktivierungen( params );
     case FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG:
-        return new FloatSpielerAbklingzeitVerringerung( params[ 0 ] );
+        return new FloatSpielerAbklingzeitVerringerung( params );
     case FLOAT_SPIELER_ARMOR:
-        return new FloatSpielerArmor( params[ 0 ] );
+        return new FloatSpielerArmor( params );
     case FLOAT_SPIELER_ERFAHRUNG:
-        return new FloatSpielerErfahrung( params[ 0 ] );
+        return new FloatSpielerErfahrung( params );
     case FLOAT_SPIELER_ERLITTENER_SCHADEN:
-        return new FloatSpielerErlittenerSchaden( params[ 0 ] );
+        return new FloatSpielerErlittenerSchaden( params );
     case FLOAT_SPIELER_GEHEILTES_LEBEN:
-        return new FloatSpielerGeheiltesLeben( params[ 0 ] );
+        return new FloatSpielerGeheiltesLeben( params );
     case INTEGER_SPIELER_GESCHOSSEN:
-        return new IntegerSpielerGeschossen( params[ 0 ] );
+        return new IntegerSpielerGeschossen( params );
     case FLOAT_SPIELER_GESCHOSS_TEMPO:
-        return new FloatSpielerGeschossTempo( params[ 0 ] );
+        return new FloatSpielerGeschossTempo( params );
     case INTEGER_SPIELER_GETROFFEN:
-        return new IntegerSpielerGetroffen( params[ 0 ] );
+        return new IntegerSpielerGetroffen( params );
     case INTEGER_SPIELER_ITEMS_AUFGEHOBEN:
-        return new IntegerSpielerItemsAufgehoben( params[ 0 ] );
+        return new IntegerSpielerItemsAufgehoben( params );
     case INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR:
-        return new IntegerSpielerItemsInInventar( params[ 0 ] );
+        return new IntegerSpielerItemsInInventar( params );
     case INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP:
-        return new IntegerSpielerItemsTypeInInventar( params[ 0 ], params[ 1 ] );
+        return new IntegerSpielerItemsTypeInInventar( params );
     case INTEGER_SPIELER_ITEMS_VERWENDET:
-        return new IntegerSpielerItemsVerwendet( params[ 0 ] );
+        return new IntegerSpielerItemsVerwendet( params );
     case INTEGER_SPIELER_KILLS:
-        return new IntegerSpielerKills( params[ 0 ] );
+        return new IntegerSpielerKills( params );
     case FLOAT_SPIELER_LEBEN:
-        return new FloatSpielerLeben( params[ 0 ] );
+        return new FloatSpielerLeben( params );
     case FLOAT_SPIELER_LEBENSRAUB:
-        return new FloatSpielerLebensraub( params[ 0 ] );
+        return new FloatSpielerLebensraub( params );
     case FLOAT_SPIELER_LEBENSREGENERATION:
-        return new FloatSpielerLebensregeneration( params[ 0 ] );
+        return new FloatSpielerLebensregeneration( params );
     case INTEGER_SPIELER_LEVEL:
-        return new IntegerSpielerLevel( params[ 0 ] );
+        return new IntegerSpielerLevel( params );
     case INTEGER_SPIELER_MAX_ERFAHRUNG:
-        return new IntegerSpielerMaxErfahrung( params[ 0 ] );
+        return new IntegerSpielerMaxErfahrung( params );
     case INTEGER_SPIELER_MAX_LEBEN:
-        return new IntegerSpielerMaxLeben( params[ 0 ] );
+        return new IntegerSpielerMaxLeben( params );
     case FLOAT_SPIELER_SCHADEN:
-        return new FloatSpielerSchaden( params[ 0 ] );
+        return new FloatSpielerSchaden( params );
     case FLOAT_SPIELER_SCHADEN_BONUS:
-        return new FloatSpielerSchadenBonus( params[ 0 ] );
+        return new FloatSpielerSchadenBonus( params );
     case INTEGER_SPIELER_SCHALTER_AKTIVIERT:
-        return new IntegerSpielerSchalterAktiviert( params[ 0 ] );
+        return new IntegerSpielerSchalterAktiviert( params );
     case FLOAT_SPIELER_TEMPO:
-        return new FloatSpielerTempo( params[ 0 ] );
+        return new FloatSpielerTempo( params );
     case INTEGER_SPIELER_TODE:
-        return new IntegerSpielerTode( params[ 0 ] );
+        return new IntegerSpielerTode( params );
     case INTEGER_SPIELER_TREFFER:
-        return new IntegerSpielerTreffer( params[ 0 ] );
+        return new IntegerSpielerTreffer( params );
     case INTEGER_SPIELER_TUNNEL_BENUTZT:
-        return new IntegerSpielerTunnelBenutzt( params[ 0 ] );
+        return new IntegerSpielerTunnelBenutzt( params );
     case INTEGER_TEAM_KILLS:
-        return new IntegerTeamKills( params[ 0 ] );
+        return new IntegerTeamKills( params );
     case INTEGER_TEAM_PUNKTE:
-        return new IntegerTeamPunkte( params[ 0 ] );
+        return new IntegerTeamPunkte( params );
     case INTEGER_TEAM_SPIELERANZAHL:
-        return new IntegerTeamSpieleranzahl( params[ 0 ] );
+        return new IntegerTeamSpieleranzahl( params );
     case INTEGER_TEAM_TODE:
-        return new IntegerTeamTode( params[ 0 ] );
+        return new IntegerTeamTode( params );
     case FLOAT_TEAM_WIEDERBELEBUNGSZEIT:
-        return new FloatTeamWiederbelegungszeit( params[ 0 ] );
+        return new FloatTeamWiederbelegungszeit( params );
     case FLOAT_TIMER_AKTUELLE_ZEIT:
-        return new FloatTimerAktuelleZeit( params[ 0 ] );
+        return new FloatTimerAktuelleZeit( params );
     case INTEGER_TIMER_MAX_ZEIT:
-        return new IntegerTimerMaxZeit( params[ 0 ] );
+        return new IntegerTimerMaxZeit( params );
     case INTEGER_TRIGGER_RUNNS:
-        return new IntegerTriggerRunns( params[ 0 ] );
+        return new IntegerTriggerRunns( params );
     case INTEGER_TUNNEL_BENUTZUNGEN:
-        return new IntegerTunnelBenutzungen( params[ 0 ] );
+        return new IntegerTunnelBenutzungen( params );
     case INTEGER_UMLENKUNG_BENUTZUNGEN:
-        return new IntegerUmlenkungBenutzungen( params[ 0 ] );
+        return new IntegerUmlenkungBenutzungen( params );
     case FLOAT_X_VON_GAME_OBJEKT:
-        return new FloatXVonGameObjekt( params[ 0 ] );
+        return new FloatXVonGameObjekt( params );
     case FLOAT_Y_VON_GAME_OBJEKT:
-        return new FloatYVonGameObjekt( params[ 0 ] );
+        return new FloatYVonGameObjekt( params );
     case INTEGER_X_VON_TUNNEL_ZIEL:
-        return new IntegerXVonTunnelZiel( params[ 0 ] );
+        return new IntegerXVonTunnelZiel( params );
     case INTEGER_Y_VON_TUNNEL_ZIEL:
-        return new IntegerYVonTunnelZiel( params[ 0 ] );
+        return new IntegerYVonTunnelZiel( params );
     case INTEGER_ZUFALL:
-        return new IntegerZufall( params[ 0 ], params[ 1 ] );
+        return new IntegerZufall( params );
     case ITEM_SPIELER_INVENTAR:
-        return new ItemSpielerInventar( params[ 0 ], params[ 1 ] );
+        return new ItemSpielerInventar( params );
     case ITEM_ZULETZT_AUFGEHOBEN:
+        params->release();
         return new ItemZuletztAufgehoben();
     case ITEM_ZULETZT_GEDROPT:
+        params->release();
         return new ItemZuletztGedropt();
     case KONSTANT_BOOLEAN:
     {
+        params->release();
         bool b;
         dat.lese( (char *)& b, 1 );
         return new KonstantBoolean( b );
     }
     case KONSTANT_FLOAT:
     {
+        params->release();
         float f;
         dat.lese( (char *)& f, 4 );
         return new KonstantFloat( f );
     }
     case KONSTANT_INTEGER:
     {
+        params->release();
         int i;
         dat.lese( (char *)& i, 4 );
         return new KonstantInteger( i );
     }
     case KONSTANT_NICHTS:
+        params->release();
         return new KonstantNichts();
     case KONSTANT_STRING:
     {
+        params->release();
         char len;
         dat.lese( &len, 1 );
         char *txt = new char[ len + 1 ];
@@ -298,6 +319,7 @@ Aktion *MapReader::readAktion( Datei &dat )
     }
     case KONSTANT_VARIABLE:
     {
+        params->release();
         char len;
         dat.lese( &len, 1 );
         char *txt = new char[ len + 1 ];
@@ -308,18 +330,21 @@ Aktion *MapReader::readAktion( Datei &dat )
         return ret;
     }
     case RICHTUNG_VON_GESCHOSS:
-        return new RichtungVonGeschoss( params[ 0 ] );
+        return new RichtungVonGeschoss( params );
     case RICHTUNG_VON_UMLENKUNG:
-        return new RichtungVonUmlenkung( params[ 0 ] );
+        return new RichtungVonUmlenkung( params );
     case RICHTUNG_ZUFALL:
+        params->release();
         return new RichtungZufall();
     case SCHALTER_AKTIVIEREN:
-        return new SchalterAktivieren( params[ 0 ] );
+        return new SchalterAktivieren( params );
     case SCHALTER_SET_ERLAUBT:
-        return new SchalterSetErlaubt( params[ 0 ], params[ 1 ] );
+        return new SchalterSetErlaubt( params );
     case SCHALTER_ZUFALL:
+        params->release();
         return new SchalterZufall();
     case SCHALTER_ZULETZT_AKTIVIERT:
+        params->release();
         return new SchalterZuletztAktiviert();
     case SET_VARIABLE:
     {
@@ -328,168 +353,188 @@ Aktion *MapReader::readAktion( Datei &dat )
         char *txt = new char[ len + 1 ];
         dat.lese( txt, len );
         txt[ (int)len ] = 0;
-        Aktion *ret = new SetVariable( txt, params[ 0 ] );
+        Aktion *ret = new SetVariable( txt, params );
         delete[] txt;
         return ret;
     }
     case SPIEL_ENDE:
-        return new SpielEnde( params[ 0 ] );
+        return new SpielEnde( params );
     case SPIELER_GIVE_ITEM:
-        return new SpielerGiveItem( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new SpielerGiveItem( params );
     case SPIELER_NACHRICHT:
-        return new SpielerNachricht( params[ 0 ], params[ 1 ] );
+        return new SpielerNachricht( params );
     case SPIELER_REMOVE_ITEM:
-        return new SpielerRemoveItem( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new SpielerRemoveItem( params );
     case SPIELER_SET_ABKLINGZEITVERRINGERUNG:
-        return new SpielerSetAbklingzeitverringerung( params[ 0 ], params[ 1 ] );
+        return new SpielerSetAbklingzeitverringerung( params );
     case SPIELER_SET_ARMOR:
-        return new SpielerSetArmor( params[ 0 ], params[ 1 ] );
+        return new SpielerSetArmor( params );
     case SPIELER_SET_ERFAHRUNG:
-        return new SpielerSetErfahrung( params[ 0 ], params[ 1 ] );
+        return new SpielerSetErfahrung( params );
     case SPIELER_SET_LEBEN:
-        return new SpielerSetLeben( params[ 0 ], params[ 1 ] );
+        return new SpielerSetLeben( params );
     case SPIELER_SET_LEBENSRAUB:
-        return new SpielerSetLebensraub( params[ 0 ], params[ 1 ] );
+        return new SpielerSetLebensraub( params );
     case SPIELER_SET_LEBENSREGENERATION:
-        return new SpielerSetLebensraub( params[ 0 ], params[ 1 ] );
+        return new SpielerSetLebensraub( params );
     case SPIELER_SET_LEVEL:
-        return new SpielerSetLevel( params[ 0 ], params[ 1 ] );
+        return new SpielerSetLevel( params );
     case SPIELER_SET_MAX_ERFAHRUNG:
-        return new SpielerSetMaxErfahrung( params[ 0 ], params[ 1 ] );
+        return new SpielerSetMaxErfahrung( params );
     case SPIELER_SET_SCHADEN_BONUS:
-        return new SpielerSetSchadenBonus( params[ 0 ], params[ 1 ] );
+        return new SpielerSetSchadenBonus( params );
     case SPIELER_SET_TEMPO:
-        return new SpielerSetTempo( params[ 0 ], params[ 1 ] );
+        return new SpielerSetTempo( params );
     case SPIELER_SET_GESCHOSS_TEMPO:
-        return new SpielerSetWaffenTempo( params[ 0 ], params[ 1 ] );
+        return new SpielerSetWaffenTempo( params );
     case SPIELER_ZUFALL:
+        params->release();
         return new SpielerZufall();
     case SPIELER_ZUFALL_AUS_TEAM:
-        return new SpielerZufallAusTeam( params[ 0 ] );
+        return new SpielerZufallAusTeam( params );
     case SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN:
         return new SpielerZuletztErfahrungBekommen();
     case SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT:
+        params->release();
         return new SpielerZuletztGegenstandAktiviert();
     case SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN:
+        params->release();
         return new SpielerZuletztGegenstandAufgehoben();
     case SPIELER_ZULETZT_GEHEILT:
+        params->release();
         return new SpielerZuletztGeheilt();
     case SPIELER_ZULETZT_GESCHOSSEN:
+        params->release();
         return new SpielerZuletztGeschossGeschossen();
     case SPIELER_ZULETZT_GESTORBEN:
+        params->release();
         return new SpielerZuletztGestorben();
     case SPIELER_ZULETZT_LEVEL_UP:
+        params->release();
         return new SpielerZuletztLevelUp();
     case SPIELER_ZULETZT_SCHADEN_GEMACHT:
+        params->release();
         return new SpielerZuletztSchadenGemacht();
     case SPIELER_ZULETZT_SCHADEN_GENOMMEN:
+        params->release();
         return new SpielerZuletztSchadenGenommen();
     case SPIELER_ZULETZT_SCHALTER_AKTIVIERT:
+        params->release();
         return new SpielerZuletztSchalterAktiviert();
     case SPIELER_ZULETZT_TUNNEL_BENUTZT:
+        params->release();
         return new SpielerZuletztTunnelBenutzt();
     case SPIELER_ZULETZT_WIEDERBELEBT:
+        params->release();
         return new SpielerZuletztWiederbelebent();
     case SPIEL_PAUSE:
-        return new SpielPause( params[ 0 ] );
+        return new SpielPause( params );
     case TEAM_SET_PUNKTE:
-        return new TeamSetPunkte( params[ 0 ], params[ 1 ] );
+        return new TeamSetPunkte( params );
     case TEAM_VON_BARIERE:
-        return new TeamVonBariere( params[ 0 ] );
+        return new TeamVonBariere( params );
     case TEAM_VON_SPIELER:
-        return new TeamVonSpieler( params[ 0 ] );
+        return new TeamVonSpieler( params );
     case TEAM_ZUFALL:
+        params->release();
         return new TeamZufall();
     case TEXT_AUS_BOOLEAN:
-        return new TextAusBoolean( params[ 0 ] );
+        return new TextAusBoolean( params );
     case TEXT_AUS_RICHTUNG:
-        return new TextAusRichtung( params[ 0 ] );
+        return new TextAusRichtung( params );
     case TEXT_AUS_INTEGER:
-        return new TextAusInteger( params[ 0 ] );
+        return new TextAusInteger( params );
     case TEXT_CONCAT:
-        return new TextConcat( params[ 0 ], params[ 1 ] );
+        return new TextConcat( params );
     case TEXT_ITEM_NAME:
-        return new TextItemName( params[ 0 ] );
+        return new TextItemName( params );
     case TEXT_SPIELER_NAME:
-        return new TextSpielerName( params[ 0 ] );
+        return new TextSpielerName( params );
     case TEXT_TEIL_VON_TEXT:
-        return new TextTeilVonText( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new TextTeilVonText( params );
     case TEXT_TRIGGER_NAME:
-        return new TextTriggerName( params[ 0 ] );
+        return new TextTriggerName( params );
     case TIMER_SET_PAUSE:
-        return new TimerSetPause( params[ 0 ], params[ 1 ] );
+        return new TimerSetPause( params );
     case TIMER_SET_SICHTBAR:
-        return new TimerSetSichtbar( params[ 0 ], params[ 1 ] );
+        return new TimerSetSichtbar( params );
     case TIMER_SET_ZEIT:
-        return new TimerSetZeit( params[ 0 ], params[ 1 ] );
+        return new TimerSetZeit( params );
     case TIMER_START:
-        return new TimerStart( params[ 0 ] );
+        return new TimerStart( params );
     case TIMER_ZUFALL:
+        params->release();
         return new TimerZufall();
     case TIMER_ZULETZT_ABGELAUFEN:
+        params->release();
         return new TimerZuletztAbgelaufen();
     case TIMER_ZULETZT_FOTOGRAFIERT:
+        params->release();
         return new TimerZuletztFortgesetzt();
     case TIMER_ZULETZT_GESTARTET:
+        params->release();
         return new TimerZuletztGestartet();
     case TIMER_ZULETZT_PAUSIERT:
+        params->release();
         return new TimerZuletztPausiert();
     case TRIGGER_AKTION:
-        return new TriggerAktion( params[ 0 ], params[ 1 ] );
+        return new TriggerAktion( params );
     case TRIGGER_LAST_RUNNED:
+        params->release();
         return new TriggerLastRunned();
     case TRIGGER_RUN_START:
-        return new TriggerRunStart( params[ 0 ] );
+        return new TriggerRunStart( params );
     case TRIGGER_SET_ENABLED:
-        return new TriggerSetEnabled( params[ 0 ], params[ 1 ] );
+        return new TriggerSetEnabled( params );
     case TRIGGER_ZUFALL:
+        params->release();
         return new TriggerZufall();
     case TUNNEL_SET_ERLAUBT:
-        return new TunnelSetErlaubt( params[ 0 ], params[ 1 ] );
+        return new TunnelSetErlaubt( params );
     case TUNNEL_SET_ZIEL_POSITION:
-        return new TunnelSetZielPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new TunnelSetZielPosition( params );
     case TUNNEL_ZUFALL:
+        params->release();
         return new TunnelZufall();
     case TUNNEL_ZULETZT_BENUTZT:
+        params->release();
         return new TunnelZuletztBenutzt();
     case UMLENKUNG_SET_ERLAUBT:
-        return new UmlenkungSetEnabled( params[ 0 ], params[ 1 ] );
+        return new UmlenkungSetEnabled( params );
     case UMLENKUNG_SET_MAX_ABK:
-        return new UmlenkungSetMaxAbk( params[ 0 ], params[ 1 ] );
+        return new UmlenkungSetMaxAbk( params );
     case UMLENKUNG_SET_RICHTUNG:
-        return new UmlenkungSetRichtung( params[ 0 ], params[ 1 ] );
+        return new UmlenkungSetRichtung( params );
     case UMLENKUNG_ZUFALL:
+        params->release();
         return new UmlenkungZufall();
     case UMLENKUNG_ZULETZT_BENUTZT:
+        params->release();
         return new UmlenkungZuletztBenutzt();
     case WARTEN:
-        return new Warten( params[ 0 ] );
+        return new Warten( params );
     case WENN_DANN_SONST:
-        return new WennDannSonst( params[ 0 ], params[ 1 ], params[ 2 ] );
+        return new WennDannSonst( params );
     case SEQUENZ:
-    {
-        RCArray< Aktion > *actions = new RCArray< Aktion >();
-        for( int i = 0; i < pAnz; i++ )
-            actions->add( params[ 0 ] );
-        return new Sequenz( actions );
-    }
+        return new Sequenz( params );
     case FLOAT_RECHNUNG:
     {
         char op;
         dat.lese( &op, 1 );
-        return new FloatRechnung( params[ 0 ], params[ 1 ], (Operator)op );
+        return new FloatRechnung( params, (Operator)op );
     }
     case FLOAT_AUS_INTEGER:
-        return new FloatAusInteger( params[ 0 ] );
+        return new FloatAusInteger( params );
     case FLOAT_AUS_TEXT:
-        return new FloatAusText( params[ 0 ] );
+        return new FloatAusText( params );
     case TEXT_AUS_FLOAT:
-        return new TextAusFloat( params[ 0 ] );
+        return new TextAusFloat( params );
     case FLOAT_ZUFALL:
-        return new FloatZufall( params[ 0 ], params[ 0 ] );
+        return new FloatZufall( params );
     case INTEGER_AUS_FLOAT:
-        return new IntegerAusFloat( params[ 0 ] );
+        return new IntegerAusFloat( params );
     }
+    params->release();
     return new KonstantNichts();
 }
 

StickmanWorldOnline/Variablen.cpp

@@ -111,7 +111,7 @@ bool Boolean::getValue() const
 }
 
 
-String::String( const char *value, bool richtung, bool geschossTyp = 0 )
+String::String( const char *value, bool richtung, bool geschossTyp )
     : Variable( richtung ? RICHTUNG : ( geschossTyp ? GESCHOSS_TYP : STRING ) )
 {
     this->value = value;