#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;
};