Stickman-World-Online-Server/StickmanWorldOnline/Aktionen.h

#pragma once

#include "Variablen.h"
#include <Array.h>

class Spiel;
class Ereignis;
class ProgramCounter;
class LocalMemory;

enum AktionTyp
{
    BARIERE_BEWEGUNG,
    BARIERE_SET_EINGESCHALTET,
    GAME_OBJEKT_SET_POSITION,
    GAME_OBJEKT_SET_SIZE,
    BARIERE_SET_TEAM,
    BARIERE_ZUFALL,
    BARIERE_ZULETZT_AUSGESCHALTET,
    BARIERE_ZULETZT_BEWEGT,
    BARIERE_ZULETZT_EINGESCHALTET,
    BASE_SET_TEAM,
    BASE_ZUFALL,
    BASE_ZULETZT_BESITZER_GEWECHSELT,
    BOOLEAN_AUS_TEXT,
    BOOLEAN_BARIERE_BEWEGT_SICH,
    BOOLEAN_BARIERE_IST_AKTIV,
    BOOLEAN_BARIERE_IST_SCHALTEND,
    BOOLEAN_BASE_IST_NEUTRAL,
    BOOLEAN_GLEICH,
    BOOLEAN_NICHT,
    BOOLEAN_ODER,
    BOOLEAN_SCHALTER_IST_AKTIV,
    BOOLEAN_SPIELER_AM_LEBEN,
    BOOLEAN_SPIELER_HAT_GEGENSTAND,
    BOOLEAN_SPIELER_IN_TEAM,
    BOOLEAN_SPIELER_IST_VERWUNDBAR,
    BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN,
    BOOLEAN_SPIEL_PAUSIERT,
    BOOLEAN_TIMER_IS_RUNNING,
    BOOLEAN_TIMER_IST_SICHTBAR,
    BOOLEAN_TRIGGER_IST_AKTIV,
    BOOLEAN_TUNNEL_IST_AKTIV,
    BOOLEAN_UMLENKUNG_HAT_ABK,
    BOOLEAN_UMLENKUNG_IST_DREHEND,
    BOOLEAN_UND,
    BOOLEAN_ZUFALL,
    DISPLAY_TEXT,
    DROP_DO_DROP,
    DROP_SET_AREA,
    DROP_SET_MAX_TIME,
    DROP_SET_TIME,
    DROP_ZUFALL,
    DROP_ZULETZT_GEDROPT,
    GESCHOSS_NEU,
    GESCHOSS_SET_PLAYER,
    GESCHOSS_SET_RICHTUNG,
    GESCHOSS_SET_SPEED,
    GESCHOSS_SET_TYPE,
    GESCHOSS_ZUFALL,
    GESCHOSS_ZULETZT_ABGEFEUERT,
    GESCHOSS_ZULETZT_BARIERE_GETROFFEN,
    GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN,
    GESCHOSS_ZULETZT_TUNNEL_BENUTZT,
    GESCHOSS_ZULETZT_UMGELENKT,
    INTEGER_AUS_TEXT,
    FLOAT_GAME_OBJEKT_BREITE,
    FLOAT_GAME_OBJEKT_HEIGHT,
    INTEGER_BARIERE_SCHALTUNGEN,
    INTEGER_BARIERE_VERSCHIEBUNGEN,
    INTEGER_DROP_MAX_ZEIT,
    INTEGER_DROP_ZEIT,
    INTEGER_MAX_X_VON_DROP,
    INTEGER_MAX_Y_VON_DROP,
    INTEGER_MIN_X_VON_DROP,
    INTEGER_MIN_Y_VON_DROP,
    INTEGER_RECHNEN,
    INTEGER_SCHALTER_AKTIVIERUNGEN,
    INTEGER_SPIELER_ABKLINGZEITVERRINGERUNG,
    INTEGER_SPIELER_ARMOR,
    INTEGER_SPIELER_ERFAHRUNG,
    INTEGER_SPIELER_ERLITTENER_SCHADEN,
    INTEGER_SPIELER_GEHEILTES_LEBEN,
    INTEGER_SPIELER_GESCHOSSEN,
    INTEGER_SPIELER_GESCHOSS_TEMPO,
    INTEGER_SPIELER_GETROFFEN,
    INTEGER_SPIELER_ITEMS_AUFGEHOBEN,
    INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR,
    INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP,
    INTEGER_SPIELER_ITEMS_VERWENDET,
    INTEGER_SPIELER_KILLS,
    INTEGER_SPIELER_LEBEN,
    INTEGER_SPIELER_LEBENSRAUB,
    INTEGER_SPIELER_LEBENSREGENERATION,
    INTEGER_SPIELER_LEVEL,
    INTEGER_SPIELER_MAX_ERFAHRUNG,
    INTEGER_SPIELER_MAX_LEBEN,
    INTEGER_SPIELER_SCHADEN,
    INTEGER_SPIELER_SCHADEN_BONUS,
    INTEGER_SPIELER_SCHALTER_AKTIVIERT,
    INTEGER_SPIELER_TEMPO,
    INTEGER_SPIELER_TODE,
    INTEGER_SPIELER_TREFFER,
    INTEGER_SPIELER_TUNNEL_BENUTZT,
    INTEGER_TEAM_KILLS,
    INTEGER_TEAM_PUNKTE,
    INTEGER_TEAM_SPIELERANZAHL,
    INTEGER_TEAM_TODE,
    INTEGER_TEAM_WIEDERBELEBUNGSZEIT,
    INTEGER_TIMER_AKTUELLE_ZEIT,
    INTEGER_TIMER_MAX_ZEIT,
    INTEGER_TRIGGER_RUNNS,
    INTEGER_TUNNEL_BENUTZUNGEN,
    INTEGER_UMLENKUNG_BENUTZUNGEN,
    FLOAT_X_VON_GAME_OBJEKT,
    FLOAT_Y_VON_GAME_OBJEKT,
    INTEGER_X_VON_TUNNEL_ZIEL,
    INTEGER_Y_VON_TUNNEL_ZIEL,
    INTEGER_ZUFALL,
    ITEM_SPIELER_INVENTAR,
    ITEM_ZULETZT_AUFGEHOBEN,
    ITEM_ZULETZT_GEDROPT,
    KONSTANT_BOOLEAN,
    KONSTANT_FLOAT,
    KONSTANT_INTEGER,
    KONSTANT_NICHTS,
    KONSTANT_STRING,
    KONSTANT_VARIABLE,
    RICHTUNG_VON_GESCHOSS,
    RICHTUNG_VON_UMLENKUNG,
    RICHTUNG_ZUFALL,
    SCHALTER_AKTIVIEREN,
    SCHALTER_SET_ERLAUBT,
    SCHALTER_ZUFALL,
    SCHALTER_ZULETZT_AKTIVIERT,
    SET_VARIABLE,
    SPIEL_ENDE,
    SPIELER_GIVE_ITEM,
    SPIELER_NACHRICHT,
    SPIELER_REMOVE_ITEM,
    SPIELER_SET_ABKLINGZEITVERRINGERUNG,
    SPIELER_SET_ARMOR,
    SPIELER_SET_ERFAHRUNG,
    SPIELER_SET_LEBEN,
    SPIELER_SET_LEBENSRAUB,
    SPIELER_SET_LEBENSREGENERATION,
    SPIELER_SET_LEVEL,
    SPIELER_SET_MAX_ERFAHRUNG,
    SPIELER_SET_SCHADEN_BONUS,
    SPIELER_SET_TEMPO,
    SPIELER_SET_GESCHOSS_TEMPO,
    SPIELER_ZUFALL,
    SPIELER_ZUFALL_AUS_TEAM,
    SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN,
    SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT,
    SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN,
    SPIELER_ZULETZT_GEHEILT,
    SPIELER_ZULETZT_GESCHOSSEN,
    SPIELER_ZULETZT_GESTORBEN,
    SPIELER_ZULETZT_LEVEL_UP,
    SPIELER_ZULETZT_SCHADEN_GEMACHT,
    SPIELER_ZULETZT_SCHADEN_GENOMMEN,
    SPIELER_ZULETZT_SCHALTER_AKTIVIERT,
    SPIELER_ZULETZT_TUNNEL_BENUTZT,
    SPIELER_ZULETZT_WIEDERBELEBT,
    SPIEL_PAUSE,
    TEAM_SET_PUNKTE,
    TEAM_VON_BARIERE,
    TEAM_VON_SPIELER,
    TEAM_ZUFALL,
    TEXT_AUS_BOOLEAN,
    TEXT_AUS_RICHTUNG,
    TEXT_AUS_ZAHL,
    TEXT_CONCAT,
    TEXT_ITEM_NAME,
    TEXT_SPIELER_NAME,
    TEXT_TEIL_VON_TEXT,
    TEXT_TRIGGER_NAME,
    TIMER_SET_PAUSE,
    TIMER_SET_SICHTBAR,
    TIMER_SET_ZEIT,
    TIMER_START,
    TIMER_ZUFALL,
    TIMER_ZULETZT_ABGELAUFEN,
    TIMER_ZULETZT_FOTOGRAFIERT,
    TIMER_ZULETZT_GESTARTET,
    TIMER_ZULETZT_PAUSIERT,
    TRIGGER_AKTION,
    TRIGGER_LAST_RUNNED,
    TRIGGER_RUN_START,
    TRIGGER_SET_ENABLED,
    TRIGGER_ZUFALL,
    TUNNEL_SET_ERLAUBT,
    TUNNEL_SET_ZIEL_POSITION,
    TUNNEL_ZUFALL,
    TUNNEL_ZULETZT_BENUTZT,
    UMLENKUNG_SET_ERLAUBT,
    UMLENKUNG_SET_MAX_ABK,
    UMLENKUNG_SET_RICHTUNG,
    UMLENKUNG_ZUFALL,
    UMLENKUNG_ZULETZT_BENUTZT,
    WARTEN,
    WENN_DANN_SONST,
    SEQUENZ
};

enum Operator
{
    PLUS,
    MINUS,
    MAHL,
    GETEILT,
    HOCH,
    WURZEL,
    BIT_ODER,
    BIT_UND,
    BIT_XOR,
    BIT_FLIP,
    BIT_SHIFT_LEFT,
    BIT_SHIFT_RIGHT,
    INVERT_SIGN,
    PLUS_PLUS_LEFT,
    PLUS_PLUS_RIGHT,
    MINUS_MINUS_LEFT,
    MINUS_MINUS_RIGHT,
    LOGARITHM,
    MODULO,
    UND,
    ODER,
    GLEICH,
    UNGLEICH,
    GREATER,
    SMALLER,
    GREATER_OR_EQUAL,
    SMALLER_OR_EQUAL,
    INVERT_BOOL
};

bool isBinary( Operator op );

class Aktion : public Variable
{
private:
    AktionTyp typ;

public:
    Aktion( AktionTyp typ );
    virtual ~Aktion();
    // gibt 1 zurück, wenn die aktion vollständig ausgeführt wurde
    virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) = 0;
};

class KonstantNichts : public Aktion
{
public:
    KonstantNichts();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantInteger : public Aktion
{
private:
    int value;

public:
    KonstantInteger( int val );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantBoolean : public Aktion
{
private:
    bool value;

public:
    KonstantBoolean( bool val );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantString : public Aktion
{
private:
    Text value;

public:
    KonstantString( Text val );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantFloat : public Aktion
{
private:
    float value;

public:
    KonstantFloat( float val );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantVariable : public Aktion
{
private:
    Text name;

public:
    KonstantVariable( Text name );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class Warten : public Aktion
{
private:
    Aktion *seconds;

public:
    Warten( Aktion *seconds );
    ~Warten();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class WennDannSonst : public Aktion
{
private:
    Aktion *wenn;
    Aktion *dann;
    Aktion *sonst;

public:
    WennDannSonst( Aktion *wenn, Aktion *dann, Aktion *sonst );
    ~WennDannSonst();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SetVariable : public Aktion
{
private:
    Text name;
    Aktion *value;

public:
    SetVariable( Text name, Aktion *value );
    ~SetVariable();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerAktion : public Aktion
{
private:
    Aktion *number;
    Aktion *trigger;

public:
    TriggerAktion( Aktion *number, Aktion *triggerName );
    ~TriggerAktion();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerNachricht : public Aktion
{
private:
    Aktion *spieler;
    Aktion *nachricht;

public:
    SpielerNachricht( Aktion *spieler, Aktion *nachricht );
    ~SpielerNachricht();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DisplayText : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *color;
    Aktion *dauer;
    Aktion *nachricht;

public:
    DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht );
    ~DisplayText();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielPause : public Aktion
{
private:
    Aktion *paused;

public:
    SpielPause( Aktion *paused );
    ~SpielPause();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielEnde : public Aktion
{
private:
    Aktion *gewinnerTeam;

public:
    SpielEnde( Aktion *gewinnerTeam );
    ~SpielEnde();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLevel : public Aktion
{
private:
    Aktion *level;
    Aktion *spieler;

public:
    SpielerSetLevel( Aktion *level, Aktion *spieler );
    ~SpielerSetLevel();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerGiveItem : public Aktion
{
private:
    Aktion *item;
    Aktion *anzahl;
    Aktion *spieler;

public:
    SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
    ~SpielerGiveItem();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerRemoveItem : public Aktion
{
private:
    Aktion *item;
    Aktion *anzahl;
    Aktion *spieler;

public:
    SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
    ~SpielerRemoveItem();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLeben : public Aktion
{
private:
    Aktion *leben;
    Aktion *spieler;

public:
    SpielerSetLeben( Aktion *leben, Aktion *spieler );
    ~SpielerSetLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetMaxLeben : public Aktion
{
private:
    Aktion *leben;
    Aktion *spieler;

public:
    SpielerSetMaxLeben( Aktion *leben, Aktion *spieler );
    ~SpielerSetMaxLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetErfahrung : public Aktion
{
private:
    Aktion *erfahrung;
    Aktion *spieler;

public:
    SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler );
    ~SpielerSetErfahrung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetMaxErfahrung : public Aktion
{
private:
    Aktion *erfahrung;
    Aktion *spieler;

public:
    SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler );
    ~SpielerSetMaxErfahrung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetTempo : public Aktion
{
private:
    Aktion *tempo;
    Aktion *spieler;

public:
    SpielerSetTempo( Aktion *tempo, Aktion *spieler );
    ~SpielerSetTempo();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetWaffenTempo : public Aktion
{
private:
    Aktion *tempo;
    Aktion *spieler;

public:
    SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler );
    ~SpielerSetWaffenTempo();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetArmor : public Aktion
{
private:
    Aktion *armor;
    Aktion *spieler;

public:
    SpielerSetArmor( Aktion *armor, Aktion *spieler );
    ~SpielerSetArmor();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetSchadenBonus : public Aktion
{
private:
    Aktion *bonus;
    Aktion *spieler;

public:
    SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler );
    ~SpielerSetSchadenBonus();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLebensraub : public Aktion
{
private:
    Aktion *lebensraub;
    Aktion *spieler;

public:
    SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler );
    ~SpielerSetLebensraub();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLebensregeneration : public Aktion
{
private:
    Aktion *regeneration;
    Aktion *spieler;

public:
    SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler );
    ~SpielerSetLebensregeneration();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetAbklingzeitverringerung : public Aktion
{
private:
    Aktion *verringerung;
    Aktion *spieler;

public:
    SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler );
    ~SpielerSetAbklingzeitverringerung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetTime : public Aktion
{
private:
    Aktion *time;
    Aktion *drop;

public:
    DropSetTime( Aktion *time, Aktion *drop );
    ~DropSetTime();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetMaxTime : public Aktion
{
private:
    Aktion *time;
    Aktion *drop;

public:
    DropSetMaxTime( Aktion *time, Aktion *drop );
    ~DropSetMaxTime();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetArea : public Aktion
{
private:
    Aktion *minX;
    Aktion *maxX;
    Aktion *minY;
    Aktion *maxY;
    Aktion *drop;

public:
    DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop );
    ~DropSetArea();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropDoDrop : public Aktion
{
private:
    Aktion *drop;

public:
    DropDoDrop( Aktion *drop );
    ~DropDoDrop();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereBewegung : public Aktion
{
private:
    Aktion *bariere;

public:
    BariereBewegung( Aktion *bariere );
    ~BariereBewegung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereSetEingeschaltet : public Aktion
{
private:
    Aktion *eingeschaltet;
    Aktion *bariere;

public:
    BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere );
    ~BariereSetEingeschaltet();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GameObjektSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *objekt;

public:
    GameObjektSetPosition( Aktion *x, Aktion *y, Aktion *objekt );
    ~GameObjektSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GameObjektSetSize : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *objekt;

public:
    GameObjektSetSize( Aktion *x, Aktion *y, Aktion *objekt );
    ~GameObjektSetSize();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereSetTeam : public Aktion
{
private:
    Aktion *team;
    Aktion *bariere;

public:
    BariereSetTeam( Aktion *team, Aktion *bariere );
    ~BariereSetTeam();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *schalter;

public:
    SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter );
    ~SchalterSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterSetErlaubt : public Aktion
{
private:
    Aktion *erlaubt;
    Aktion *schalter;

public:
    SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter );
    ~SchalterSetErlaubt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterAktivieren : public Aktion
{
private:
    Aktion *schalter;

public:
    SchalterAktivieren( Aktion *schalter );
    ~SchalterAktivieren();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *tunnel;

public:
    TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel );
    ~TunnelSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelSetZielPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *tunnel;

public:
    TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel );
    ~TunnelSetZielPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelSetErlaubt : public Aktion
{
private:
    Aktion *erlaubt;
    Aktion *tunnel;

public:
    TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel );
    ~TunnelSetErlaubt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *umlenkung;

public:
    UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung );
    ~UmlenkungSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetRichtung : public Aktion
{
private:
    Aktion *richtung;
    Aktion *umlenkung;

public:
    UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung );
    ~UmlenkungSetRichtung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetMaxAbk : public Aktion
{
private:
    Aktion *abk;
    Aktion *umlenkung;

public:
    UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung );
    ~UmlenkungSetMaxAbk();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetEnabled : public Aktion
{
private:
    Aktion *enabled;
    Aktion *umlenkung;

public:
    UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung );
    ~UmlenkungSetEnabled();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *base;

public:
    BaseSetPosition( Aktion *x, Aktion *y, Aktion *base );
    ~BaseSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseSetTeam : public Aktion
{
private:
    Aktion *team;
    Aktion *base;

public:
    BaseSetTeam( Aktion *team, Aktion *base );
    ~BaseSetTeam();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerRunStart : public Aktion
{
private:
    Aktion *trigger;

public:
    TriggerRunStart( Aktion *trigger );
    ~TriggerRunStart();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerSetEnabled : public Aktion
{
private:
    Aktion *enabled;
    Aktion *trigger;

public:
    TriggerSetEnabled( Aktion *enabled, Aktion *trigger );
    ~TriggerSetEnabled();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamSetPunkte : public Aktion
{
private:
    Aktion *punkte;
    Aktion *team;

public:
    TeamSetPunkte( Aktion *punkte, Aktion *team );
    ~TeamSetPunkte();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *timer;

public:
    TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer );
    ~TimerSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetPause : public Aktion
{
private:
    Aktion *pause;
    Aktion *timer;

public:
    TimerSetPause( Aktion *pause, Aktion *timer );
    ~TimerSetPause();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerStart : public Aktion
{
private:
    Aktion *timer;

public:
    TimerStart( Aktion *timer );
    ~TimerStart();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetZeit : public Aktion
{
private:
    Aktion *zeit;
    Aktion *timer;

public:
    TimerSetZeit( Aktion *zeit, Aktion *timer );
    ~TimerSetZeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetSichtbar : public Aktion
{
private:
    Aktion *sichtbar;
    Aktion *timer;

public:
    TimerSetSichtbar( Aktion *sichtbar, Aktion *timer );
    ~TimerSetSichtbar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossNeu : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *typ;
    Aktion *richtung;

public:
    GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung );
    ~GeschossNeu();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetPosition : public Aktion
{
private:
    Aktion *x;
    Aktion *y;
    Aktion *geschoss;

public:
    GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss );
    ~GeschossSetPosition();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetSpeed : public Aktion
{
private:
    Aktion *speed;
    Aktion *geschoss;

public:
    GeschossSetSpeed( Aktion *speed, Aktion *geschoss );
    ~GeschossSetSpeed();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetPlayer : public Aktion
{
private:
    Aktion *player;
    Aktion *geschoss;

public:
    GeschossSetPlayer( Aktion *player, Aktion *geschoss );
    ~GeschossSetPlayer();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetRichtung : public Aktion
{
private:
    Aktion *richtung;
    Aktion *geschoss;

public:
    GeschossSetRichtung( Aktion *richtung, Aktion *geschoss );
    ~GeschossSetRichtung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetType : public Aktion
{
private:
    Aktion *type;
    Aktion *geschoss;

public:
    GeschossSetType( Aktion *type, Aktion *geschoss );
    ~GeschossSetType();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerZufall : public Aktion
{
public:
    TriggerZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerLastRunned : public Aktion
{
public:
    TriggerLastRunned();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereZufall : public Aktion
{
public:
    BariereZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereZuletztEingeschaltet : public Aktion
{
public:
    BariereZuletztEingeschaltet();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereZuletztAusgeschaltet : public Aktion
{
public:
    BariereZuletztAusgeschaltet();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereZuletztBewegt : public Aktion
{
public:
    BariereZuletztBewegt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseZufall : public Aktion
{
public:
    BaseZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseZuletztBesitzerGewechselt : public Aktion
{
public:
    BaseZuletztBesitzerGewechselt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropZufall : public Aktion
{
public:
    DropZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropZuletztGedropt : public Aktion
{
public:
    DropZuletztGedropt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerRechnen : public Aktion
{
private:
    Aktion *left;
    Aktion *right;
    Operator op;

public:
    IntegerRechnen( Aktion *left, Aktion *right, Operator op );
    ~IntegerRechnen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerZufall : public Aktion
{
private:
    Aktion *min;
    Aktion *max;

public:
    IntegerZufall( Aktion *min, Aktion *max );
    ~IntegerZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerAusText : public Aktion
{
private:
    Aktion *text;

public:
    IntegerAusText( Aktion *text );
    ~IntegerAusText();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatXVonGameObjekt : public Aktion
{
private:
    Aktion *objekt;

public:
    FloatXVonGameObjekt( Aktion *objekt );
    ~FloatXVonGameObjekt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatYVonGameObjekt : public Aktion
{
private:
    Aktion *objekt;

public:
    FloatYVonGameObjekt( Aktion *objekt );
    ~FloatYVonGameObjekt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerXVonTunnelZiel : public Aktion
{
private:
    Aktion *tunnel;

public:
    IntegerXVonTunnelZiel( Aktion *tunnel );
    ~IntegerXVonTunnelZiel();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerYVonTunnelZiel : public Aktion
{
private:
    Aktion *tunnel;

public:
    IntegerYVonTunnelZiel( Aktion *tunnel );
    ~IntegerYVonTunnelZiel();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMinXVonDrop : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerMinXVonDrop( Aktion *drop );
    ~IntegerMinXVonDrop();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMinYVonDrop : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerMinYVonDrop( Aktion *drop );
    ~IntegerMinYVonDrop();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMaxXVonDrop : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerMaxXVonDrop( Aktion *drop );
    ~IntegerMaxXVonDrop();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMaxYVonDrop : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerMaxYVonDrop( Aktion *drop );
    ~IntegerMaxYVonDrop();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerLevel : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerLevel( Aktion *spieler );
    ~IntegerSpielerLevel();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerLeben : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerLeben( Aktion *spieler );
    ~IntegerSpielerLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerMaxLeben : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerMaxLeben( Aktion *spieler );
    ~IntegerSpielerMaxLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerErfahrung : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerErfahrung( Aktion *spieler );
    ~IntegerSpielerErfahrung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerMaxErfahrung : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerMaxErfahrung( Aktion *spieler );
    ~IntegerSpielerMaxErfahrung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTempo : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerTempo( Aktion *spieler );
    ~IntegerSpielerTempo();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGeschossTempo : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerGeschossTempo( Aktion *spieler );
    ~IntegerSpielerGeschossTempo();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerArmor : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerArmor( Aktion *spieler );
    ~IntegerSpielerArmor();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerSchadenBonus : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerSchadenBonus( Aktion *spieler );
    ~IntegerSpielerSchadenBonus();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerLebensraub : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerLebensraub( Aktion *spieler );
    ~IntegerSpielerLebensraub();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerLebensregeneration : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerLebensregeneration( Aktion *spieler );
    ~IntegerSpielerLebensregeneration();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerAbklingzeitVerringerung : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerAbklingzeitVerringerung( Aktion *spieler );
    ~IntegerSpielerAbklingzeitVerringerung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTode : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerTode( Aktion *spieler );
    ~IntegerSpielerTode();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerKills : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerKills( Aktion *spieler );
    ~IntegerSpielerKills();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTreffer : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerTreffer( Aktion *spieler );
    ~IntegerSpielerTreffer();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGetroffen : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerGetroffen( Aktion *spieler );
    ~IntegerSpielerGetroffen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerErlittenerSchaden : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerErlittenerSchaden( Aktion *spieler );
    ~IntegerSpielerErlittenerSchaden();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerSchaden : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerSchaden( Aktion *spieler );
    ~IntegerSpielerSchaden();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGeheiltesLeben : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerGeheiltesLeben( Aktion *spieler );
    ~IntegerSpielerGeheiltesLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsAufgehoben : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerItemsAufgehoben( Aktion *spieler );
    ~IntegerSpielerItemsAufgehoben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsVerwendet : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerItemsVerwendet( Aktion *spieler );
    ~IntegerSpielerItemsVerwendet();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsInInventar : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerItemsInInventar( Aktion *spieler );
    ~IntegerSpielerItemsInInventar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsTypeInInventar : public Aktion
{
private:
    Aktion *spieler;
    Aktion *item;

public:
    IntegerSpielerItemsTypeInInventar( Aktion *item, Aktion *spieler );
    ~IntegerSpielerItemsTypeInInventar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTunnelBenutzt : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerTunnelBenutzt( Aktion *spieler );
    ~IntegerSpielerTunnelBenutzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerSchalterAktiviert : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerSchalterAktiviert( Aktion *spieler );
    ~IntegerSpielerSchalterAktiviert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGeschossen : public Aktion
{
private:
    Aktion *spieler;

public:
    IntegerSpielerGeschossen( Aktion *spieler );
    ~IntegerSpielerGeschossen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerDropZeit : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerDropZeit( Aktion *drop );
    ~IntegerDropZeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerDropMaxZeit : public Aktion
{
private:
    Aktion *drop;

public:
    IntegerDropMaxZeit( Aktion *drop );
    ~IntegerDropMaxZeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatGameObjektBreite : public Aktion
{
private:
    Aktion *objekt;

public:
    FloatGameObjektBreite( Aktion *objekt );
    ~FloatGameObjektBreite();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatGameObjektHeight : public Aktion
{
private:
    Aktion *objekt;

public:
    FloatGameObjektHeight( Aktion *objekt );
    ~FloatGameObjektHeight();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerBariereVerschiebungen : public Aktion
{
private:
    Aktion *bariere;

public:
    IntegerBariereVerschiebungen( Aktion *bariere );
    ~IntegerBariereVerschiebungen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerBariereSchaltungen : public Aktion
{
private:
    Aktion *bariere;

public:
    IntegerBariereSchaltungen( Aktion *bariere );
    ~IntegerBariereSchaltungen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSchalterAktivierungen : public Aktion
{
private:
    Aktion *schalter;

public:
    IntegerSchalterAktivierungen( Aktion *schalter );
    ~IntegerSchalterAktivierungen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTunnelBenutzungen : public Aktion
{
private:
    Aktion *tunnel;

public:
    IntegerTunnelBenutzungen( Aktion *tunnel );
    ~IntegerTunnelBenutzungen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerUmlenkungBenutzungen : public Aktion
{
private:
    Aktion *umlenkung;

public:
    IntegerUmlenkungBenutzungen( Aktion *umlenkung );
    ~IntegerUmlenkungBenutzungen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamPunkte : public Aktion
{
private:
    Aktion *team;

public:
    IntegerTeamPunkte( Aktion *team );
    ~IntegerTeamPunkte();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamKills : public Aktion
{
private:
    Aktion *team;

public:
    IntegerTeamKills( Aktion *team );
    ~IntegerTeamKills();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamTode : public Aktion
{
private:
    Aktion *team;

public:
    IntegerTeamTode( Aktion *team );
    ~IntegerTeamTode();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamWiederbelegungszeit : public Aktion
{
private:
    Aktion *team;

public:
    IntegerTeamWiederbelegungszeit( Aktion *team );
    ~IntegerTeamWiederbelegungszeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamSpieleranzahl : public Aktion
{
private:
    Aktion *team;

public:
    IntegerTeamSpieleranzahl( Aktion *team );
    ~IntegerTeamSpieleranzahl();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTimerAktuelleZeit : public Aktion
{
private:
    Aktion *timer;

public:
    IntegerTimerAktuelleZeit( Aktion *timer );
    ~IntegerTimerAktuelleZeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTimerMaxZeit : public Aktion
{
private:
    Aktion *timer;

public:
    IntegerTimerMaxZeit( Aktion *timer );
    ~IntegerTimerMaxZeit();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTriggerRunns : public Aktion
{
private:
    Aktion *trigger;

public:
    IntegerTriggerRunns( Aktion *trigger );
    ~IntegerTriggerRunns();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemSpielerInventar : public Aktion
{
private:
    Aktion *spieler;
    Aktion *index;

public:
    ItemSpielerInventar( Aktion *index, Aktion *spieler );
    ~ItemSpielerInventar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemZuletztAufgehoben : public Aktion
{
public:
    ItemZuletztAufgehoben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemZuletztAktiviert : public Aktion
{
public:
    ItemZuletztAktiviert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemZuletztGedropt : public Aktion
{
public:
    ItemZuletztGedropt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemZufall : public Aktion
{
public:
    ItemZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZufall : public Aktion
{
public:
    GeschossZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZuletztAbgefeuert : public Aktion
{
public:
    GeschossZuletztAbgefeuert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZuletztUmgelenkt : public Aktion
{
public:
    GeschossZuletztUmgelenkt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZuletztBarjereGetroffen : public Aktion
{
public:
    GeschossZuletztBarjereGetroffen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZuletztTunnelBenutzt : public Aktion
{
public:
    GeschossZuletztTunnelBenutzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossZuletztGeschossGetroffen : public Aktion
{
public:
    GeschossZuletztGeschossGetroffen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class RichtungZufall : public Aktion
{
public:
    RichtungZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class RichtungVonUmlenkung : public Aktion
{
private:
    Aktion *umlenkung;

public:
    RichtungVonUmlenkung( Aktion *umlenkung );
    ~RichtungVonUmlenkung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class RichtungVonGeschoss : public Aktion
{
private:
    Aktion *geschoss;

public:
    RichtungVonGeschoss( Aktion *geschoss );
    ~RichtungVonGeschoss();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterZufall : public Aktion
{
public:
    SchalterZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterZuletztAktiviert : public Aktion
{
public:
    SchalterZuletztAktiviert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZufall : public Aktion
{
public:
    SpielerZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZufallAusTeam : public Aktion
{
private:
    Aktion *team;

public:
    SpielerZufallAusTeam( Aktion *team );
    ~SpielerZufallAusTeam();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztSchadenGemacht : public Aktion
{
public:
    SpielerZuletztSchadenGemacht();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztSchadenGenommen : public Aktion
{
public:
    SpielerZuletztSchadenGenommen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztGeheilt : public Aktion
{
public:
    SpielerZuletztGeheilt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztLevelUp : public Aktion
{
public:
    SpielerZuletztLevelUp();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztErfahrungBekommen : public Aktion
{
public:
    SpielerZuletztErfahrungBekommen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztGegenstandAktiviert : public Aktion
{
public:
    SpielerZuletztGegenstandAktiviert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztGegenstandAufgehoben : public Aktion
{
public:
    SpielerZuletztGegenstandAufgehoben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztSchalterAktiviert : public Aktion
{
public:
    SpielerZuletztSchalterAktiviert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztTunnelBenutzt : public Aktion
{
public:
    SpielerZuletztTunnelBenutzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztGestorben : public Aktion
{
public:
    SpielerZuletztGestorben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztWiederbelebent : public Aktion
{
public:
    SpielerZuletztWiederbelebent();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerZuletztGeschossGeschossen : public Aktion
{
public:
    SpielerZuletztGeschossGeschossen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextConcat : public Aktion
{
private:
    Aktion *t1;
    Aktion *t2;

public:
    TextConcat( Aktion *t1, Aktion *t2 );
    ~TextConcat();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusZahl : public Aktion
{
private:
    Aktion *zahl;

public:
    TextAusZahl( Aktion *zahl );
    ~TextAusZahl();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusRichtung : public Aktion
{
private:
    Aktion *richtung;

public:
    TextAusRichtung( Aktion *richtung );
    ~TextAusRichtung();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusBoolean : public Aktion
{
private:
    Aktion *boolean;

public:
    TextAusBoolean( Aktion *boolean );
    ~TextAusBoolean();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextSpielerName : public Aktion
{
private:
    Aktion *spieler;

public:
    TextSpielerName( Aktion *spieler );
    ~TextSpielerName();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextItemName : public Aktion
{
private:
    Aktion *item;

public:
    TextItemName( Aktion *item );
    ~TextItemName();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextTriggerName : public Aktion
{
private:
    Aktion *trigger;

public:
    TextTriggerName( Aktion *trigger );
    ~TextTriggerName();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextTeilVonText : public Aktion
{
private:
    Aktion *start;
    Aktion *ende;
    Aktion *text;

public:
    TextTeilVonText( Aktion *start, Aktion *ende, Aktion *text );
    ~TextTeilVonText();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamZufall : public Aktion
{
public:
    TeamZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamVonSpieler : public Aktion
{
private:
    Aktion *spieler;

public:
    TeamVonSpieler( Aktion *spieler );
    ~TeamVonSpieler();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamVonBariere : public Aktion
{
private:
    Aktion *bariere;

public:
    TeamVonBariere( Aktion *bariere );
    ~TeamVonBariere();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerZufall : public Aktion
{
public:
    TimerZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerZuletztAbgelaufen : public Aktion
{
public:
    TimerZuletztAbgelaufen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerZuletztGestartet : public Aktion
{
public:
    TimerZuletztGestartet();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerZuletztPausiert : public Aktion
{
public:
    TimerZuletztPausiert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerZuletztFortgesetzt : public Aktion
{
public:
    TimerZuletztFortgesetzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelZufall : public Aktion
{
public:
    TunnelZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelZuletztBenutzt : public Aktion
{
public:
    TunnelZuletztBenutzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungZufall : public Aktion
{
public:
    UmlenkungZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungZuletztBenutzt : public Aktion
{
public:
    UmlenkungZuletztBenutzt();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanZufall : public Aktion
{
public:
    BooleanZufall();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielPausiert : public Aktion
{
public:
    BooleanSpielPausiert();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerAmLeben : public Aktion
{
private:
    Aktion *spieler;

public:
    BooleanSpielerAmLeben( Aktion *spieler );
    ~BooleanSpielerAmLeben();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerHatGegenstand : public Aktion
{
private:
    Aktion *spieler;
    Aktion *item;

public:
    BooleanSpielerHatGegenstand( Aktion *item, Aktion *spieler );
    ~BooleanSpielerHatGegenstand();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerInTeam : public Aktion
{
private:
    Aktion *spieler;
    Aktion *team;

public:
    BooleanSpielerInTeam( Aktion *team, Aktion *spieler );
    ~BooleanSpielerInTeam();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerIstVerwundbar : public Aktion
{
private:
    Aktion *spieler;

public:
    BooleanSpielerIstVerwundbar( Aktion *spieler );
    ~BooleanSpielerIstVerwundbar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerKannItemBenutzen : public Aktion
{
private:
    Aktion *spieler;
    Aktion *item;

public:
    BooleanSpielerKannItemBenutzen( Aktion *item, Aktion *spieler );
    ~BooleanSpielerKannItemBenutzen();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanUmlenkungHatAbk : public Aktion
{
private:
    Aktion *umlenkung;

public:
    BooleanUmlenkungHatAbk( Aktion *umlenkung );
    ~BooleanUmlenkungHatAbk();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanUmlenkungIstDrehend : public Aktion
{
private:
    Aktion *umlenkung;

public:
    BooleanUmlenkungIstDrehend( Aktion *umlenkung );
    ~BooleanUmlenkungIstDrehend();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereBewegtSich : public Aktion
{
private:
    Aktion *bariere;

public:
    BooleanBariereBewegtSich( Aktion *bariere );
    ~BooleanBariereBewegtSich();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereIstSchaltend : public Aktion
{
private:
    Aktion *bariere;

public:
    BooleanBariereIstSchaltend( Aktion *bariere );
    ~BooleanBariereIstSchaltend();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereIstAktiv : public Aktion
{
private:
    Aktion *bariere;

public:
    BooleanBariereIstAktiv( Aktion *bariere );
    ~BooleanBariereIstAktiv();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSchalterIstAktiv : public Aktion
{
private:
    Aktion *schalter;

public:
    BooleanSchalterIstAktiv( Aktion *schalter );
    ~BooleanSchalterIstAktiv();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTunnelIstAktiv : public Aktion
{
private:
    Aktion *tunnel;

public:
    BooleanTunnelIstAktiv( Aktion *tunnel );
    ~BooleanTunnelIstAktiv();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBaseIstNeutral : public Aktion
{
private:
    Aktion *base;

public:
    BooleanBaseIstNeutral( Aktion *base );
    ~BooleanBaseIstNeutral();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTimerIsRunning : public Aktion
{
private:
    Aktion *timer;

public:
    BooleanTimerIsRunning( Aktion *timer );
    ~BooleanTimerIsRunning();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTimerIstSichtbar : public Aktion
{
private:
    Aktion *timer;

public:
    BooleanTimerIstSichtbar( Aktion *timer );
    ~BooleanTimerIstSichtbar();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanAusText : public Aktion
{
private:
    Aktion *text;

public:
    BooleanAusText( Aktion *text );
    ~BooleanAusText();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTriggerIstAktiv : public Aktion
{
private:
    Aktion *trigger;

public:
    BooleanTriggerIstAktiv( Aktion *trigger );
    ~BooleanTriggerIstAktiv();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanGleich : public Aktion
{
private:
    Aktion *v1;
    Aktion *v2;

public:
    BooleanGleich( Aktion *v1, Aktion *v2 );
    ~BooleanGleich();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanNicht : public Aktion
{
private:
    Aktion *boolean;

public:
    BooleanNicht( Aktion *boolean );
    ~BooleanNicht();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanUnd : public Aktion
{
private:
    Aktion *v1;
    Aktion *v2;

public:
    BooleanUnd( Aktion *v1, Aktion *v2 );
    ~BooleanUnd();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanOder : public Aktion
{
private:
    Aktion *v1;
    Aktion *v2;

public:
    BooleanOder( Aktion *v1, Aktion *v2 );
    ~BooleanOder();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class Sequenz : public Aktion
{
private:
    RCArray< Aktion > *aktions;

public:
    Sequenz( RCArray< Aktion > *aktions );
    ~Sequenz();
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};