Triggersystem erlaubt jetzt auch verkettete und verschachtelte Aktionen

StickmanWorldOnline/Aktionen.h

@@ -4,6 +4,8 @@
 
 class Spiel;
 class Ereignis;
+class ProgramCounter;
+class LocalMemory;
 
 enum AktionTyp
 {
@@ -229,7 +231,7 @@ private:
 public:
     Aktion( AktionTyp typ );
     virtual ~Aktion();
-    virtual Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) = 0;
+    virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) = 0;
     Aktion *getThis();
     Aktion *release();
 };
@@ -238,7 +240,7 @@ class KonstantNichts : public Aktion
 {
 public:
     KonstantNichts();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantInteger : public Aktion
@@ -248,7 +250,7 @@ private:
 
 public:
     KonstantInteger( int val );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantBoolean : public Aktion
@@ -258,7 +260,7 @@ private:
 
 public:
     KonstantBoolean( bool val );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantString : public Aktion
@@ -268,7 +270,7 @@ private:
 
 public:
     KonstantString( Text val );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantFloat : public Aktion
@@ -278,7 +280,7 @@ private:
 
 public:
     KonstantFloat( float val );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class KonstantVariable : public Aktion
@@ -288,7 +290,7 @@ private:
 
 public:
     KonstantVariable( Text name );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class Warten : public Aktion
@@ -298,30 +300,33 @@ private:
 
 public:
     Warten( Aktion *seconds );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~Warten();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SetVariable : public Aktion
+class WennDannSonst : public Aktion
 {
 private:
-    Text name;
-    Aktion *value;
+    Aktion *wenn;
+    Aktion *dann;
+    Aktion *sonst;
 
 public:
-    SetVariable( Text name, Aktion *value );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    WennDannSonst( Aktion *wenn, Aktion *dann, Aktion *sonst );
+    ~WennDannSonst();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class WennDannSonst : public Aktion
+class SetVariable : public Aktion
 {
 private:
-    Aktion *condition;
-    Aktion *wahr;
-    Aktion *falsch;
+    Text name;
+    Aktion *value;
 
 public:
-    WennDannSonst( Aktion *condition, Aktion *wahr, Aktion *falsch );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    SetVariable( Text name, Aktion *value );
+    ~SetVariable();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerAktion : public Aktion
@@ -332,7 +337,8 @@ private:
 
 public:
     TriggerAktion( Aktion *number, Aktion *triggerName );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TriggerAktion();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerNachricht : public Aktion
@@ -343,7 +349,8 @@ private:
 
 public:
     SpielerNachricht( Aktion *spieler, Aktion *nachricht );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerNachricht();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DisplayText : public Aktion
@@ -357,7 +364,8 @@ private:
 
 public:
     DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~DisplayText();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielPause : public Aktion
@@ -367,7 +375,8 @@ private:
 
 public:
     SpielPause( Aktion *paused );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielPause();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielEnde : public Aktion
@@ -377,7 +386,8 @@ private:
 
 public:
     SpielEnde( Aktion *gewinnerTeam );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielEnde();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLevel : public Aktion
@@ -388,7 +398,8 @@ private:
 
 public:
     SpielerSetLevel( Aktion *level, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetLevel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerGiveItem : public Aktion
@@ -400,7 +411,8 @@ private:
 
 public:
     SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerGiveItem();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerRemoveItem : public Aktion
@@ -412,7 +424,8 @@ private:
 
 public:
     SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerRemoveItem();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetPosition : public Aktion
@@ -424,7 +437,8 @@ private:
 
 public:
     SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLeben : public Aktion
@@ -435,7 +449,8 @@ private:
 
 public:
     SpielerSetLeben( Aktion *leben, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetMaxLeben : public Aktion
@@ -446,29 +461,32 @@ private:
 
 public:
     SpielerSetMaxLeben( Aktion *leben, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetMaxLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetErfahrung : public Aktion
+class SpielerSetErfahrunNextg : public Aktion
 {
 private:
-    Aktion *erfahrung;
+    Aktion *erfahrunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    SpielerSetErfahrunNextg( Aktion *erfahrunNextg, Aktion *spieler );
+    ~SpielerSetErfahrunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetMaxErfahrung : public Aktion
+class SpielerSetMaxErfahrunNextg : public Aktion
 {
 private:
-    Aktion *erfahrung;
+    Aktion *erfahrunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    SpielerSetMaxErfahrunNextg( Aktion *erfahrunNextg, Aktion *spieler );
+    ~SpielerSetMaxErfahrunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetTempo : public Aktion
@@ -479,7 +497,8 @@ private:
 
 public:
     SpielerSetTempo( Aktion *tempo, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetTempo();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetWaffenTempo : public Aktion
@@ -490,7 +509,8 @@ private:
 
 public:
     SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetWaffenTempo();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetArmor : public Aktion
@@ -501,7 +521,8 @@ private:
 
 public:
     SpielerSetArmor( Aktion *armor, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetArmor();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetSchadenBonus : public Aktion
@@ -512,7 +533,8 @@ private:
 
 public:
     SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetSchadenBonus();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLebensraub : public Aktion
@@ -523,7 +545,8 @@ private:
 
 public:
     SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetLebensraub();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerSetLebensregeneration : public Aktion
@@ -534,18 +557,20 @@ private:
 
 public:
     SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerSetLebensregeneration();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetAbklingzeitverringerung : public Aktion
+class SpielerSetAbklingzeitverringerunNextg : public Aktion
 {
 private:
-    Aktion *verringerung;
+    Aktion *verringerunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    SpielerSetAbklingzeitverringerunNextg( Aktion *verringerunNextg, Aktion *spieler );
+    ~SpielerSetAbklingzeitverringerunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetTime : public Aktion
@@ -556,7 +581,8 @@ private:
 
 public:
     DropSetTime( Aktion *time, Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~DropSetTime();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetMaxTime : public Aktion
@@ -567,7 +593,8 @@ private:
 
 public:
     DropSetMaxTime( Aktion *time, Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~DropSetMaxTime();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropSetArea : public Aktion
@@ -581,7 +608,8 @@ private:
 
 public:
     DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~DropSetArea();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropDoDrop : public Aktion
@@ -591,7 +619,8 @@ private:
 
 public:
     DropDoDrop( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~DropDoDrop();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereBewegung : public Aktion
@@ -601,7 +630,8 @@ private:
 
 public:
     BariereBewegung( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BariereBewegung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereSetEingeschaltet : public Aktion
@@ -612,7 +642,8 @@ private:
 
 public:
     BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BariereSetEingeschaltet();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereSetPosition : public Aktion
@@ -624,7 +655,8 @@ private:
 
 public:
     BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BariereSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereSetTeam : public Aktion
@@ -635,7 +667,8 @@ private:
 
 public:
     BariereSetTeam( Aktion *team, Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BariereSetTeam();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterSetPosition : public Aktion
@@ -647,7 +680,8 @@ private:
 
 public:
     SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SchalterSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterSetErlaubt : public Aktion
@@ -658,7 +692,8 @@ private:
 
 public:
     SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SchalterSetErlaubt();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterAktivieren : public Aktion
@@ -668,7 +703,8 @@ private:
 
 public:
     SchalterAktivieren( Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SchalterAktivieren();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelSetPosition : public Aktion
@@ -680,7 +716,8 @@ private:
 
 public:
     TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TunnelSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelSetZielPosition : public Aktion
@@ -692,7 +729,8 @@ private:
 
 public:
     TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TunnelSetZielPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelSetErlaubt : public Aktion
@@ -703,7 +741,8 @@ private:
 
 public:
     TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TunnelSetErlaubt();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetPosition : public Aktion
@@ -715,7 +754,8 @@ private:
 
 public:
     UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~UmlenkungSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetRichtung : public Aktion
@@ -726,7 +766,8 @@ private:
 
 public:
     UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~UmlenkungSetRichtung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetMaxAbk : public Aktion
@@ -737,7 +778,8 @@ private:
 
 public:
     UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~UmlenkungSetMaxAbk();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetEnabled : public Aktion
@@ -748,7 +790,8 @@ private:
 
 public:
     UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~UmlenkungSetEnabled();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseSetPosition : public Aktion
@@ -760,7 +803,8 @@ private:
 
 public:
     BaseSetPosition( Aktion *x, Aktion *y, Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BaseSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseSetTeam : public Aktion
@@ -771,7 +815,8 @@ private:
 
 public:
     BaseSetTeam( Aktion *team, Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BaseSetTeam();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerRunStart : public Aktion
@@ -781,7 +826,8 @@ private:
 
 public:
     TriggerRunStart( Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TriggerRunStart();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerSetEnabled : public Aktion
@@ -792,7 +838,8 @@ private:
 
 public:
     TriggerSetEnabled( Aktion *enabled, Aktion *trigger );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TriggerSetEnabled();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamSetPunkte : public Aktion
@@ -803,7 +850,8 @@ private:
 
 public:
     TeamSetPunkte( Aktion *punkte, Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TeamSetPunkte();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetPosition : public Aktion
@@ -815,7 +863,8 @@ private:
 
 public:
     TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TimerSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetPause : public Aktion
@@ -826,7 +875,8 @@ private:
 
 public:
     TimerSetPause( Aktion *pause, Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TimerSetPause();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerStart : public Aktion
@@ -836,7 +886,8 @@ private:
 
 public:
     TimerStart( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TimerStart();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetZeit : public Aktion
@@ -847,7 +898,8 @@ private:
 
 public:
     TimerSetZeit( Aktion *zeit, Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TimerSetZeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerSetSichtbar : public Aktion
@@ -858,7 +910,8 @@ private:
 
 public:
     TimerSetSichtbar( Aktion *sichtbar, Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TimerSetSichtbar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossNeu : public Aktion
@@ -871,7 +924,8 @@ private:
 
 public:
     GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossNeu();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetPosition : public Aktion
@@ -883,7 +937,8 @@ private:
 
 public:
     GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetSpeed : public Aktion
@@ -894,7 +949,8 @@ private:
 
 public:
     GeschossSetSpeed( Aktion *speed, Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossSetSpeed();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetPlayer : public Aktion
@@ -905,7 +961,8 @@ private:
 
 public:
     GeschossSetPlayer( Aktion *player, Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossSetPlayer();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetRichtung : public Aktion
@@ -916,7 +973,8 @@ private:
 
 public:
     GeschossSetRichtung( Aktion *richtung, Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossSetRichtung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossSetType : public Aktion
@@ -927,77 +985,78 @@ private:
 
 public:
     GeschossSetType( Aktion *type, Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~GeschossSetType();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerZufall : public Aktion
 {
 public:
     TriggerZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TriggerLastRunned : public Aktion
 {
 public:
     TriggerLastRunned();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZufall : public Aktion
 {
 public:
     BariereZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztEingeschaltet : public Aktion
 {
 public:
     BariereZuletztEingeschaltet();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztAusgeschaltet : public Aktion
 {
 public:
     BariereZuletztAusgeschaltet();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BariereZuletztBewegt : public Aktion
 {
 public:
     BariereZuletztBewegt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseZufall : public Aktion
 {
 public:
     BaseZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BaseZuletztBesitzerGewechselt : public Aktion
 {
 public:
     BaseZuletztBesitzerGewechselt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropZufall : public Aktion
 {
 public:
     DropZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class DropZuletztGedropt : public Aktion
 {
 public:
     DropZuletztGedropt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerRechnen : public Aktion
@@ -1009,7 +1068,8 @@ private:
 
 public:
     IntegerRechnen( Aktion *left, Aktion *right, char op );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerRechnen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerZufall : public Aktion
@@ -1020,7 +1080,8 @@ private:
 
 public:
     IntegerZufall( Aktion *min, Aktion *max );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerZufall();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerAusText : public Aktion
@@ -1030,7 +1091,8 @@ private:
 
 public:
     IntegerAusText( Aktion *text );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerAusText();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonSpieler : public Aktion
@@ -1040,7 +1102,8 @@ private:
 
 public:
     IntegerXVonSpieler( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonSpieler();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonSpieler : public Aktion
@@ -1050,7 +1113,8 @@ private:
 
 public:
     IntegerYVonSpieler( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonSpieler();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonBariere : public Aktion
@@ -1060,7 +1124,8 @@ private:
 
 public:
     IntegerXVonBariere( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonBariere();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonBariere : public Aktion
@@ -1070,7 +1135,8 @@ private:
 
 public:
     IntegerYVonBariere( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonBariere();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonSchalter : public Aktion
@@ -1080,7 +1146,8 @@ private:
 
 public:
     IntegerXVonSchalter( Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonSchalter();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonSchalter : public Aktion
@@ -1090,7 +1157,8 @@ private:
 
 public:
     IntegerYVonSchalter( Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonSchalter();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonTunnel : public Aktion
@@ -1100,7 +1168,8 @@ private:
 
 public:
     IntegerXVonTunnel( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonTunnel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonTunnel : public Aktion
@@ -1110,7 +1179,8 @@ private:
 
 public:
     IntegerYVonTunnel( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonTunnel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonTunnelZiel : public Aktion
@@ -1120,7 +1190,8 @@ private:
 
 public:
     IntegerXVonTunnelZiel( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonTunnelZiel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonTunnelZiel : public Aktion
@@ -1130,7 +1201,8 @@ private:
 
 public:
     IntegerYVonTunnelZiel( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonTunnelZiel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonUmlenkung : public Aktion
@@ -1140,7 +1212,8 @@ private:
 
 public:
     IntegerXVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonUmlenkung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonUmlenkung : public Aktion
@@ -1150,7 +1223,8 @@ private:
 
 public:
     IntegerYVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonUmlenkung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMinXVonDrop : public Aktion
@@ -1160,7 +1234,8 @@ private:
 
 public:
     IntegerMinXVonDrop( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerMinXVonDrop();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMinYVonDrop : public Aktion
@@ -1170,7 +1245,8 @@ private:
 
 public:
     IntegerMinYVonDrop( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerMinYVonDrop();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMaxXVonDrop : public Aktion
@@ -1180,7 +1256,8 @@ private:
 
 public:
     IntegerMaxXVonDrop( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerMaxXVonDrop();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerMaxYVonDrop : public Aktion
@@ -1190,7 +1267,8 @@ private:
 
 public:
     IntegerMaxYVonDrop( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerMaxYVonDrop();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonBase : public Aktion
@@ -1200,7 +1278,8 @@ private:
 
 public:
     IntegerXVonBase( Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonBase();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonBase : public Aktion
@@ -1210,7 +1289,8 @@ private:
 
 public:
     IntegerYVonBase( Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonBase();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonTimer : public Aktion
@@ -1220,7 +1300,8 @@ private:
 
 public:
     IntegerXVonTimer( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonTimer();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonTimer : public Aktion
@@ -1230,7 +1311,8 @@ private:
 
 public:
     IntegerYVonTimer( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonTimer();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerXVonGeschoss : public Aktion
@@ -1240,7 +1322,8 @@ private:
 
 public:
     IntegerXVonGeschoss( Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerXVonGeschoss();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerYVonGeschoss : public Aktion
@@ -1250,7 +1333,8 @@ private:
 
 public:
     IntegerYVonGeschoss( Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerYVonGeschoss();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerLevel : public Aktion
@@ -1260,7 +1344,8 @@ private:
 
 public:
     IntegerSpielerLevel( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerLevel();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerLeben : public Aktion
@@ -1270,7 +1355,8 @@ private:
 
 public:
     IntegerSpielerLeben( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerMaxLeben : public Aktion
@@ -1280,27 +1366,30 @@ private:
 
 public:
     IntegerSpielerMaxLeben( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerMaxLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerErfahrung : public Aktion
+class IntegerSpielerErfahrunNextg : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerErfahrung( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerErfahrunNextg( Aktion *spieler );
+    ~IntegerSpielerErfahrunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerMaxErfahrung : public Aktion
+class IntegerSpielerMaxErfahrunNextg : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerMaxErfahrung( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerMaxErfahrunNextg( Aktion *spieler );
+    ~IntegerSpielerMaxErfahrunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTempo : public Aktion
@@ -1310,7 +1399,8 @@ private:
 
 public:
     IntegerSpielerTempo( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerTempo();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGeschossTempo : public Aktion
@@ -1320,7 +1410,8 @@ private:
 
 public:
     IntegerSpielerGeschossTempo( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerGeschossTempo();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerArmor : public Aktion
@@ -1330,7 +1421,8 @@ private:
 
 public:
     IntegerSpielerArmor( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerArmor();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerSchadenBonus : public Aktion
@@ -1340,7 +1432,8 @@ private:
 
 public:
     IntegerSpielerSchadenBonus( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerSchadenBonus();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerLebensraub : public Aktion
@@ -1350,7 +1443,8 @@ private:
 
 public:
     IntegerSpielerLebensraub( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerLebensraub();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerLebensregeneration : public Aktion
@@ -1360,17 +1454,19 @@ private:
 
 public:
     IntegerSpielerLebensregeneration( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerLebensregeneration();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerAbklingzeitverringerrung : public Aktion
+class IntegerSpielerAbklingzeitverringerrunNextg : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerAbklingzeitverringerrung( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerAbklingzeitverringerrunNextg( Aktion *spieler );
+    ~IntegerSpielerAbklingzeitverringerrunNextg();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTode : public Aktion
@@ -1380,7 +1476,8 @@ private:
 
 public:
     IntegerSpielerTode( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerTode();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerKills : public Aktion
@@ -1390,7 +1487,8 @@ private:
 
 public:
     IntegerSpielerKills( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerKills();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTreffer : public Aktion
@@ -1400,7 +1498,8 @@ private:
 
 public:
     IntegerSpielerTreffer( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerTreffer();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGetroffen : public Aktion
@@ -1410,7 +1509,8 @@ private:
 
 public:
     IntegerSpielerGetroffen( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerGetroffen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerErlittenerSchaden : public Aktion
@@ -1420,7 +1520,8 @@ private:
 
 public:
     IntegerSpielerErlittenerSchaden( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerErlittenerSchaden();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerSchaden : public Aktion
@@ -1430,7 +1531,8 @@ private:
 
 public:
     IntegerSpielerSchaden( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerSchaden();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGeheiltesLeben : public Aktion
@@ -1440,7 +1542,8 @@ private:
 
 public:
     IntegerSpielerGeheiltesLeben( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerGeheiltesLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsAufgehoben : public Aktion
@@ -1450,7 +1553,8 @@ private:
 
 public:
     IntegerSpielerItemsAufgehoben( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerItemsAufgehoben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsVerwendet : public Aktion
@@ -1460,7 +1564,8 @@ private:
 
 public:
     IntegerSpielerItemsVerwendet( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerItemsVerwendet();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsInInventar : public Aktion
@@ -1470,7 +1575,8 @@ private:
 
 public:
     IntegerSpielerItemsInInventar( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerItemsInInventar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerItemsTypeInInventar : public Aktion
@@ -1481,7 +1587,8 @@ private:
 
 public:
     IntegerSpielerItemsTypeInInventar( Aktion *item, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerItemsTypeInInventar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerTunnelBenutzt : public Aktion
@@ -1491,7 +1598,8 @@ private:
 
 public:
     IntegerSpielerTunnelBenutzt( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerTunnelBenutzt();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerSchalterAktiviert : public Aktion
@@ -1501,7 +1609,8 @@ private:
 
 public:
     IntegerSpielerSchalterAktiviert( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerSchalterAktiviert();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerSpielerGeschossen : public Aktion
@@ -1511,7 +1620,8 @@ private:
 
 public:
     IntegerSpielerGeschossen( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerSpielerGeschossen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerDropZeit : public Aktion
@@ -1521,7 +1631,8 @@ private:
 
 public:
     IntegerDropZeit( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerDropZeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerDropMaxZeit : public Aktion
@@ -1531,7 +1642,8 @@ private:
 
 public:
     IntegerDropMaxZeit( Aktion *drop );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerDropMaxZeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereBreite : public Aktion
@@ -1541,7 +1653,8 @@ private:
 
 public:
     IntegerBariereBreite( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerBariereBreite();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereHeight : public Aktion
@@ -1551,7 +1664,8 @@ private:
 
 public:
     IntegerBariereHeight( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerBariereHeight();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereVerschiebungen : public Aktion
@@ -1561,7 +1675,8 @@ private:
 
 public:
     IntegerBariereVerschiebungen( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerBariereVerschiebungen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerBariereSchaltungen : public Aktion
@@ -1571,17 +1686,19 @@ private:
 
 public:
     IntegerBariereSchaltungen( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerBariereSchaltungen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSchalterAktivierungen : public Aktion
+class IntegerSchalterAktivierunNextgen : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
-    IntegerSchalterAktivierungen( Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSchalterAktivierunNextgen( Aktion *schalter );
+    ~IntegerSchalterAktivierunNextgen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTunnelBenutzungen : public Aktion
@@ -1591,7 +1708,8 @@ private:
 
 public:
     IntegerTunnelBenutzungen( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTunnelBenutzungen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerUmlenkungBenutzungen : public Aktion
@@ -1601,7 +1719,8 @@ private:
 
 public:
     IntegerUmlenkungBenutzungen( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerUmlenkungBenutzungen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamPunkte : public Aktion
@@ -1611,7 +1730,8 @@ private:
 
 public:
     IntegerTeamPunkte( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTeamPunkte();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamKills : public Aktion
@@ -1621,7 +1741,8 @@ private:
 
 public:
     IntegerTeamKills( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTeamKills();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamTode : public Aktion
@@ -1631,7 +1752,8 @@ private:
 
 public:
     IntegerTeamTode( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTeamTode();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamWiederbelegungszeit : public Aktion
@@ -1641,7 +1763,8 @@ private:
 
 public:
     IntegerTeamWiederbelegungszeit( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTeamWiederbelegungszeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTeamSpieleranzahl : public Aktion
@@ -1651,7 +1774,8 @@ private:
 
 public:
     IntegerTeamSpieleranzahl( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTeamSpieleranzahl();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTimerAktuelleZeit : public Aktion
@@ -1661,7 +1785,8 @@ private:
 
 public:
     IntegerTimerAktuelleZeit( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTimerAktuelleZeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTimerMaxZeit : public Aktion
@@ -1671,7 +1796,8 @@ private:
 
 public:
     IntegerTimerMaxZeit( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTimerMaxZeit();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class IntegerTriggerRunns : public Aktion
@@ -1681,7 +1807,8 @@ private:
 
 public:
     IntegerTriggerRunns( Aktion *trigger );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~IntegerTriggerRunns();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemSpielerInventar : public Aktion
@@ -1692,84 +1819,85 @@ private:
 
 public:
     ItemSpielerInventar( Aktion *index, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~ItemSpielerInventar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztAufgehoben : public Aktion
 {
 public:
     ItemZuletztAufgehoben();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztAktiviert : public Aktion
 {
 public:
     ItemZuletztAktiviert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZuletztGedropt : public Aktion
 {
 public:
     ItemZuletztGedropt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class ItemZufall : public Aktion
 {
 public:
     ItemZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZufall : public Aktion
 {
 public:
     GeschossZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztAbgefeuert : public Aktion
 {
 public:
     GeschossZuletztAbgefeuert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztUmgelenkt : public Aktion
 {
 public:
     GeschossZuletztUmgelenkt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztBarjereGetroffen : public Aktion
 {
 public:
     GeschossZuletztBarjereGetroffen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztTunnelBenutzt : public Aktion
 {
 public:
     GeschossZuletztTunnelBenutzt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class GeschossZuletztGeschossGetroffen : public Aktion
 {
 public:
     GeschossZuletztGeschossGetroffen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungZufall : public Aktion
 {
 public:
     RichtungZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungVonUmlenkung : public Aktion
@@ -1779,7 +1907,8 @@ private:
 
 public:
     RichtungVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~RichtungVonUmlenkung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class RichtungVonGeschoss : public Aktion
@@ -1789,28 +1918,29 @@ private:
 
 public:
     RichtungVonGeschoss( Aktion *geschoss );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~RichtungVonGeschoss();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterZufall : public Aktion
 {
 public:
     SchalterZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SchalterZuletztAktiviert : public Aktion
 {
 public:
     SchalterZuletztAktiviert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZufall : public Aktion
 {
 public:
     SpielerZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZufallAusTeam : public Aktion
@@ -1820,91 +1950,92 @@ private:
 
 public:
     SpielerZufallAusTeam( Aktion *team );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~SpielerZufallAusTeam();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchadenGemacht : public Aktion
 {
 public:
     SpielerZuletztSchadenGemacht();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchadenGenommen : public Aktion
 {
 public:
     SpielerZuletztSchadenGenommen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGeheilt : public Aktion
 {
 public:
     SpielerZuletztGeheilt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztLevelUp : public Aktion
 {
 public:
     SpielerZuletztLevelUp();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerZuletztErfahrungBekommen : public Aktion
+class SpielerZuletztErfahrunNextgBekommen : public Aktion
 {
 public:
-    SpielerZuletztErfahrungBekommen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    SpielerZuletztErfahrunNextgBekommen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGegenstandAktiviert : public Aktion
 {
 public:
     SpielerZuletztGegenstandAktiviert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGegenstandAufgehoben : public Aktion
 {
 public:
     SpielerZuletztGegenstandAufgehoben();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztSchalterAktiviert : public Aktion
 {
 public:
     SpielerZuletztSchalterAktiviert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztTunnelBenutzt : public Aktion
 {
 public:
     SpielerZuletztTunnelBenutzt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGestorben : public Aktion
 {
 public:
     SpielerZuletztGestorben();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztWiederbelebent : public Aktion
 {
 public:
     SpielerZuletztWiederbelebent();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class SpielerZuletztGeschossGeschossen : public Aktion
 {
 public:
     SpielerZuletztGeschossGeschossen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextConcat : public Aktion
@@ -1915,7 +2046,8 @@ private:
 
 public:
     TextConcat( Aktion *t1, Aktion *t2 );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextConcat();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusZahl : public Aktion
@@ -1925,7 +2057,8 @@ private:
 
 public:
     TextAusZahl( Aktion *zahl );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextAusZahl();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusRichtung : public Aktion
@@ -1935,7 +2068,8 @@ private:
 
 public:
     TextAusRichtung( Aktion *richtung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextAusRichtung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextAusBoolean : public Aktion
@@ -1945,7 +2079,8 @@ private:
 
 public:
     TextAusBoolean( Aktion *boolean );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextAusBoolean();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextSpielerName : public Aktion
@@ -1955,7 +2090,8 @@ private:
 
 public:
     TextSpielerName( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextSpielerName();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextItemName : public Aktion
@@ -1965,7 +2101,8 @@ private:
 
 public:
     TextItemName( Aktion *item );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextItemName();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextTriggerName : public Aktion
@@ -1975,7 +2112,8 @@ private:
 
 public:
     TextTriggerName( Aktion *trigger );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextTriggerName();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TextTeilVonText : public Aktion
@@ -1987,14 +2125,15 @@ private:
 
 public:
     TextTeilVonText( Aktion *start, Aktion *ende, Aktion *text );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TextTeilVonText();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamZufall : public Aktion
 {
 public:
     TeamZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamVonSpieler : public Aktion
@@ -2004,7 +2143,8 @@ private:
 
 public:
     TeamVonSpieler( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TeamVonSpieler();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TeamVonBariere : public Aktion
@@ -2014,84 +2154,85 @@ private:
 
 public:
     TeamVonBariere( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~TeamVonBariere();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZufall : public Aktion
 {
 public:
     TimerZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztAbgelaufen : public Aktion
 {
 public:
     TimerZuletztAbgelaufen();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztGestartet : public Aktion
 {
 public:
     TimerZuletztGestartet();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztPausiert : public Aktion
 {
 public:
     TimerZuletztPausiert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TimerZuletztFortgesetzt : public Aktion
 {
 public:
     TimerZuletztFortgesetzt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelZufall : public Aktion
 {
 public:
     TunnelZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class TunnelZuletztBenutzt : public Aktion
 {
 public:
     TunnelZuletztBenutzt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungZufall : public Aktion
 {
 public:
     UmlenkungZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungZuletztBenutzt : public Aktion
 {
 public:
     UmlenkungZuletztBenutzt();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanZufall : public Aktion
 {
 public:
     BooleanZufall();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielPausiert : public Aktion
 {
 public:
     BooleanSpielPausiert();
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerAmLeben : public Aktion
@@ -2101,7 +2242,8 @@ private:
 
 public:
     BooleanSpielerAmLeben( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSpielerAmLeben();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerHatGegenstand : public Aktion
@@ -2112,7 +2254,8 @@ private:
 
 public:
     BooleanSpielerHatGegenstand( Aktion *item, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSpielerHatGegenstand();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerInTeam : public Aktion
@@ -2123,7 +2266,8 @@ private:
 
 public:
     BooleanSpielerInTeam( Aktion *team, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSpielerInTeam();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerIstVerwundbar : public Aktion
@@ -2133,7 +2277,8 @@ private:
 
 public:
     BooleanSpielerIstVerwundbar( Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSpielerIstVerwundbar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerKannItemBenutzen : public Aktion
@@ -2144,7 +2289,8 @@ private:
 
 public:
     BooleanSpielerKannItemBenutzen( Aktion *item, Aktion *spieler );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSpielerKannItemBenutzen();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanUmlenkungHatAbk : public Aktion
@@ -2154,7 +2300,8 @@ private:
 
 public:
     BooleanUmlenkungHatAbk( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanUmlenkungHatAbk();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanUmlenkungIstDrehend : public Aktion
@@ -2164,7 +2311,8 @@ private:
 
 public:
     BooleanUmlenkungIstDrehend( Aktion *umlenkung );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanUmlenkungIstDrehend();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereBewegtSich : public Aktion
@@ -2174,7 +2322,8 @@ private:
 
 public:
     BooleanBariereBewegtSich( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanBariereBewegtSich();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereIstSchaltend : public Aktion
@@ -2184,7 +2333,8 @@ private:
 
 public:
     BooleanBariereIstSchaltend( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanBariereIstSchaltend();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBariereIstAktiv : public Aktion
@@ -2194,7 +2344,8 @@ private:
 
 public:
     BooleanBariereIstAktiv( Aktion *bariere );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanBariereIstAktiv();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSchalterIstAktiv : public Aktion
@@ -2204,7 +2355,8 @@ private:
 
 public:
     BooleanSchalterIstAktiv( Aktion *schalter );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanSchalterIstAktiv();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTunnelIstAktiv : public Aktion
@@ -2214,7 +2366,8 @@ private:
 
 public:
     BooleanTunnelIstAktiv( Aktion *tunnel );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanTunnelIstAktiv();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanBaseIstNeutral : public Aktion
@@ -2224,7 +2377,8 @@ private:
 
 public:
     BooleanBaseIstNeutral( Aktion *base );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanBaseIstNeutral();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTimerIsRunning : public Aktion
@@ -2234,7 +2388,8 @@ private:
 
 public:
     BooleanTimerIsRunning( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanTimerIsRunning();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTimerIstSichtbar : public Aktion
@@ -2244,7 +2399,8 @@ private:
 
 public:
     BooleanTimerIstSichtbar( Aktion *timer );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanTimerIstSichtbar();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanAusText : public Aktion
@@ -2254,7 +2410,8 @@ private:
 
 public:
     BooleanAusText( Aktion *text );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanAusText();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanTriggerIstAktiv : public Aktion
@@ -2264,7 +2421,8 @@ private:
 
 public:
     BooleanTriggerIstAktiv( Aktion *trigger );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanTriggerIstAktiv();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanGleich : public Aktion
@@ -2275,7 +2433,8 @@ private:
 
 public:
     BooleanGleich( Aktion *v1, Aktion *v2 );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanGleich();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanNicht : public Aktion
@@ -2285,7 +2444,8 @@ private:
 
 public:
     BooleanNicht( Aktion *boolean );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanNicht();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanUnd : public Aktion
@@ -2296,7 +2456,8 @@ private:
 
 public:
     BooleanUnd( Aktion *v1, Aktion *v2 );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanUnd();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanOder : public Aktion
@@ -2307,5 +2468,17 @@ private:
 
 public:
     BooleanOder( Aktion *v1, Aktion *v2 );
-    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
+    ~BooleanOder();
+    bool runNext( 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;
 };

StickmanWorldOnline/Ereignis.cpp

@@ -24,7 +24,7 @@ VarPointer *Ereignis::getParameter( const char *name ) const
 {
     for( auto v = params.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
             return v->getThis();
     }
     return 0;
@@ -34,7 +34,7 @@ VarPointer *Ereignis::zParameter( const char *name ) const
 {
     for( auto v = params.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
             return v;
     }
     return 0;

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -106,6 +106,7 @@
     <ClCompile Include="Team.cpp" />
     <ClCompile Include="TempoRune.cpp" />
     <ClCompile Include="Timer.cpp" />
+    <ClCompile Include="Trigger.cpp" />
     <ClCompile Include="Tunnel.cpp" />
     <ClCompile Include="Umlenkung.cpp" />
     <ClCompile Include="Variablen.cpp" />

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -129,6 +129,9 @@
     <ClCompile Include="Variablen.cpp">
       <Filter>Spiel\Auslöser</Filter>
     </ClCompile>
+    <ClCompile Include="Trigger.cpp">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="SpielKlasse.h">

StickmanWorldOnline/Trigger.cpp

@@ -0,0 +1,122 @@
+#include "Trigger.h"
+#include "Gegenstand.h"
+
+
+VarPointer::VarPointer( const char *name, Variable *var )
+{
+    this->name = name;
+    this->var = var;
+    ref = 1;
+}
+
+VarPointer::~VarPointer()
+{
+    if( var )
+        var->release();
+}
+
+Text VarPointer::getName() const
+{
+    return name;
+}
+
+void VarPointer::setVariable( Variable *var )
+{
+    if( this->var )
+        this->var->release();
+    this->var = var;
+}
+
+Variable *VarPointer::getVariable() const
+{
+    return var ? var->getThis() : 0;
+}
+
+Variable *VarPointer::zVariable() const
+{
+    return var;
+}
+
+VarPointer::operator Variable *( ) const
+{
+    return var;
+}
+
+VarPointer *VarPointer::getThis()
+{
+    ref++;
+    return this;
+}
+
+VarPointer *VarPointer::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+Bedingung::Bedingung( Aktion *expression )
+{
+    this->expression = expression;
+    ref = 1;
+}
+
+Bedingung::~Bedingung()
+{
+    if( expression )
+        expression->release();
+}
+
+void Bedingung::setExpression( Aktion *expr )
+{
+    if( expression )
+        expression->release();
+    expression = expr;
+}
+
+bool Bedingung::check( Spiel *zSpiel, Ereignis *zEreignis )
+{
+    if( !expression )
+        return 1;
+    double wait;
+    ProgramCounter c;
+    LocalMemory m;
+    while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) )
+    {
+        Variable *var = m.zVariable( "__return__" );
+        if( !var )
+            return 0;
+        switch( var->getVariableTyp() )
+        {
+        case NICHTS:
+            return 0;
+        case INTEGER:
+            return ( (Integer *)var )->getValue() != 0;
+        case BOOLEAN:
+            return ( (Boolean *)var )->getValue();
+        case STRING:
+            return ( (String *)var )->getValue().getLength();
+        case FLOAT:
+            return ( (Float *)var )->getValue() != 0;
+        case TASTE:
+            return ( (Integer *)var )->getValue() != 0;
+        case GEGENSTAND_TYP:
+            return ( (GegenstandTypVar *)var )->getValue() != KEIN_GEGENSTAND;
+        default:
+            return 1;
+        }
+    }
+}
+
+Bedingung *Bedingung::getThis()
+{
+    ref++;
+    return this;
+}
+
+Bedingung *Bedingung::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Trigger.h

@@ -19,7 +19,7 @@ private:
 public:
     VarPointer( const char *name, Variable *var );
     ~VarPointer();
-    Text *zName() const;
+    Text getName() const;
     void setVariable( Variable *var );
     Variable *getVariable() const;
     Variable *zVariable() const;
@@ -28,6 +28,40 @@ public:
     VarPointer *release();
 };
 
+class LocalMemory
+{
+private:
+    RCArray< VarPointer > vars;
+    int ref;
+
+public:
+    LocalMemory();
+    ~LocalMemory();
+    void setVar( const char *name, Variable *var );
+    Variable *getVariable( const char *name );
+    Variable *zVariable( const char *name );
+    LocalMemory *getThis();
+    LocalMemory *release();
+};
+
+class ProgramCounter
+{
+private:
+    Array< int > current;
+    int depth;
+    int ref;
+
+public:
+    ProgramCounter();
+    ~ProgramCounter();
+    void stepInto();
+    void count();
+    void stepOut();
+    int currentPosition() const;
+    ProgramCounter *getThis();
+    ProgramCounter *release();
+};
+
 class Bedingung
 {
 private:
@@ -73,6 +107,8 @@ private:
     Trigger *trigger;
     Ereignis *ereignis;
     Spiel *spiel;
+    LocalMemory *localMem;
+    ProgramCounter counter;
     int programCounter;
     double waitCount;
     int ref;