Einiege dinge Vordefiniert die man bestimmt mal braucht

StickmanWorldOnline/Aktionen.h

@@ -0,0 +1,2129 @@
+#pragma once
+
+#include "Variablen.h"
+
+class Memory;
+class Ereignis;
+
+class Aktion
+{
+private:
+    int ref;
+
+public:
+    Aktion();
+    virtual ~Aktion();
+    virtual Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) = 0;
+    Aktion *getThis();
+    Aktion *release();
+};
+
+class KonstantNichts : public Aktion
+{
+public:
+    KonstantNichts();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class KonstantInteger : public Aktion
+{
+private:
+    int value;
+
+public:
+    KonstantInteger( int val );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class KonstantBoolean : public Aktion
+{
+private:
+    bool value;
+
+public:
+    KonstantBoolean( bool val );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class KonstantString : public Aktion
+{
+private:
+    Text value;
+
+public:
+    KonstantString( Text val );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class KonstantFloat : public Aktion
+{
+private:
+    float value;
+
+public:
+    KonstantFloat( float val );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class KonstantVariable : public Aktion
+{
+private:
+    Text name;
+
+public:
+    KonstantVariable( Text name );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class Warten : Aktion
+{
+private:
+    Aktion *seconds;
+
+public:
+    Warten( Aktion *seconds );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SetVariable : Aktion
+{
+private:
+    Text name;
+    Aktion *value;
+
+public:
+    SetVariable( Text name, Aktion *value );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class WennDannSonst : Aktion
+{
+private:
+    Aktion *condition;
+    Aktion *wahr;
+    Aktion *falsch;
+
+public:
+    WennDannSonst( Aktion *condition, Aktion *wahr, Aktion *falsch );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TriggerAktion : Aktion
+{
+private:
+    Aktion *number;
+    Aktion *trigger;
+
+public:
+    TriggerAktion( Aktion *number, Aktion *triggerName );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerNachricht : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *nachricht;
+
+public:
+    SpielerNachricht( Aktion *spieler, Aktion *nachricht );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DisplayText : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *color;
+    Aktion *dauer;
+    Aktion *nachricht;
+
+public:
+    DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielPause : Aktion
+{
+private:
+    Aktion *paused;
+
+public:
+    SpielPause( Aktion *paused );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielEnde : Aktion
+{
+private:
+    Aktion *gewinnerTeam;
+
+public:
+    SpielEnde( Aktion *gewinnerTeam );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetLevel : Aktion
+{
+private:
+    Aktion *level;
+    Aktion *spieler;
+
+public:
+    SpielerSetLevel( Aktion *level, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerGiveItem : Aktion
+{
+private:
+    Aktion *item;
+    Aktion *anzahl;
+    Aktion *spieler;
+
+public:
+    SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerRemoveItem : Aktion
+{
+private:
+    Aktion *item;
+    Aktion *anzahl;
+    Aktion *spieler;
+
+public:
+    SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *spieler;
+
+public:
+    SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetLeben : Aktion
+{
+private:
+    Aktion *leben;
+    Aktion *spieler;
+
+public:
+    SpielerSetLeben( Aktion *leben, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetMaxLeben : Aktion
+{
+private:
+    Aktion *leben;
+    Aktion *spieler;
+
+public:
+    SpielerSetMaxLeben( Aktion *leben, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetErfahrung : Aktion
+{
+private:
+    Aktion *erfahrung;
+    Aktion *spieler;
+
+public:
+    SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetMaxErfahrung : Aktion
+{
+private:
+    Aktion *erfahrung;
+    Aktion *spieler;
+
+public:
+    SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetTempo : Aktion
+{
+private:
+    Aktion *tempo;
+    Aktion *spieler;
+
+public:
+    SpielerSetTempo( Aktion *tempo, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetWaffenTempo : Aktion
+{
+private:
+    Aktion *tempo;
+    Aktion *spieler;
+
+public:
+    SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetArmor : Aktion
+{
+private:
+    Aktion *armor;
+    Aktion *spieler;
+
+public:
+    SpielerSetArmor( Aktion *armor, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetSchadenBonus : Aktion
+{
+private:
+    Aktion *bonus;
+    Aktion *spieler;
+
+public:
+    SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetLebensraub : Aktion
+{
+private:
+    Aktion *lebensraub;
+    Aktion *spieler;
+
+public:
+    SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetLebensregeneration : Aktion
+{
+private:
+    Aktion *regeneration;
+    Aktion *spieler;
+
+public:
+    SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerSetAbklingzeitverringerung : Aktion
+{
+private:
+    Aktion *verringerung;
+    Aktion *spieler;
+
+public:
+    SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropSetTime : Aktion
+{
+private:
+    Aktion *time;
+    Aktion *drop;
+
+public:
+    DropSetTime( Aktion *time, Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropSetMaxTime : Aktion
+{
+private:
+    Aktion *time;
+    Aktion *drop;
+
+public:
+    DropSetMaxTime( Aktion *time, Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropSetArea : Aktion
+{
+private:
+    Aktion *minX;
+    Aktion *maxX;
+    Aktion *minY;
+    Aktion *maxY;
+    Aktion *drop;
+
+public:
+    DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropDoDrop : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    DropDoDrop( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereBewegung : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    BariereBewegung( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereIndividualBewegung : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *bariere;
+
+public:
+    BariereIndividualBewegung( Aktion *x, Aktion *y, Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereSetEingeschaltet : Aktion
+{
+private:
+    Aktion *eingeschaltet;
+    Aktion *bariere;
+
+public:
+    BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *bariere;
+
+public:
+    BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereSetTeam : Aktion
+{
+private:
+    Aktion *team;
+    Aktion *bariere;
+
+public:
+    BariereSetTeam( Aktion *team, Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SchalterSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *schalter;
+
+public:
+    SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SchalterSetErlaubt : Aktion
+{
+private:
+    Aktion *erlaubt;
+    Aktion *schalter;
+
+public:
+    SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SchalterAktivieren : Aktion
+{
+private:
+    Aktion *schalter;
+
+public:
+    SchalterAktivieren( Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TunnelSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *tunnel;
+
+public:
+    TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TunnelSetZielPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *tunnel;
+
+public:
+    TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TunnelSetErlaubt : Aktion
+{
+private:
+    Aktion *erlaubt;
+    Aktion *tunnel;
+
+public:
+    TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *umlenkung;
+
+public:
+    UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungSetRichtung : Aktion
+{
+private:
+    Aktion *richtung;
+    Aktion *umlenkung;
+
+public:
+    UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungSetMaxAbk : Aktion
+{
+private:
+    Aktion *abk;
+    Aktion *umlenkung;
+
+public:
+    UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungSetEnabled : Aktion
+{
+private:
+    Aktion *enabled;
+    Aktion *umlenkung;
+
+public:
+    UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BaseSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *base;
+
+public:
+    BaseSetPosition( Aktion *x, Aktion *y, Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BaseSetTeam : Aktion
+{
+private:
+    Aktion *team;
+    Aktion *base;
+
+public:
+    BaseSetTeam( Aktion *team, Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class AuslöserRun : Aktion
+{
+private:
+    Aktion *auslöser;
+
+public:
+    AuslöserRun( Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class AuslöserSetEnabled : Aktion
+{
+private:
+    Aktion *enabled;
+    Aktion *auslöser;
+
+public:
+    AuslöserSetEnabled( Aktion *enabled, Aktion *auslöser );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TeamSetPunkte : Aktion
+{
+private:
+    Aktion *punkte;
+    Aktion *team;
+
+public:
+    TeamSetPunkte( Aktion *punkte, Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *timer;
+
+public:
+    TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerSetPause : Aktion
+{
+private:
+    Aktion *pause;
+    Aktion *timer;
+
+public:
+    TimerSetPause( Aktion *pause, Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerStart : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    TimerStart( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerSetZeit : Aktion
+{
+private:
+    Aktion *zeit;
+    Aktion *timer;
+
+public:
+    TimerSetZeit( Aktion *zeit, Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerSetSichtbar : Aktion
+{
+private:
+    Aktion *sichtbar;
+    Aktion *timer;
+
+public:
+    TimerSetSichtbar( Aktion *sichtbar, Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossNeu : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *typ;
+    Aktion *richtung;
+
+public:
+    GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossSetPosition : Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *geschoss;
+
+public:
+    GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossSetSpeed : Aktion
+{
+private:
+    Aktion *speed;
+    Aktion *geschoss;
+
+public:
+    GeschossSetSpeed( Aktion *speed, Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossSetPlayer : Aktion
+{
+private:
+    Aktion *player;
+    Aktion *geschoss;
+
+public:
+    GeschossSetPlayer( Aktion *player, Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossSetRichtung : Aktion
+{
+private:
+    Aktion *richtung;
+    Aktion *geschoss;
+
+public:
+    GeschossSetRichtung( Aktion *richtung, Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossSetType : Aktion
+{
+private:
+    Aktion *type;
+    Aktion *geschoss;
+
+public:
+    GeschossSetType( Aktion *type, Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TriggerZufall : Aktion
+{
+public:
+    TriggerZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TriggerLastRunned : Aktion
+{
+public:
+    TriggerLastRunned();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereZufall : Aktion
+{
+public:
+    BariereZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereZuletztEingeschaltet : Aktion
+{
+public:
+    BariereZuletztEingeschaltet();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereZuletztAusgeschaltet : Aktion
+{
+public:
+    BariereZuletztAusgeschaltet();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BariereZuletztBewegt : Aktion
+{
+public:
+    BariereZuletztBewegt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BaseZufall : Aktion
+{
+public:
+    BaseZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BaseZuletztBesitzerGewechselt : Aktion
+{
+public:
+    BaseZuletztBesitzerGewechselt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropZufall : Aktion
+{
+public:
+    DropZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class DropZuletztGedropt : Aktion
+{
+public:
+    DropZuletztGedropt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerRechnen : Aktion
+{
+private:
+    Aktion *left;
+    Aktion *right;
+    char op;
+
+public:
+    IntegerRechnen( Aktion *left, Aktion *right, char op );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerZufall : Aktion
+{
+private:
+    Aktion *min;
+    Aktion *max;
+
+public:
+    IntegerZufall( Aktion *min, Aktion *max );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerAusText : Aktion
+{
+private:
+    Aktion *text;
+
+public:
+    IntegerAusText( Aktion *text );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonSpieler : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerXVonSpieler( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonSpieler : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerYVonSpieler( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonBariere : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerXVonBariere( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonBariere : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerYVonBariere( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonSchalter : Aktion
+{
+private:
+    Aktion *schalter;
+
+public:
+    IntegerXVonSchalter( Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonSchalter : Aktion
+{
+private:
+    Aktion *schalter;
+
+public:
+    IntegerYVonSchalter( Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonTunnel : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    IntegerXVonTunnel( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonTunnel : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    IntegerYVonTunnel( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonTunnelZiel : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    IntegerXVonTunnelZiel( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonTunnelZiel : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    IntegerYVonTunnelZiel( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonUmlenkung : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    IntegerXVonUmlenkung( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonUmlenkung : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    IntegerYVonUmlenkung( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerMinXVonDrop : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerMinXVonDrop( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerMinYVonDrop : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerMinYVonDrop( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerMaxXVonDrop : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerMaxXVonDrop( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerMaxYVonDrop : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerMaxYVonDrop( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonBase : Aktion
+{
+private:
+    Aktion *base;
+
+public:
+    IntegerXVonBase( Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonBase : Aktion
+{
+private:
+    Aktion *base;
+
+public:
+    IntegerYVonBase( Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonTimer : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    IntegerXVonTimer( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonTimer : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    IntegerYVonTimer( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerXVonGeschoss : Aktion
+{
+private:
+    Aktion *geschoss;
+
+public:
+    IntegerXVonGeschoss( Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerYVonGeschoss : Aktion
+{
+private:
+    Aktion *geschoss;
+
+public:
+    IntegerYVonGeschoss( Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerLevel : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerLevel( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerLeben : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerLeben( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerMaxLeben : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerMaxLeben( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerErfahrung : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerErfahrung( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerMaxErfahrung : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerMaxErfahrung( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerTempo : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerTempo( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGeschossTempo : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGeschossTempo( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerRüstung : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerRüstung( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerSchadenBonus : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerSchadenBonus( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerLebensraub : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerLebensraub( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerLebensregeneration : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerLebensregeneration( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerAbklingzeitverringerrung : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerAbklingzeitverringerrung( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerTode : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerTode( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerKills : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerKills( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerTreffer : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerTreffer( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGetroffen : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGetroffen( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerErlittenerSchaden : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerErlittenerSchaden( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerSchaden : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerSchaden( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGeheiltesLeben : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGeheiltesLeben( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerErfahrung : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerErfahrung( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGegenständeAufgehoben : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGegenständeAufgehoben( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGegenständeVerwendet : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGegenständeVerwendet( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsInInventar : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerItemsInInventar( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsTypeInInventar : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *item;
+
+public:
+    IntegerSpielerItemsTypeInInventar( Aktion *item, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerTunnelBenutzt : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerTunnelBenutzt( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerSchalterAktiviert : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerSchalterAktiviert( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSpielerGeschossen : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    IntegerSpielerGeschossen( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerDropZeit : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerDropZeit( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerDropMaxZeit : Aktion
+{
+private:
+    Aktion *drop;
+
+public:
+    IntegerDropMaxZeit( Aktion *drop );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerBariereBreite : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerBariereBreite( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerBariereHöhe : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerBariereHöhe( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerBariereVerschiebungen : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerBariereVerschiebungen( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerBariereSchaltungen : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    IntegerBariereSchaltungen( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerSchalterAktivierungen : Aktion
+{
+private:
+    Aktion *schalter;
+
+public:
+    IntegerSchalterAktivierungen( Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTunnelBenutzungen : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    IntegerTunnelBenutzungen( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerUmlenkungBenutzungen : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    IntegerUmlenkungBenutzungen( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTeamPunkte : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    IntegerTeamPunkte( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTeamKills : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    IntegerTeamKills( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTeamTode : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    IntegerTeamTode( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTeamWiederbelegungszeit : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    IntegerTeamWiederbelegungszeit( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTeamSpieleranzahl : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    IntegerTeamSpieleranzahl( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTimerAktuelleZeit : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    IntegerTimerAktuelleZeit( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTimerMaxZeit : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    IntegerTimerMaxZeit( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class IntegerTriggerRunns : Aktion
+{
+private:
+    Aktion *trigger;
+
+public:
+    IntegerTriggerRunns( Aktion *trigger );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemSpielerInventar : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *index;
+
+public:
+    ItemSpielerInventar( Aktion *index, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemSpielerInventar : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *index;
+
+public:
+    ItemSpielerInventar( Aktion *index, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemZuletztAufgehoben : Aktion
+{
+public:
+    ItemZuletztAufgehoben();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemZuletztAktiviert : Aktion
+{
+public:
+    ItemZuletztAktiviert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemZuletztGedropt : Aktion
+{
+public:
+    ItemZuletztGedropt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class ItemZufall : Aktion
+{
+public:
+    ItemZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZufall : Aktion
+{
+public:
+    GeschossZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZuletztAbgefeuert : Aktion
+{
+public:
+    GeschossZuletztAbgefeuert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZuletztUmgelenkt : Aktion
+{
+public:
+    GeschossZuletztUmgelenkt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZuletztBarjereGetroffen : Aktion
+{
+public:
+    GeschossZuletztBarjereGetroffen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZuletztTunnelBenutzt : Aktion
+{
+public:
+    GeschossZuletztTunnelBenutzt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class GeschossZuletztGeschossGetroffen : Aktion
+{
+public:
+    GeschossZuletztGeschossGetroffen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class RichtungZufall : Aktion
+{
+public:
+    RichtungZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class RichtungVonUmlenkung : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    RichtungVonUmlenkung( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class RichtungVonGeschoss : Aktion
+{
+private:
+    Aktion *geschoss;
+
+public:
+    RichtungVonGeschoss( Aktion *geschoss );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SchalterZufall : Aktion
+{
+public:
+    SchalterZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SchalterZuletztAktiviert : Aktion
+{
+public:
+    SchalterZuletztAktiviert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZufall : Aktion
+{
+public:
+    SpielerZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZufallAusTeam : Aktion
+{
+private:
+    Aktion *team;
+
+public:
+    SpielerZufallAusTeam( Aktion *team );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztSchadenGemacht : Aktion
+{
+public:
+    SpielerZuletztSchadenGemacht();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztSchadenGenommen : Aktion
+{
+public:
+    SpielerZuletztSchadenGenommen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztGeheilt : Aktion
+{
+public:
+    SpielerZuletztGeheilt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztLevelUp : Aktion
+{
+public:
+    SpielerZuletztLevelUp();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztErfahrungBekommen : Aktion
+{
+public:
+    SpielerZuletztErfahrungBekommen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztGegenstandAktiviert : Aktion
+{
+public:
+    SpielerZuletztGegenstandAktiviert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztGegenstandAufgehoben : Aktion
+{
+public:
+    SpielerZuletztGegenstandAufgehoben();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztSchalterAktiviert : Aktion
+{
+public:
+    SpielerZuletztSchalterAktiviert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztTunnelBenutzt : Aktion
+{
+public:
+    SpielerZuletztTunnelBenutzt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztGestorben : Aktion
+{
+public:
+    SpielerZuletztGestorben();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztWiederbelebent : Aktion
+{
+public:
+    SpielerZuletztWiederbelebent();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class SpielerZuletztGeschossGeschossen : Aktion
+{
+public:
+    SpielerZuletztGeschossGeschossen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextConcat : Aktion
+{
+private:
+    Aktion *t1;
+    Aktion *t2;
+
+public:
+    TextConcat( Aktion *t1, Aktion *t2 );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextAusZahl : Aktion
+{
+private:
+    Aktion *zahl;
+
+public:
+    TextAusZahl( Aktion *zahl );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextAusRichtung : Aktion
+{
+private:
+    Aktion *richtung;
+
+public:
+    TextAusRichtung( Aktion *richtung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextAusBoolean : Aktion
+{
+private:
+    Aktion *boolean;
+
+public:
+    TextAusBoolean( Aktion *boolean );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextSpielerName : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    TextSpielerName( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextItemName : Aktion
+{
+private:
+    Aktion *item;
+
+public:
+    TextItemName( Aktion *item );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextTriggerName : Aktion
+{
+private:
+    Aktion *trigger;
+
+public:
+    TextTriggerName( Aktion *trigger );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TextTeilVonText : Aktion
+{
+private:
+    Aktion *start;
+    Aktion *ende;
+    Aktion *text;
+
+public:
+    TextTeilVonText( Aktion *start, Aktion *ende, Aktion *text );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TeamZufall : Aktion
+{
+public:
+    TeamZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TeamVonSpieler : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    TeamVonSpieler( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TeamVonBariere : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    TeamVonBariere( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerZufall : Aktion
+{
+public:
+    TimerZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerZuletztAbgelaufen : Aktion
+{
+public:
+    TimerZuletztAbgelaufen();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerZuletztGestartet : Aktion
+{
+public:
+    TimerZuletztGestartet();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerZuletztPausiert : Aktion
+{
+public:
+    TimerZuletztPausiert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TimerZuletztFortgesetzt : Aktion
+{
+public:
+    TimerZuletztFortgesetzt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TunnelZufall : Aktion
+{
+public:
+    TunnelZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class TunnelZuletztBenutzt : Aktion
+{
+public:
+    TunnelZuletztBenutzt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungZufall : Aktion
+{
+public:
+    UmlenkungZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class UmlenkungZuletztBenutzt : Aktion
+{
+public:
+    UmlenkungZuletztBenutzt();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanZufall : Aktion
+{
+public:
+    BooleanZufall();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielPausiert : Aktion
+{
+public:
+    BooleanSpielPausiert();
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielerAmLeben : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    BooleanSpielerAmLeben( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielerHatGegenstand : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *item;
+
+public:
+    BooleanSpielerHatGegenstand( Aktion *item, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielerInTeam : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *team;
+
+public:
+    BooleanSpielerInTeam( Aktion *team, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielerIstVerwundbar : Aktion
+{
+private:
+    Aktion *spieler;
+
+public:
+    BooleanSpielerIstVerwundbar( Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSpielerIstItemfähig : Aktion
+{
+private:
+    Aktion *spieler;
+    Aktion *item;
+
+public:
+    BooleanSpielerIstItemfähig( Aktion *item, Aktion *spieler );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanUmlenkungHatAbk : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    BooleanUmlenkungHatAbk( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanUmlenkungIstDrehend : Aktion
+{
+private:
+    Aktion *umlenkung;
+
+public:
+    BooleanUmlenkungIstDrehend( Aktion *umlenkung );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanBariereBewegtSich : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    BooleanBariereBewegtSich( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanBariereIstSchaltend : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    BooleanBariereIstSchaltend( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanBariereIstAktiv : Aktion
+{
+private:
+    Aktion *bariere;
+
+public:
+    BooleanBariereIstAktiv( Aktion *bariere );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanSchalterIstAktiv : Aktion
+{
+private:
+    Aktion *schalter;
+
+public:
+    BooleanSchalterIstAktiv( Aktion *schalter );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanTunnelIstAktiv : Aktion
+{
+private:
+    Aktion *tunnel;
+
+public:
+    BooleanTunnelIstAktiv( Aktion *tunnel );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanBaseIstNeutral : Aktion
+{
+private:
+    Aktion *base;
+
+public:
+    BooleanBaseIstNeutral( Aktion *base );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanTimerIsRunning : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    BooleanTimerIsRunning( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanTimerIstSichtbar : Aktion
+{
+private:
+    Aktion *timer;
+
+public:
+    BooleanTimerIstSichtbar( Aktion *timer );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanAusText : Aktion
+{
+private:
+    Aktion *text;
+
+public:
+    BooleanAusText( Aktion *text );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanAuslöserIstAktiv : Aktion
+{
+private:
+    Aktion *auslöser;
+
+public:
+    BooleanAuslöserIstAktiv( Aktion *auslöser );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanGleich : Aktion
+{
+private:
+    Aktion *v1;
+    Aktion *v2;
+
+public:
+    BooleanGleich( Aktion *v1, Aktion *v2 );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanUngleich : Aktion
+{
+private:
+    Aktion *v1;
+    Aktion *v2;
+
+public:
+    BooleanUngleich( Aktion *v1, Aktion *v2 );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanUnd : Aktion
+{
+private:
+    Aktion *v1;
+    Aktion *v2;
+
+public:
+    BooleanUnd( Aktion *v1, Aktion *v2 );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};
+
+class BooleanOder : Aktion
+{
+private:
+    Aktion *v1;
+    Aktion *v2;
+
+public:
+    BooleanOder( Aktion *v1, Aktion *v2 );
+    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+};

StickmanWorldOnline/Ausloeser.h

@@ -1,37 +0,0 @@
-#pragma once
-
-enum AusloeserEreignisTyp
-{
-    AUSLOESER_WURDE_AUSGEFUEHRT,
-    BARIERE_WIRD_GESCHALTET,
-    BARIERE_WIRD_VERSCHOBEN,
-    BASE_BESITZERWECHSEL,
-    GEGENSTAND_DROP,
-    INITIALISIERUNG,
-    SCHALTER_AKTIVIERT,
-    SPIEL_SCHLEIFE,
-    SPIEL_ZEITPUNKT,
-    SPIELER_DRUEKCKT_TASTE,
-
-};
-
-struct AusloeserEreignis
-{
-    AusloeserEreignisTyp typ;
-    void *p1;
-    void *p2;
-};
-
-class Ausloeser
-{
-private:
-    int Ereignisanzahl = 0;
-    int Bedingunganzahl = 0;
-    int Aktionanzahl = 0;
-    Ereignis[] e = new Ereignis[ 1 ];
-    Bedingung[] b = new Bedingung[ 1 ];
-    Aktion[] a = new Aktion[ 1 ];
-    boolean aktiv = true;
-    int runs = 0;
-    String name = "";
-};

StickmanWorldOnline/Bedingung.h

@@ -0,0 +1 @@
+#pragma once

StickmanWorldOnline/Drop.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "Variablen.h"
+
+class Drop : public Variable
+{
+
+};

StickmanWorldOnline/Ereignis.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Array.h>
+#include "Variablen.h"
+
+class VarPointer;
+
+enum EreignisTyp
+{
+    AUSLOESER_RUNNED,
+    BARIERE_SWITCHED,
+    BARIERE_WIRD_VERSCHOBEN,
+    BASIS_BESITZERWECHSEL,
+    GEGENSTAND_ERSCHEINT,
+    INITIALISIERUNG,
+    SCHALTER_AKTIVIERT,
+    SPIELER_BENUTZT_GEGENSTAND,
+    SPIELER_KEY_PRESSED,
+    SPIELER_BEKOMMT_ERFAHRUNG,
+    SPIELER_BEKOMMT_GEGENSTAND,
+    SPIELER_KEY_RELEASED,
+    SPIELER_LEVEL_UP,
+    SPIELER_MACHT_SCHADEN,
+    SPIELER_NIMMT_SCHADEN,
+    SPIELER_STIRBT,
+    SPIELER_WIEDERBELEBT,
+    SPIELER_WIRD_GEHEILT,
+    TIMER_RUNNS_OUT,
+    TIMER_BEGINNT,
+    TUNNEL_BENUTZT,
+    UMLENKUNG_LENKT_UM
+};
+
+class Ereignis
+{
+private:
+    EreignisTyp typ;
+    RCArray< VarPointer > params;
+    int ref;
+
+public:
+    Ereignis( EreignisTyp typ );
+    ~Ereignis();
+    EreignisTyp getTyp() const;
+    void addParameter( const char *name, Variable *var );
+    VarPointer *getParameter( const char *name ) const;
+    VarPointer *zParameter( const char *name ) const;
+    Ereignis *getThis();
+    Ereignis *release();
+};

StickmanWorldOnline/GameObject.h

@@ -1,6 +1,8 @@
 #pragma once
 
-class GameObject
+#include "Variablen.h"
+
+class GameObject : public Variable
 {
 protected:
     int x, y, w, h;
@@ -8,7 +10,6 @@ protected:
 public:
     GameObject();
     GameObject( int x, int y, int width, int height );
-
     void setX( int x );
     void setY( int y );
     void setWidth( int width );

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -80,10 +80,13 @@
     <ClCompile Include="DllStart.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Ausloeser.h" />
+    <ClInclude Include="Aktionen.h" />
+    <ClInclude Include="Trigger.h" />
     <ClInclude Include="Bariere.h" />
     <ClInclude Include="Base.h" />
+    <ClInclude Include="Drop.h" />
     <ClInclude Include="Editor.h" />
+    <ClInclude Include="Ereignis.h" />
     <ClInclude Include="ESEditorV.h" />
     <ClInclude Include="GameObject.h" />
     <ClInclude Include="Gegenstand.h" />
@@ -98,6 +101,7 @@
     <ClInclude Include="Timer.h" />
     <ClInclude Include="Tunnel.h" />
     <ClInclude Include="Umlenkung.h" />
+    <ClInclude Include="Variablen.h" />
   </ItemGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Link>

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -53,9 +53,6 @@
     <ClInclude Include="Spiel.h">
       <Filter>Spiel</Filter>
     </ClInclude>
-    <ClInclude Include="Ausloeser.h">
-      <Filter>Spiel\Auslöser</Filter>
-    </ClInclude>
     <ClInclude Include="Umlenkung.h">
       <Filter>Spiel\System</Filter>
     </ClInclude>
@@ -86,5 +83,20 @@
     <ClInclude Include="Bariere.h">
       <Filter>Spiel\System</Filter>
     </ClInclude>
+    <ClInclude Include="Variablen.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Ereignis.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Aktionen.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Drop.h">
+      <Filter>Spiel\System</Filter>
+    </ClInclude>
+    <ClInclude Include="Trigger.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

StickmanWorldOnline/Trigger.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <Array.h>
+#include "Ereignis.h"
+#include "Aktionen.h"
+
+using namespace Framework;
+
+class TriggerRun;
+
+class VarPointer
+{
+private:
+    Variable *var;
+    Text name;
+    int ref;
+
+public:
+    VarPointer( const char *name, Variable *var );
+    ~VarPointer();
+    void setVariable( Variable *var );
+    Variable *getVariable() const;
+    Variable *zVariable() const;
+    operator Variable *( ) const;
+    VarPointer *getThis();
+    VarPointer *release();
+};
+
+class Memory
+{
+private:
+    RCArray< VarPointer > variablen;
+    int ref;
+
+public:
+    Memory();
+    ~Memory();
+    void addVariable( const char *name, Variable *var );
+    void setVariable( const char *name, Variable *var );
+    Variable *getVariable( const char *name ) const;
+    Variable *zVariable( const char *name ) const;
+    Memory *getThis();
+    Memory *release();
+};
+
+class Bedingung
+{
+private:
+    Aktion *expression;
+    int ref;
+
+public:
+    Bedingung();
+    ~Bedingung();
+    void setExpression( Aktion *expr );
+    bool check( Memory *zMem, Ereignis *zEreignis );
+    Bedingung *getThis();
+    Bedingung *release();
+};
+
+class Trigger : public Variable
+{
+private:
+    int ereignisAnzahl;
+    EreignisTyp *ereignisse;
+    RCArray< Bedingung > *bedingungen;
+    RCArray< Aktion > *aktionen;
+
+public:
+    Trigger();
+    ~Trigger();
+    int getAktionAnzahl() const;
+    Aktion *zAktion( int index ) const;
+    Aktion *getAktion( int index ) const;
+    // prüft ob der auslöser von einem bestimmten ereignis ausgelößt wird
+    bool wirdGetriggertVon( EreignisTyp typ ) const;
+    // return: 0, falls die bedingungen nicht erfüllt sind
+    TriggerRun *runTrigger( Ereignis *e, Memory *mem );
+};
+
+class TriggerRun
+{
+private:
+    Trigger *trigger;
+    Ereignis *ereignis;
+    Memory *memory;
+    int programCounter;
+    double waitCount;
+    int ref;
+
+public:
+    TriggerRun( Trigger *trig, Ereignis *e, Memory *mem );
+    ~TriggerRun();
+    // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
+    bool runNext( double t );
+};

StickmanWorldOnline/Variablen.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <Text.h>
+
+using namespace Framework;
+
+enum VariableTyp
+{
+    NICHTS,
+    INTEGER,
+    BOOLEAN,
+    STRING,
+    RICHTUNG,
+    FLOAT,
+    TASTE,
+    SPIELER,
+    TIMER,
+    TEAM,
+    BARIERE,
+    SCHALTER,
+    BASE,
+    GEGENSTAND,
+    SCHIENE,
+    TUNNEL,
+    UMLENKUNG,
+    TRIGGER
+};
+
+class Variable
+{
+private:
+    VariableTyp typ;
+    int ref;
+
+public:
+    Variable( VariableTyp typ );
+    virtual ~Variable();
+    VariableTyp getTyp() const;
+    Variable *getThis();
+    Variable *release();
+};
+
+class Integer : public Variable
+{
+private:
+    int value;
+
+public:
+    Integer( bool taste = 0 );
+    void setValue( int value );
+    int getValue() const;
+};
+
+class Boolean : public Variable
+{
+private:
+    bool value;
+
+public:
+    Boolean();
+    void setValue( bool value );
+    bool getValue() const;
+};
+
+class String : public Variable
+{
+private:
+    Text value;
+
+public:
+    String( bool richtung = 0 );
+    void setValue( Text value );
+    const Text &getValue() const;
+};
+
+class Float : public Variable
+{
+private:
+    float value;
+
+public:
+    Float();
+    void setValue( float value );
+    float getValue() const;
+};