Es werden makros benutzt um den trigger code lesbarer zu machen

StickmanWorldOnline/Aktionen.cpp

@@ -3,6 +3,13 @@
 #include "Spiel.h"
 
 
+#define zParam( x )    zEvaluatedParam( x, zMemory, zPC )
+#define getParam( x )  getEvaluatedParam( x, zMemory, zPC )
+#define setReturn( x ) zMemory->setVar( "__return__", x )
+#define zReturn        zMemory->zVariable( "__return__" )
+#define getReturn      zMemory->getVariable( "__return__" )
+
+
 Aktion::Aktion( AktionTyp typ, RCArray< Aktion > *subActions )
     : Variable( AKTION )
 {
@@ -40,7 +47,7 @@ bool Aktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory,
             zPC->stepOut();
             return 0;
         }
-        Variable *result = zMemory->zVariable( "__return__" );
+        Variable *result = zReturn;
         if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || result->getVariableTyp() != erlaubteTypen.get( i ) )
         {
             zPC->stepOut();
@@ -76,7 +83,7 @@ KonstantNichts::KonstantNichts()
 
 void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Variable( NICHTS ) );
+    setReturn( new Variable( NICHTS ) );
 }
 
 
@@ -88,7 +95,7 @@ KonstantInteger::KonstantInteger( int val )
 
 void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( value ) );
+    setReturn( new Integer( value ) );
 }
 
 
@@ -100,7 +107,7 @@ KonstantBoolean::KonstantBoolean( bool val )
 
 void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Boolean( value ) );
+    setReturn( new Boolean( value ) );
 }
 
 
@@ -112,7 +119,7 @@ KonstantString::KonstantString( Text val )
 
 void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new String( value ) );
+    setReturn( new String( value ) );
 }
 
 
@@ -124,7 +131,7 @@ KonstantFloat::KonstantFloat( float val )
 
 void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Float( value ) );
+    setReturn( new Float( value ) );
 }
 
 
@@ -137,13 +144,13 @@ KonstantVariable::KonstantVariable( Text name )
 void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     if( zMemory->zVariable( name ) )
-        zMemory->setVar( "__return__", zMemory->getVariable( name ) );
+        setReturn( zMemory->getVariable( name ) );
     else if( zEreignis->zParameter( name ) )
-        zMemory->setVar( "__return__", zEreignis->zParameter( name ) );
+        setReturn( zEreignis->zParameter( name ) );
     else if( zSpiel->zVariable( name ) )
-        zMemory->setVar( "__return__", zSpiel->getVariable( name ) );
+        setReturn( zSpiel->getVariable( name ) );
     else
-        zMemory->setVar( "__return__", new Variable( NICHTS ) );
+        setReturn( new Variable( NICHTS ) );
 }
 
 
@@ -158,7 +165,7 @@ Warten::~Warten()
 
 void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    waitCount += ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue();
+    waitCount += ( (Float *)zParam( 0 ) )->getValue();
 }
 
 
@@ -177,7 +184,7 @@ bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
         bool finished = subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
         if( finished )
         {
-            Variable *ret = zMemory->zVariable( "__return__" );
+            Variable *ret = zReturn;
             zPC->count();
             if( !isTrue( ret ) )
             {
@@ -233,9 +240,9 @@ SetVariable::~SetVariable()
 void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
-        zMemory->setVar( name, getEvaluatedParam( 0, zMemory, zPC ) );
+        zMemory->setVar( name, getParam( 0 ) );
     else
-        zSpiel->setVariable( name, getEvaluatedParam( 0, zMemory, zPC ) );
+        zSpiel->setVariable( name, getParam( 0 ) );
 }
 
 
@@ -253,7 +260,7 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     {
         if( subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
-            Variable *t = zMemory->zVariable( "__return__" );
+            Variable *t = zReturn;
             if( !t || t->getVariableTyp() != INTEGER )
             {
                 zPC->stepOut();
@@ -267,13 +274,13 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     {
         if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
-            Variable *t = zMemory->zVariable( "__return__" );
+            Variable *t = zReturn;
             if( !t || t->getVariableTyp() != TRIGGER )
             {
                 zPC->stepOut();
                 return 1;
             }
-            int id = ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue();
+            int id = ( (Integer *)zParam( 0 ) )->getValue();
             if( id >= ( (Trigger *)t )->getAktionAnzahl() )
             {
                 zPC->stepOut();
@@ -285,7 +292,7 @@ bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
     }
     if( zPC->currentPosition() == 2 && waitCount <= 0 )
     {
-        if( ( (Aktion *)zEvaluatedParam( 0, zMemory, zPC ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( ( (Aktion *)zParam( 0 ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             zPC->stepOut();
             return 1;
@@ -342,7 +349,7 @@ SpielPause::~SpielPause()
 
 void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zSpiel->setPausiert( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    zSpiel->setPausiert( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -355,7 +362,7 @@ SpielEnde::~SpielEnde()
 
 void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    Variable *t = zEvaluatedParam( 0, zMemory, zPC );
+    Variable *t = zParam( 0 );
     if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM )
         t = 0;
     zSpiel->setEnde( t->getVariableTyp() == NICHTS ? 0 : (Team *)t );
@@ -374,7 +381,7 @@ SpielerSetLevel::~SpielerSetLevel()
 
 void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLevel( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -391,8 +398,8 @@ SpielerGiveItem::~SpielerGiveItem()
 
 void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->addItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(),
-        ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue(), zSpiel );
+    ( (Spieler *)zParam( 2 ) )->addItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
+        ( (Integer *)zParam( 1 ) )->getValue(), zSpiel );
 }
 
 
@@ -409,8 +416,8 @@ SpielerRemoveItem::~SpielerRemoveItem()
 
 void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 2, zMemory, zPC ) )->removeItem( ( (GegenstandTypVar *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue(),
-        ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 2 ) )->removeItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
+        ( (Integer *)zParam( 1 ) )->getValue() );
 }
 
 
@@ -426,7 +433,7 @@ SpielerSetLeben::~SpielerSetLeben()
 
 void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLeben( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLeben( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -442,7 +449,7 @@ SpielerSetMaxLeben::~SpielerSetMaxLeben()
 
 void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxLeben( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setMaxLeben( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -458,7 +465,7 @@ SpielerSetErfahrung::~SpielerSetErfahrung()
 
 void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setErfahrung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -474,7 +481,7 @@ SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung()
 
 void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxErfahrung( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setMaxErfahrung( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -490,7 +497,7 @@ SpielerSetTempo::~SpielerSetTempo()
 
 void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLaufTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLaufTempo( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -506,7 +513,7 @@ SpielerSetWaffenTempo::~SpielerSetWaffenTempo()
 
 void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setGeschossTempo( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setGeschossTempo( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -522,7 +529,7 @@ SpielerSetArmor::~SpielerSetArmor()
 
 void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setArmor( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setArmor( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -538,7 +545,7 @@ SpielerSetSchadenBonus::~SpielerSetSchadenBonus()
 
 void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setSchadenBonus( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setSchadenBonus( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -554,7 +561,7 @@ SpielerSetLebensraub::~SpielerSetLebensraub()
 
 void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRaub( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLebensRaub( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -570,7 +577,7 @@ SpielerSetLebensregeneration::~SpielerSetLebensregeneration()
 
 void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setLebensRegeneration( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setLebensRegeneration( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -586,7 +593,7 @@ SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung()
 
 void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Spieler *)zEvaluatedParam( 1, zMemory, zPC ) )->setAbklingZeitVerringerung( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Spieler *)zParam( 1 ) )->setAbklingZeitVerringerung( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -602,7 +609,7 @@ DropSetTime::~DropSetTime()
 
 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() );
+    ( (Drop *)zParam( 1 ) )->setTime( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -618,7 +625,7 @@ DropSetMaxTime::~DropSetMaxTime()
 
 void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Drop *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxTime( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Drop *)zParam( 1 ) )->setMaxTime( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -637,10 +644,10 @@ DropSetArea::~DropSetArea()
 
 void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (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() );
+    ( (Drop *)zParam( 4 ) )->setMinX( ( (Integer *)zParam( 0 ) )->getValue() );
+    ( (Drop *)zParam( 4 ) )->setMaxX( ( (Integer *)zParam( 1 ) )->getValue() );
+    ( (Drop *)zParam( 4 ) )->setMinY( ( (Integer *)zParam( 2 ) )->getValue() );
+    ( (Drop *)zParam( 4 ) )->setMaxY( ( (Integer *)zParam( 3 ) )->getValue() );
 }
 
 
@@ -655,7 +662,7 @@ DropDoDrop::~DropDoDrop()
 
 void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->doDrop( zSpiel );
+    ( (Drop *)zParam( 0 ) )->doDrop( zSpiel );
 }
 
 
@@ -670,7 +677,7 @@ BariereBewegung::~BariereBewegung()
 
 void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Bariere *)zEvaluatedParam( 0, zMemory, zPC ) )->startAutoVerschiebung( zSpiel );
+    ( (Bariere *)zParam( 0 ) )->startAutoVerschiebung( zSpiel );
 }
 
 
@@ -686,7 +693,7 @@ BariereSetEingeschaltet::~BariereSetEingeschaltet()
 
 void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setEingeschaltet( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Bariere *)zParam( 1 ) )->setEingeschaltet( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -703,8 +710,8 @@ GameObjektSetPosition::~GameObjektSetPosition()
 
 void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setX( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
-    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setY( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
+    ( (GameObject *)zParam( 2 ) )->setX( ( (Float *)zParam( 0 ) )->getValue() );
+    ( (GameObject *)zParam( 2 ) )->setY( ( (Float *)zParam( 1 ) )->getValue() );
 }
 
 
@@ -721,8 +728,8 @@ GameObjektSetSize::~GameObjektSetSize()
 
 void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setWidth( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
-    ( (GameObject *)zEvaluatedParam( 2, zMemory, zPC ) )->setHeight( ( (Float *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
+    ( (GameObject *)zParam( 2 ) )->setWidth( ( (Float *)zParam( 0 ) )->getValue() );
+    ( (GameObject *)zParam( 2 ) )->setHeight( ( (Float *)zParam( 1 ) )->getValue() );
 }
 
 
@@ -738,7 +745,7 @@ BariereSetTeam::~BariereSetTeam()
 
 void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Bariere *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) );
+    ( (Bariere *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ) );
 }
 
 
@@ -754,7 +761,7 @@ SchalterSetErlaubt::~SchalterSetErlaubt()
 
 void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Schalter *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktive( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Schalter *)zParam( 1 ) )->setAktive( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -769,7 +776,7 @@ SchalterAktivieren::~SchalterAktivieren()
 
 void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zSpiel->activateShalter( ( (Schalter *)zEvaluatedParam( 0, zMemory, zPC ) )->getId() );
+    zSpiel->activateShalter( ( (Schalter *)zParam( 0 ) )->getId() );
 }
 
 
@@ -786,8 +793,8 @@ TunnelSetZielPosition::~TunnelSetZielPosition()
 
 void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielX( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
-    ( (Tunnel *)zEvaluatedParam( 2, zMemory, zPC ) )->setZielY( ( (Integer *)zEvaluatedParam( 1, zMemory, zPC ) )->getValue() );
+    ( (Tunnel *)zParam( 2 ) )->setZielX( ( (Integer *)zParam( 0 ) )->getValue() );
+    ( (Tunnel *)zParam( 2 ) )->setZielY( ( (Integer *)zParam( 1 ) )->getValue() );
 }
 
 
@@ -803,7 +810,7 @@ TunnelSetErlaubt::~TunnelSetErlaubt()
 
 void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Tunnel *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Tunnel *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -819,7 +826,7 @@ UmlenkungSetRichtung::~UmlenkungSetRichtung()
 
 void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
+    ( (Umlenkung *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
 }
 
 
@@ -835,7 +842,7 @@ UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk()
 
 void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setMaxAbklingzeit( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Umlenkung *)zParam( 1 ) )->setMaxAbklingzeit( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -851,7 +858,7 @@ UmlenkungSetEnabled::~UmlenkungSetEnabled()
 
 void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Umlenkung *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Umlenkung *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -867,7 +874,7 @@ BaseSetTeam::~BaseSetTeam()
 
 void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Base *)zEvaluatedParam( 1, zMemory, zPC ) )->setTeam( ( (Team *)zEvaluatedParam( 0, zMemory, zPC ) ) );
+    ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ) );
 }
 
 TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
@@ -881,7 +888,7 @@ TriggerRunStart::~TriggerRunStart()
 
 void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zSpiel->addTriggerRun( ( (Trigger *)zEvaluatedParam( 0, zMemory, zPC ) )->runTrigger( zEreignis->getThis(), zSpiel ) );
+    zSpiel->addTriggerRun( ( (Trigger *)zParam( 0 ) )->runTrigger( zEreignis->getThis(), zSpiel ) );
 }
 
 
@@ -897,7 +904,7 @@ TriggerSetEnabled::~TriggerSetEnabled()
 
 void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Trigger *)zEvaluatedParam( 1, zMemory, zPC ) )->setAktiv( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Trigger *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -913,7 +920,7 @@ TeamSetPunkte::~TeamSetPunkte()
 
 void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Team *)zEvaluatedParam( 1, zMemory, zPC ) )->setPunkte( ( (Integer *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Team *)zParam( 1 ) )->setPunkte( ( (Integer *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -929,7 +936,7 @@ TimerSetPause::~TimerSetPause()
 
 void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setPause( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Timer *)zParam( 1 ) )->setPause( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -944,7 +951,7 @@ TimerStart::~TimerStart()
 
 void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Timer *)zEvaluatedParam( 0, zMemory, zPC ) )->start( zSpiel );
+    ( (Timer *)zParam( 0 ) )->start( zSpiel );
 }
 
 
@@ -960,7 +967,7 @@ TimerSetZeit::~TimerSetZeit()
 
 void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setZeit( ( (Float *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Timer *)zParam( 1 ) )->setZeit( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -976,7 +983,7 @@ TimerSetSichtbar::~TimerSetSichtbar()
 
 void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Timer *)zEvaluatedParam( 1, zMemory, zPC ) )->setSichtbar( ( (Boolean *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() );
+    ( (Timer *)zParam( 1 ) )->setSichtbar( ( (Boolean *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -995,12 +1002,12 @@ 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 );
+                                getGeschossTypFromString( ( (String *)zParam( 2 ) )->getValue() ),
+                                getRichtungFromString( ( (String *)zParam( 3 ) )->getValue() ),
+                                ( (Integer *)zParam( 0 ) )->getValue(),
+                                ( (Integer *)zParam( 1 ) )->getValue(), 0 );
     zSpiel->addGeschoss( (Geschoss *)g->getThis() );
-    zMemory->setVar( "__return__", g );
+    setReturn( g );
 }
 
 
@@ -1016,7 +1023,7 @@ 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() );
+    ( (Geschoss *)zParam( 1 ) )->setSpeed( ( (Float *)zParam( 0 ) )->getValue() );
 }
 
 
@@ -1032,7 +1039,7 @@ GeschossSetPlayer::~GeschossSetPlayer()
 
 void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
+    ( (Geschoss *)zParam( 1 ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
 }
 
 
@@ -1048,7 +1055,7 @@ GeschossSetRichtung::~GeschossSetRichtung()
 
 void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    ( (Geschoss *)zEvaluatedParam( 1, zMemory, zPC ) )->setRichtung( getRichtungFromString( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
+    ( (Geschoss *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
 }
 
 
@@ -1064,7 +1071,7 @@ 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() ) );
+    ( (Geschoss *)zParam( 1 ) )->setTyp( getGeschossTypFromString( ( (String *)zParam( 0 ) )->getValue() ) );
 }
 
 
@@ -1074,7 +1081,7 @@ TriggerZufall::TriggerZufall()
 
 void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getRandomTrigger() );
+    setReturn( zSpiel->getRandomTrigger() );
 }
 
 
@@ -1084,7 +1091,7 @@ TriggerLastRunned::TriggerLastRunned()
 
 void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getLastRunnedTrigger() );
+    setReturn( zSpiel->getLastRunnedTrigger() );
 }
 
 
@@ -1094,7 +1101,7 @@ BariereZufall::BariereZufall()
 
 void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getRandomBariere() );
+    setReturn( zSpiel->getRandomBariere() );
 }
 
 
@@ -1104,7 +1111,7 @@ BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
 
 void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getZuletztEingeschalteteBariere() );
+    setReturn( zSpiel->getZuletztEingeschalteteBariere() );
 }
 
 
@@ -1114,7 +1121,7 @@ BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
 
 void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getZuletztAusgeschalteteBariere() );
+    setReturn( zSpiel->getZuletztAusgeschalteteBariere() );
 }
 
 
@@ -1124,7 +1131,7 @@ BariereZuletztBewegt::BariereZuletztBewegt()
 
 void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getZuletztBewegteBariere() );
+    setReturn( zSpiel->getZuletztBewegteBariere() );
 }
 
 
@@ -1134,7 +1141,7 @@ BaseZufall::BaseZufall()
 
 void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getRandomBase() );
+    setReturn( zSpiel->getRandomBase() );
 }
 
 
@@ -1144,7 +1151,7 @@ BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
 
 void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getLastTeamChangedBase() );
+    setReturn( zSpiel->getLastTeamChangedBase() );
 }
 
 
@@ -1154,7 +1161,7 @@ DropZufall::DropZufall()
 
 void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getRandomDrop() );
+    setReturn( zSpiel->getRandomDrop() );
 }
 
 
@@ -1164,7 +1171,7 @@ DropZuletztGedropt::DropZuletztGedropt()
 
 void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", zSpiel->getLastDrop() );
+    setReturn( zSpiel->getLastDrop() );
 }
 
 
@@ -1180,76 +1187,76 @@ IntegerRechnen::~IntegerRechnen()
 
 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 );
+    Integer *l = (Integer *)zParam( 0 );
+    Integer *r = (Integer *)zParam( 1 );
     switch( op )
     {
     case PLUS:
-        zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) );
+        setReturn( new Integer( l->getValue() + r->getValue() ) );
         break;
     case MINUS:
-        zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) );
+        setReturn( new Integer( l->getValue() - r->getValue() ) );
         break;
     case MAHL:
-        zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) );
+        setReturn( new Integer( l->getValue() * r->getValue() ) );
         break;
     case GETEILT:
-        zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) );
+        setReturn( new Integer( l->getValue() / r->getValue() ) );
         break;
     case HOCH:
-        zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
+        setReturn( new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
         break;
     case WURZEL:
-        zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
+        setReturn( new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
         break;
     case BIT_ODER:
-        zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) );
+        setReturn( new Integer( l->getValue() | r->getValue() ) );
         break;
     case BIT_UND:
-        zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) );
+        setReturn( new Integer( l->getValue() & r->getValue() ) );
         break;
     case BIT_XOR:
-        zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) );
+        setReturn( new Integer( l->getValue() ^ r->getValue() ) );
         break;
     case BIT_FLIP:
-        zMemory->setVar( "__return__", new Integer( ~l->getValue() ) );
+        setReturn( new Integer( ~l->getValue() ) );
         break;
     case BIT_SHIFT_LEFT:
-        zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) );
+        setReturn( new Integer( l->getValue() << r->getValue() ) );
         break;
     case BIT_SHIFT_RIGHT:
-        zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) );
+        setReturn( new Integer( l->getValue() >> r->getValue() ) );
         break;
     case INVERT_SIGN:
-        zMemory->setVar( "__return__", new Integer( -l->getValue() ) );
+        setReturn( new Integer( -l->getValue() ) );
         break;
     case PLUS_PLUS_LEFT:
         l->setValue( l->getValue() + 1 );
-        zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+        setReturn( new Integer( l->getValue() ) );
         break;
     case PLUS_PLUS_RIGHT:
     {
         int tmp = l->getValue();
         l->setValue( l->getValue() + 1 );
-        zMemory->setVar( "__return__", new Integer( tmp ) );
+        setReturn( new Integer( tmp ) );
         break;
     }
     case MINUS_MINUS_LEFT:
         l->setValue( l->getValue() - 1 );
-        zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+        setReturn( new Integer( l->getValue() ) );
         break;
     case MINUS_MINUS_RIGHT:
     {
         int tmp = l->getValue();
         l->setValue( l->getValue() - 1 );
-        zMemory->setVar( "__return__", new Integer( tmp ) );
+        setReturn( new Integer( tmp ) );
         break;
     }
     case LOGARITHM:
-        zMemory->setVar( "__return__", new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
+        setReturn( new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
         break;
     case MODULO:
-        zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
+        setReturn( new Integer( l->getValue() % r->getValue() ) );
         break;
     default:
         break;
@@ -1269,9 +1276,9 @@ IntegerZufall::~IntegerZufall()
 
 void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    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 ) ) );
+    int mi = ( (Integer *)zParam( 0 ) )->getValue();
+    int ma = ( (Integer *)zParam( 1 ) )->getValue();
+    setReturn( new Integer( (int)( zSpiel->getRand() * ( ma - mi ) + mi ) ) );
 }
 
 
@@ -1286,7 +1293,7 @@ IntegerAusText::~IntegerAusText()
 
 void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (String *)zEvaluatedParam( 0, zMemory, zPC ) )->getValue() ) );
+    setReturn( new Integer( ( (String *)zParam( 0 ) )->getValue() ) );
 }
 
 
@@ -1301,7 +1308,7 @@ FloatXVonGameObjekt::~FloatXVonGameObjekt()
 
 void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getX() ) );
+    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getX() ) );
 }
 
 
@@ -1316,7 +1323,7 @@ FloatYVonGameObjekt::~FloatYVonGameObjekt()
 
 void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Float( ( (GameObject *)zEvaluatedParam( 0, zMemory, zPC ) )->getY() ) );
+    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getY() ) );
 }
 
 
@@ -1331,7 +1338,7 @@ IntegerXVonTunnelZiel::~IntegerXVonTunnelZiel()
 
 void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielX() ) );
+    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielX() ) );
 }
 
 
@@ -1346,7 +1353,7 @@ IntegerYVonTunnelZiel::~IntegerYVonTunnelZiel()
 
 void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Tunnel *)zEvaluatedParam( 0, zMemory, zPC ) )->getZielY() ) );
+    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielY() ) );
 }
 
 
@@ -1361,7 +1368,7 @@ IntegerMinXVonDrop::~IntegerMinXVonDrop()
 
 void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinX() ) );
+    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinX() ) );
 }
 
 
@@ -1376,7 +1383,7 @@ IntegerMinYVonDrop::~IntegerMinYVonDrop()
 
 void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMinY() ) );
+    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinY() ) );
 }
 
 
@@ -1391,7 +1398,7 @@ IntegerMaxXVonDrop::~IntegerMaxXVonDrop()
 
 void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxX() ) );
+    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxX() ) );
 }
 
 
@@ -1406,7 +1413,7 @@ IntegerMaxYVonDrop::~IntegerMaxYVonDrop()
 
 void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Drop *)zEvaluatedParam( 0, zMemory, zPC ) )->getMaxY() ) );
+    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxY() ) );
 }
 
 
@@ -1421,7 +1428,7 @@ IntegerSpielerLevel::~IntegerSpielerLevel()
 
 void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Integer( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLevel() ) );
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getLevel() ) );
 }
 
 
@@ -1436,5 +1443,26 @@ FloatSpielerLeben::~FloatSpielerLeben()
 
 void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    zMemory->setVar( "__return__", new Float( ( (Spieler *)zEvaluatedParam( 0, zMemory, zPC ) )->getLeben() ) );
-}
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLeben() ) );
+}
+
+bool isBinary( Operator op )
+{
+    return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
+        op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
+}
+
+
+IntegerSpielerMaxLeben::IntegerSpielerMaxLeben( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_MAX_LEBEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+IntegerSpielerMaxLeben::~IntegerSpielerMaxLeben()
+{}
+
+void IntegerSpielerMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+
+}