Stickman-World-Online-Client/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_START_TEAM_CHANGE,
    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_RECHNUNG,
    BOOLEAN_SCHALTER_IST_AKTIV,
    BOOLEAN_SPIELER_AM_LEBEN,
    BOOLEAN_SPIELER_HAT_GEGENSTAND,
    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_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,
    FLOAT_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,
    FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG,
    FLOAT_SPIELER_ARMOR,
    FLOAT_SPIELER_ERFAHRUNG,
    FLOAT_SPIELER_ERLITTENER_SCHADEN,
    FLOAT_SPIELER_GEHEILTES_LEBEN,
    INTEGER_SPIELER_GESCHOSSEN,
    FLOAT_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,
    FLOAT_SPIELER_LEBEN,
    FLOAT_SPIELER_LEBENSRAUB,
    FLOAT_SPIELER_LEBENSREGENERATION,
    INTEGER_SPIELER_LEVEL,
    INTEGER_SPIELER_MAX_ERFAHRUNG,
    INTEGER_SPIELER_MAX_LEBEN,
    FLOAT_SPIELER_SCHADEN,
    FLOAT_SPIELER_SCHADEN_BONUS,
    INTEGER_SPIELER_SCHALTER_AKTIVIERT,
    FLOAT_SPIELER_TEMPO,
    INTEGER_SPIELER_TODE,
    INTEGER_SPIELER_TREFFER,
    INTEGER_SPIELER_TUNNEL_BENUTZT,
    INTEGER_TEAM_KILLS,
    INTEGER_TEAM_PUNKTE,
    INTEGER_TEAM_SPIELERANZAHL,
    INTEGER_TEAM_TODE,
    FLOAT_TEAM_WIEDERBELEBUNGSZEIT,
    FLOAT_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_AKTIVIERT,
    ITEM_ZULETZT_GEDROPT,
    ITEM_ZUFALL,
    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_INTEGER,
    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,
    FLOAT_RECHNUNG,
    FLOAT_AUS_INTEGER,
    FLOAT_AUS_TEXT,
    TEXT_AUS_FLOAT,
    FLOAT_ZUFALL,
    INTEGER_AUS_FLOAT,
    KONSTANT_TASTE,
    KONSTANT_GEGENSTAND_TYP,
    BESTENLISTE_NEU,
    BESTENLISTE_ADD_SPALTE,
    BESTENLISTE_ADD_ZEILE,
    BESTENLISTE_SET_WERT,
    BESTENLISTE_GET_WERT
};

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
{
protected:
    RCArray< Aktion > *subActions;
    Array< VariableTyp > erlaubteTypen;
    AktionTyp typ;
    Variable *zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );
    Variable *getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );

public:
    Aktion( AktionTyp typ, RCArray< Aktion > *subActions );
    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 );
    virtual void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount );
};

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

class KonstantInteger : public Aktion
{
private:
    int value;

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

class KonstantGegenstandTyp : public Aktion
{
private:
    GegenstandTyp value;

public:
    KonstantGegenstandTyp( GegenstandTyp val );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantTaste : public Aktion
{
private:
    unsigned char value;

public:
    KonstantTaste( unsigned char taste );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class KonstantBoolean : public Aktion
{
private:
    bool value;

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

class KonstantString : public Aktion
{
private:
    Text value;

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

class KonstantFloat : public Aktion
{
private:
    float value;

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

class KonstantVariable : public Aktion
{
private:
    Text name;

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

class Warten : public Aktion
{
public:
    // zeit
    Warten( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class WennDannSonst : public Aktion
{
public:
    // wenn, dann, sonst
    WennDannSonst( RCArray< Aktion > *subActions );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SetVariable : public Aktion
{
private:
    Text name;

public:
    // value
    SetVariable( Text name, RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerAktion : public Aktion
{
public:
    // number, triggerName
    TriggerAktion( RCArray< Aktion > *subActions );
    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerNachricht : public Aktion
{
public:
    // Spieler, Nachricht
    SpielerNachricht( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DisplayText : public Aktion
{
public:
    // x, y, color, dauer, nachricht
    DisplayText( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielPause : public Aktion
{
public:
    // paused
    SpielPause( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielEnde : public Aktion
{
public:
    // gewinner team
    SpielEnde( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLevel : public Aktion
{
public:
    // level, spieler
    SpielerSetLevel( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerGiveItem : public Aktion
{
public:
    // item, anzahl, spieler
    SpielerGiveItem( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerRemoveItem : public Aktion
{
public:
    // item, anzahl, spieler
    SpielerRemoveItem( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLeben : public Aktion
{
public:
    // leben, spieler
    SpielerSetLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetMaxLeben : public Aktion
{
public:
    // leben, spieler
    SpielerSetMaxLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetErfahrung : public Aktion
{
public:
    // erfahrung, spieler
    SpielerSetErfahrung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetMaxErfahrung : public Aktion
{
public:
    // erfahrung, spieler
    SpielerSetMaxErfahrung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetTempo : public Aktion
{
public:
    // tempo, spieler
    SpielerSetTempo( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetWaffenTempo : public Aktion
{
public:
    // tempo, spieler
    SpielerSetWaffenTempo( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetArmor : public Aktion
{
public:
    // armor, spieler
    SpielerSetArmor( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetSchadenBonus : public Aktion
{
public:
    // bonus, spieler
    SpielerSetSchadenBonus( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLebensraub : public Aktion
{
public:
    // lebensrauf, spieler
    SpielerSetLebensraub( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetLebensregeneration : public Aktion
{
public:
    // regeneration, spieler
    SpielerSetLebensregeneration( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SpielerSetAbklingzeitverringerung : public Aktion
{
public:
    // verringerung, spieler
    SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetTime : public Aktion
{
public:
    // time, drop
    DropSetTime( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetMaxTime : public Aktion
{
public:
    // time, drop
    DropSetMaxTime( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropSetArea : public Aktion
{
public:
    // minX, maxX, minY, maxY, drop
    DropSetArea( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class DropDoDrop : public Aktion
{
public:
    // drop
    DropDoDrop( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereBewegung : public Aktion
{
public:
    // bariere
    BariereBewegung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereSetEingeschaltet : public Aktion
{
public:
    // eingeschaltet, bariere
    BariereSetEingeschaltet( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GameObjektSetPosition : public Aktion
{
public:
    // x, y, objekt
    GameObjektSetPosition( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GameObjektSetSize : public Aktion
{
public:
    // x, y, objekt
    GameObjektSetSize( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BariereSetTeam : public Aktion
{
public:
    // team, bariere
    BariereSetTeam( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterSetErlaubt : public Aktion
{
public:
    // erlaubt, schalter
    SchalterSetErlaubt( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class SchalterAktivieren : public Aktion
{
public:
    // schalter
    SchalterAktivieren( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelSetZielPosition : public Aktion
{
public:
    // x, y, tunnel
    TunnelSetZielPosition( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TunnelSetErlaubt : public Aktion
{
public:
    // erlaubt, tunnel
    TunnelSetErlaubt( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetRichtung : public Aktion
{
public:
    // richtung, umlenkung
    UmlenkungSetRichtung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetMaxAbk : public Aktion
{
public:
    // abk, umlenkung
    UmlenkungSetMaxAbk( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class UmlenkungSetEnabled : public Aktion
{
public:
    // enabled, umlenkung
    UmlenkungSetEnabled( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseSetTeam : public Aktion
{
public:
    // team, base
    BaseSetTeam( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BaseStartTeamChange : public Aktion
{
public:
    // team, base
    BaseStartTeamChange( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerRunStart : public Aktion
{
public:
    // trigger
    TriggerRunStart( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TriggerSetEnabled : public Aktion
{
public:
    // enabled, trigger
    TriggerSetEnabled( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamSetPunkte : public Aktion
{
public:
    // punkte, team
    TeamSetPunkte( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetPause : public Aktion
{
public:
    // pause, timer
    TimerSetPause( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerStart : public Aktion
{
public:
    // timer
    TimerStart( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetZeit : public Aktion
{
public:
    // zeit, timer
    TimerSetZeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TimerSetSichtbar : public Aktion
{
public:
    // sichtbar, timer
    TimerSetSichtbar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossNeu : public Aktion
{
public:
    // x, y, typ, richtung
    GeschossNeu( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetSpeed : public Aktion
{
public:
    // speed, geschoss
    GeschossSetSpeed( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetPlayer : public Aktion
{
public:
    // player, geschoss
    GeschossSetPlayer( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetRichtung : public Aktion
{
public:
    // richtung, geschoss
    GeschossSetRichtung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class GeschossSetType : public Aktion
{
public:
    // typ, geschoss
    GeschossSetType( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

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

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

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

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

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

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

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

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

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

class IntegerRechnen : public Aktion
{
private:
    Operator op;

public:
    // left, right
    IntegerRechnen( RCArray< Aktion > *subActions, Operator op );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerZufall : public Aktion
{
public:
    // min, max
    IntegerZufall( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerAusText : public Aktion
{
public:
    // text
    IntegerAusText( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatXVonGameObjekt : public Aktion
{
public:
    // objekt
    FloatXVonGameObjekt( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatYVonGameObjekt : public Aktion
{
public:
    // objekt
    FloatYVonGameObjekt( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerXVonTunnelZiel : public Aktion
{
public:
    // tunnel
    IntegerXVonTunnelZiel( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerYVonTunnelZiel : public Aktion
{
public:
    // tunnel
    IntegerYVonTunnelZiel( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMinXVonDrop : public Aktion
{
public:
    // drop
    IntegerMinXVonDrop( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMinYVonDrop : public Aktion
{
public:
    // drop
    IntegerMinYVonDrop( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMaxXVonDrop : public Aktion
{
public:
    // drop
    IntegerMaxXVonDrop( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerMaxYVonDrop : public Aktion
{
public:
    // drop
    IntegerMaxYVonDrop( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerLevel : public Aktion
{
public:
    // spieler
    IntegerSpielerLevel( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerLeben : public Aktion
{
public:
    // spieler
    FloatSpielerLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerMaxLeben : public Aktion
{
public:
    // spieler
    IntegerSpielerMaxLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerErfahrung : public Aktion
{
public:
    // spieler
    FloatSpielerErfahrung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerMaxErfahrung : public Aktion
{
public:
    // spieler
    IntegerSpielerMaxErfahrung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerTempo : public Aktion
{
public:
    // spieler
    FloatSpielerTempo( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerGeschossTempo : public Aktion
{
public:
    // spieler
    FloatSpielerGeschossTempo( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerArmor : public Aktion
{
public:
    // spieler
    FloatSpielerArmor( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerSchadenBonus : public Aktion
{
public:
    // spieler
    FloatSpielerSchadenBonus( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerLebensraub : public Aktion
{
public:
    // spieler
    FloatSpielerLebensraub( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerLebensregeneration : public Aktion
{
public:
    // spieler
    FloatSpielerLebensregeneration( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerAbklingzeitVerringerung : public Aktion
{
public:
    // spieler
    FloatSpielerAbklingzeitVerringerung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTode : public Aktion
{
public:
    // spieler
    IntegerSpielerTode( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerKills : public Aktion
{
public:
    // spieler
    IntegerSpielerKills( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTreffer : public Aktion
{
public:
    // spieler
    IntegerSpielerTreffer( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGetroffen : public Aktion
{
public:
    // spieler
    IntegerSpielerGetroffen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerErlittenerSchaden : public Aktion
{
public:
    // spieler
    FloatSpielerErlittenerSchaden( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerSchaden : public Aktion
{
public:
    // spieler
    FloatSpielerSchaden( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatSpielerGeheiltesLeben : public Aktion
{
public:
    // spieler
    FloatSpielerGeheiltesLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsAufgehoben : public Aktion
{
public:
    // spieler
    IntegerSpielerItemsAufgehoben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsVerwendet : public Aktion
{
public:
    // spieler
    IntegerSpielerItemsVerwendet( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsInInventar : public Aktion
{
public:
    // spieler
    IntegerSpielerItemsInInventar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerItemsTypeInInventar : public Aktion
{
public:
    // item, spieler
    IntegerSpielerItemsTypeInInventar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerTunnelBenutzt : public Aktion
{
public:
    // spieler
    IntegerSpielerTunnelBenutzt( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerSchalterAktiviert : public Aktion
{
public:
    // spieler
    IntegerSpielerSchalterAktiviert( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSpielerGeschossen : public Aktion
{
public:
    // spieler
    IntegerSpielerGeschossen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatDropZeit : public Aktion
{
public:
    // drop
    FloatDropZeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerDropMaxZeit : public Aktion
{
public:
    // drop
    IntegerDropMaxZeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatGameObjektBreite : public Aktion
{
public:
    // objekt
    FloatGameObjektBreite( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatGameObjektHeight : public Aktion
{
public:
    // objekt
    FloatGameObjektHeight( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerBariereVerschiebungen : public Aktion
{
public:
    // bariere
    IntegerBariereVerschiebungen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerBariereSchaltungen : public Aktion
{
public:
    // bariere
    IntegerBariereSchaltungen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerSchalterAktivierungen : public Aktion
{
public:
    // schalter
    IntegerSchalterAktivierungen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTunnelBenutzungen : public Aktion
{
public:
    // tunnel
    IntegerTunnelBenutzungen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerUmlenkungBenutzungen : public Aktion
{
public:
    // umlenkung
    IntegerUmlenkungBenutzungen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamPunkte : public Aktion
{
public:
    // team
    IntegerTeamPunkte( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamKills : public Aktion
{
public:
    // team
    IntegerTeamKills( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamTode : public Aktion
{
public:
    // team
    IntegerTeamTode( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatTeamWiederbelegungszeit : public Aktion
{
public:
    // team
    FloatTeamWiederbelegungszeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTeamSpieleranzahl : public Aktion
{
public:
    // team
    IntegerTeamSpieleranzahl( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatTimerAktuelleZeit : public Aktion
{
public:
    // timer
    FloatTimerAktuelleZeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTimerMaxZeit : public Aktion
{
public:
    // timer
    IntegerTimerMaxZeit( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerTriggerRunns : public Aktion
{
public:
    // trigger
    IntegerTriggerRunns( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class ItemSpielerInventar : public Aktion
{
public:
    // index, spieler
    ItemSpielerInventar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

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

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

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

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

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

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

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

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

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

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

class RichtungVonUmlenkung : public Aktion
{
public:
    // umlenkung
    RichtungVonUmlenkung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class RichtungVonGeschoss : public Aktion
{
public:
    // geschoss
    RichtungVonGeschoss( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

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

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

class SpielerZufallAusTeam : public Aktion
{
public:
    // team
    SpielerZufallAusTeam( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

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

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

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

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

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

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

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

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

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

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

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

class TextConcat : public Aktion
{
public:
    // t1, t2
    TextConcat( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusInteger : public Aktion
{
public:
    // integer
    TextAusInteger( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusRichtung : public Aktion
{
public:
    // richtung
    TextAusRichtung( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusBoolean : public Aktion
{
public:
    // boolean
    TextAusBoolean( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextSpielerName : public Aktion
{
public:
    // spieler
    TextSpielerName( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextItemName : public Aktion
{
public:
    // item
    TextItemName( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextTriggerName : public Aktion
{
public:
    // trigger
    TextTriggerName( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextTeilVonText : public Aktion
{
public:
    // start, ende, text
    TextTeilVonText( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

class TeamVonSpieler : public Aktion
{
public:
    // spieler
    TeamVonSpieler( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TeamVonBariere : public Aktion
{
public:
    // bariere
    TeamVonBariere( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

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

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

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

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

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

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

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

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

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

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

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

class BooleanSpielerAmLeben : public Aktion
{
public:
    // spieler
    BooleanSpielerAmLeben( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerHatGegenstand : public Aktion
{
public:
    // item, spieler
    BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerIstVerwundbar : public Aktion
{
public:
    // richtung, spieler
    BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSpielerKannItemBenutzen : public Aktion
{
public:
    // item, spieler
    BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanUmlenkungHatAbk : public Aktion
{
public:
    // umlenkung
    BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanUmlenkungIstDrehend : public Aktion
{
public:
    // umlenkung
    BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereBewegtSich : public Aktion
{
public:
    // bariere
    BooleanBariereBewegtSich( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereIstSchaltend : public Aktion
{
public:
    // bariere
    BooleanBariereIstSchaltend( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBariereIstAktiv : public Aktion
{
public:
    // bariere
    BooleanBariereIstAktiv( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanSchalterIstAktiv : public Aktion
{
public:
    // schalter
    BooleanSchalterIstAktiv( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTunnelIstAktiv : public Aktion
{
public:
    // tunnel
    BooleanTunnelIstAktiv( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanBaseIstNeutral : public Aktion
{
public:
    // base
    BooleanBaseIstNeutral( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTimerIsRunning : public Aktion
{
public:
    BooleanTimerIsRunning( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTimerIstSichtbar : public Aktion
{
public:
    // timer
    BooleanTimerIstSichtbar( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanAusText : public Aktion
{
public:
    // text
    BooleanAusText( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanTriggerIstAktiv : public Aktion
{
public:
    // trigger
    BooleanTriggerIstAktiv( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BooleanRechnung : public Aktion
{
private:
    Operator op;

public:
    // v1, v2
    BooleanRechnung( RCArray< Aktion > *subActions, Operator op );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class Sequenz : public Aktion
{
public:
    Sequenz( RCArray< Aktion > *aktions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatRechnung : public Aktion
{
private:
    Operator op;

public:
    // left, right
    FloatRechnung( RCArray< Aktion > *subActions, Operator op );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatAusInteger : public Aktion
{
public:
    // integer
    FloatAusInteger( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatAusText : public Aktion
{
public:
    // text
    FloatAusText( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class TextAusFloat : public Aktion
{
public:
    // f
    TextAusFloat( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class FloatZufall : public Aktion
{
public:
    // min, max
    FloatZufall( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class IntegerAusFloat : public Aktion
{
public:
    // f
    IntegerAusFloat( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BestenlisteNeu : public Aktion
{
public:
    // f
    BestenlisteNeu( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BestenlisteAddZeile : public Aktion
{
public:
    // f
    BestenlisteAddZeile( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BestenlisteAddSpalte : public Aktion
{
public:
    // f
    BestenlisteAddSpalte( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BestenlisteSetWert : public Aktion
{
public:
    // f
    BestenlisteSetWert( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};

class BestenlisteGetWert : public Aktion
{
public:
    // f
    BestenlisteGetWert( RCArray< Aktion > *subActions );
    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
};