#include "Aktionen.h"
#include "Trigger.h"
#include "Spiel.h"
#include "Bestenliste.h"


#define zParam( x )    zEvaluatedParam( x, zMemory, zPC )
#define getParam( x )  getEvaluatedParam( x, zMemory, zPC )
#define setReturn( x ) zMemory->setVar( "__return__", x )
#define zReturn        zMemory->zVariable( "__return__" )
#define getReturn      zMemory->getVariable( "__return__" )


Aktion::Aktion( AktionTyp typ, RCArray< Aktion > *subActions )
    : Variable( AKTION )
{
    this->subActions = subActions;
    for( int i = 0; i < subActions->getEintragAnzahl(); i++ )
        erlaubteTypen.add( ALLE );
    this->typ = typ;
}

Aktion::~Aktion()
{
    subActions->release();
}

Variable *Aktion::zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
{
    return zMemory->zVariable( zPC->getUniqueString() + "R" + number + "__" );
}

Variable *Aktion::getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
{
    return zMemory->getVariable( zPC->getUniqueString() + "R" + number + "__" );
}

bool Aktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( waitCount > 0 )
        return 0;
    zPC->stepIn();
    // evaluate parameters
    for( int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++ )
    {
        if( !subActions->z( i )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            zPC->stepOut();
            return 0;
        }
        Variable *result = zReturn;
        if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || ( result && result->getVariableTyp() != erlaubteTypen.get( i ) ) )
        {
            zPC->stepOut();
            return 1;
        }
        if( result )
            zMemory->setVar( zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable *>( result->getThis() ) );
        zPC->count();
        if( waitCount > 0 )
        {
            zPC->stepOut();
            return 0;
        }
    }
    if( zPC->currentPosition() == subActions->getEintragAnzahl() )
    {
        // evaluate result
        run( zSpiel, zEreignis, zMemory, zPC, waitCount );
        zPC->stepOut();
        return 1;
    }
    zPC->stepOut();
    return 0;
}

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

void Aktion::writeOptions( Datei &dat )
{}

AktionTyp Aktion::getTyp() const
{
    return typ;
}

RCArray< Aktion > *Aktion::zSubActions() const
{
    return subActions;
}


KonstantNichts::KonstantNichts()
    : Aktion( KONSTANT_NICHTS, new RCArray< Aktion >() )
{}

void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Variable( NICHTS ) );
}


KonstantInteger::KonstantInteger( int val )
    : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
{
    this->value = val;
}

void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( value ) );
}

void KonstantInteger::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&value, 4 );
}


KonstantGegenstandTyp::KonstantGegenstandTyp( GegenstandTyp val )
    : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
{
    this->value = val;
}

void KonstantGegenstandTyp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( value ) );
}

void KonstantGegenstandTyp::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&value, 4 );
}


KonstantTaste::KonstantTaste( unsigned char val )
    : Aktion( KONSTANT_TASTE, new RCArray< Aktion >() )
{
    this->value = val;
}

void KonstantTaste::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( (int)value, 1 ) );
}

void KonstantTaste::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&value, 1 );
}


KonstantBoolean::KonstantBoolean( bool val )
    : Aktion( KONSTANT_BOOLEAN, new RCArray< Aktion >() )
{
    value = val;
}

void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( value ) );
}

void KonstantBoolean::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&value, 1 );
}


KonstantString::KonstantString( Text val )
    : Aktion( KONSTANT_STRING, new RCArray< Aktion >() )
{
    value = val;
}

void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( value ) );
}

void KonstantString::writeOptions( Datei &dat )
{
    char len = (char)value.getLength();
    dat.schreibe( (char *)&len, 1 );
    dat.schreibe( value, len );
}


KonstantFloat::KonstantFloat( float val )
    : Aktion( KONSTANT_FLOAT, new RCArray< Aktion >() )
{
    value = val;
}

void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( value ) );
}

void KonstantFloat::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&value, 4 );
}


KonstantVariable::KonstantVariable( Text name )
    : Aktion( KONSTANT_VARIABLE, new RCArray< Aktion >() )
{
    this->name = name;
}

void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( zMemory->zVariable( name ) )
        setReturn( zMemory->getVariable( name ) );
    else if( zEreignis->zParameter( name ) )
        setReturn( zEreignis->getParameter( name ) );
    else if( zSpiel->zVariable( name ) )
        setReturn( zSpiel->getVariable( name ) );
    else
        setReturn( new Variable( NICHTS ) );
}

void KonstantVariable::writeOptions( Datei &dat )
{
    char len = (char)name.getLength();
    dat.schreibe( (char *)&len, 1 );
    dat.schreibe( name, len );
}


Warten::Warten( RCArray< Aktion > *subActions )
    : Aktion( WARTEN, subActions )
{
    this->erlaubteTypen.add( FLOAT );
}

void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    waitCount += ( (Float *)zParam( 0 ) )->getValue();
}


WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions )
    : Aktion( WENN_DANN_SONST, subActions )
{}

bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        bool finished = subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
        if( finished )
        {
            Variable *ret = zReturn;
            zPC->count();
            if( !isTrue( ret ) )
            {
                zPC->count();
                if( !subActions->z( 2 ) )
                {
                    zPC->stepOut();
                    return 1;
                }
            }
            else
            {
                if( !subActions->z( 1 ) )
                {
                    zPC->stepOut();
                    return 1;
                }
            }
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        bool finished = subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
        if( finished )
        {
            zPC->stepOut();
            return 1;
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        bool finished = subActions->z( 2 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
        if( finished )
        {
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SetVariable::SetVariable( Text name, RCArray< Aktion > *subActions )
    : Aktion( SET_VARIABLE, subActions )
{
    this->name = name;
}

void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
        zMemory->setVar( name, getParam( 0 ) );
    else
        zSpiel->setVariable( name, getParam( 0 ) );
}

void SetVariable::writeOptions( Datei &dat )
{
    char len = (char)name.getLength();
    dat.schreibe( (char *)&len, 1 );
    dat.schreibe( name, len );
}


TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
    : Aktion( TRIGGER_AKTION, subActions )
{}

bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zReturn;
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", dynamic_cast<Variable *>( t->getThis() ) );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zReturn;
            if( !t || t->getVariableTyp() != TRIGGER )
            {
                zPC->stepOut();
                return 1;
            }
            int id = ( (Integer *)zParam( 0 ) )->getValue();
            if( id >= ( (Trigger *)t )->getAktionAnzahl() )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", ( (Trigger *)t )->getAktion( id ) );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( ( (Aktion *)zParam( 0 ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_NACHRICHT, subActions )
{
    erlaubteTypen.add( SPIELER );
    erlaubteTypen.add( STRING );
}

void SpielerNachricht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    // this is handeld on client side directly (no need to send the message to the player)
}


DisplayText::DisplayText( RCArray< Aktion > *subActions )
    : Aktion( DISPLAY_TEXT, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( STRING );
}

void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    // do nothing because the server does not need to show text
}


SpielPause::SpielPause( RCArray< Aktion > *subActions )
    : Aktion( SPIEL_PAUSE, subActions )
{
    erlaubteTypen.add( BOOLEAN );
}

void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zSpiel->setPausiert( ( (Boolean *)zParam( 0 ) )->getValue() );
}


SpielEnde::SpielEnde( RCArray< Aktion > *subActions )
    : Aktion( SPIEL_ENDE, subActions )
{}

void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Variable *t = zParam( 0 );
    if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM )
        t = 0;
    zSpiel->setEnde( ( !t || t->getVariableTyp() == NICHTS ) ? 0 : (Team *)t );
}


SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_LEVEL, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue(), zSpiel );
}


SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_GIVE_ITEM, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 2 ) )->addItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
                                         ( (Integer *)zParam( 1 ) )->getValue(), zSpiel );
}


SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_REMOVE_ITEM, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 2 ) )->removeItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
                                            ( (Integer *)zParam( 1 ) )->getValue() );
}


SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_LEBEN, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setLeben( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_LEBEN, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setMaxLeben( ( (Integer *)zParam( 0 ) )->getValue() );
}


SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_ERFAHRUNG, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue(), zSpiel );
}


SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_MAX_ERFAHRUNG, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setMaxErfahrung( ( (Integer *)zParam( 0 ) )->getValue() );
}


SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_TEMPO, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setLaufTempo( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_GESCHOSS_TEMPO, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setGeschossTempo( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_ARMOR, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setArmor( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_SCHADEN_BONUS, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setSchadenBonus( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setLebensRaub( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setLebensRegeneration( ( (Float *)zParam( 0 ) )->getValue() );
}


SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( SPIELER );
}

void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Spieler *)zParam( 1 ) )->setAbklingZeitVerringerung( ( (Float *)zParam( 0 ) )->getValue() );
}


DropSetTime::DropSetTime( RCArray< Aktion > *subActions )
    : Aktion( DROP_SET_TIME, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( DROP );
}

void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Drop *)zParam( 1 ) )->setTime( ( (Float *)zParam( 0 ) )->getValue() );
}


DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions )
    : Aktion( DROP_SET_MAX_TIME, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( DROP );
}

void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Drop *)zParam( 1 ) )->setMaxTime( ( (Integer *)zParam( 0 ) )->getValue() );
}


DropSetArea::DropSetArea( RCArray< Aktion > *subActions )
    : Aktion( DROP_SET_AREA, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( DROP );
}

void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Drop *)zParam( 4 ) )->setMinX( ( (Integer *)zParam( 0 ) )->getValue() );
    ( (Drop *)zParam( 4 ) )->setMaxX( ( (Integer *)zParam( 1 ) )->getValue() );
    ( (Drop *)zParam( 4 ) )->setMinY( ( (Integer *)zParam( 2 ) )->getValue() );
    ( (Drop *)zParam( 4 ) )->setMaxY( ( (Integer *)zParam( 3 ) )->getValue() );
}


DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions )
    : Aktion( DROP_DO_DROP, subActions )
{
    erlaubteTypen.add( DROP );
}

void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Drop *)zParam( 0 ) )->doDrop( zSpiel );
}


BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions )
    : Aktion( BARIERE_BEWEGUNG, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bariere *)zParam( 0 ) )->startAutoVerschiebung( zSpiel );
}


BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions )
    : Aktion( BARIERE_SET_EINGESCHALTET, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( DROP );
}

void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bariere *)zParam( 1 ) )->setStyle( Bariere::Style::Aktiv, ( (Boolean *)zParam( 0 ) )->getValue(), zSpiel );
}


GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions )
    : Aktion( GAME_OBJEKT_SET_POSITION, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( GAME_OBJEKT );
}

void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (GameObject *)zParam( 2 ) )->setX( ( (Float *)zParam( 0 ) )->getValue() );
    ( (GameObject *)zParam( 2 ) )->setY( ( (Float *)zParam( 1 ) )->getValue() );
}


GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions )
    : Aktion( GAME_OBJEKT_SET_SIZE, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( GAME_OBJEKT );
}

void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (GameObject *)zParam( 2 ) )->setWidth( ( (Float *)zParam( 0 ) )->getValue() );
    ( (GameObject *)zParam( 2 ) )->setHeight( ( (Float *)zParam( 1 ) )->getValue() );
}


BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions )
    : Aktion( BARIERE_SET_TEAM, subActions )
{
    erlaubteTypen.add( TEAM );
    erlaubteTypen.add( BARIERE );
}

void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bariere *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ) );
}


SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions )
    : Aktion( SCHALTER_SET_ERLAUBT, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( SCHALTER );
}

void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Schalter *)zParam( 1 ) )->setAktive( ( (Boolean *)zParam( 0 ) )->getValue() );
}


SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions )
    : Aktion( SCHALTER_AKTIVIEREN, subActions )
{
    erlaubteTypen.add( SCHALTER );
}

void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zSpiel->activateShalter( ( (Schalter *)zParam( 0 ) )->getId() );
}


TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions )
    : Aktion( TUNNEL_SET_ZIEL_POSITION, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( TUNNEL );
}

void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Tunnel *)zParam( 2 ) )->setZielX( ( (Integer *)zParam( 0 ) )->getValue() );
    ( (Tunnel *)zParam( 2 ) )->setZielY( ( (Integer *)zParam( 1 ) )->getValue() );
}


TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions )
    : Aktion( TUNNEL_SET_ERLAUBT, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( TUNNEL );
}

void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Tunnel *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
}


UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions )
    : Aktion( UMLENKUNG_SET_RICHTUNG, subActions )
{
    erlaubteTypen.add( RICHTUNG );
    erlaubteTypen.add( UMLENKUNG );
}

void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Umlenkung *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
}


UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions )
    : Aktion( UMLENKUNG_SET_MAX_ABK, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( UMLENKUNG );
}

void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Umlenkung *)zParam( 1 ) )->setMaxAbklingzeit( ( (Integer *)zParam( 0 ) )->getValue() );
}


UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions )
    : Aktion( UMLENKUNG_SET_ERLAUBT, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( UMLENKUNG );
}

void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Umlenkung *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
}


BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
    : Aktion( BASE_SET_TEAM, subActions )
{
    erlaubteTypen.add( TEAM );
    erlaubteTypen.add( BASE );
}

void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ), zSpiel );
}


BaseStartTeamChange::BaseStartTeamChange( RCArray< Aktion > *subActions )
    : Aktion( BASE_START_TEAM_CHANGE, subActions )
{
    erlaubteTypen.add( TEAM );
    erlaubteTypen.add( BASE );
}

void BaseStartTeamChange::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Base *)zParam( 1 ) )->startChange( ( (Team *)getParam( 0 ) ) );
}


TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
    : Aktion( TRIGGER_RUN_START, subActions )
{
    erlaubteTypen.add( TRIGGER );
}

void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zSpiel->addTriggerRun( ( (Trigger *)zParam( 0 ) )->runTrigger( dynamic_cast<Ereignis *>( zEreignis->getThis() ), zSpiel ) );
}


TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions )
    : Aktion( TRIGGER_SET_ENABLED, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( TRIGGER );
}

void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Trigger *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
}


TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions )
    : Aktion( TEAM_SET_PUNKTE, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( TEAM );
}

void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Team *)zParam( 1 ) )->setPunkte( ( (Integer *)zParam( 0 ) )->getValue() );
}


TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
    : Aktion( TIMER_SET_PAUSE, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( TIMER );
}

void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Timer *)zParam( 1 ) )->setPause( zSpiel, ( (Boolean *)zParam( 0 ) )->getValue() );
}


TimerStart::TimerStart( RCArray< Aktion > *subActions )
    : Aktion( TIMER_START, subActions )
{
    erlaubteTypen.add( TIMER );
}

void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Timer *)zParam( 0 ) )->start( zSpiel );
}


TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions )
    : Aktion( TIMER_SET_ZEIT, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( TIMER );
}

void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Timer *)zParam( 1 ) )->setZeit( ( (Float *)zParam( 0 ) )->getValue() );
}


TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions )
    : Aktion( TIMER_SET_SICHTBAR, subActions )
{
    erlaubteTypen.add( BOOLEAN );
    erlaubteTypen.add( TIMER );
}

void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Timer *)zParam( 1 ) )->setSichtbar( ( (Boolean *)zParam( 0 ) )->getValue() );
}


GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions )
    : Aktion( GESCHOSS_NEU, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( GESCHOSS_TYP );
    erlaubteTypen.add( RICHTUNG );
}

void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
                                getGeschossTypFromString( ( (String *)zParam( 2 ) )->getValue() ),
                                getRichtungFromString( ( (String *)zParam( 3 ) )->getValue() ),
                                ( (Integer *)zParam( 0 ) )->getValue(),
                                ( (Integer *)zParam( 1 ) )->getValue(), 0 );
    zSpiel->addGeschoss( dynamic_cast<Geschoss *>( g->getThis() ) );
    setReturn( g );
}


GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions )
    : Aktion( GESCHOSS_SET_SPEED, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( GESCHOSS );
}

void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Geschoss *)zParam( 1 ) )->setSpeed( ( (Float *)zParam( 0 ) )->getValue() );
}


GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions )
    : Aktion( GESCHOSS_SET_PLAYER, subActions )
{
    erlaubteTypen.add( SPIELER );
    erlaubteTypen.add( GESCHOSS );
}

void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Geschoss *)zParam( 1 ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
}


GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions )
    : Aktion( GESCHOSS_SET_RICHTUNG, subActions )
{
    erlaubteTypen.add( RICHTUNG );
    erlaubteTypen.add( GESCHOSS );
}

void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Geschoss *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
}


GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions )
    : Aktion( GESCHOSS_SET_TYPE, subActions )
{
    erlaubteTypen.add( GESCHOSS_TYP );
    erlaubteTypen.add( GESCHOSS );
}

void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Geschoss *)zParam( 1 ) )->setTyp( getGeschossTypFromString( ( (String *)zParam( 0 ) )->getValue() ) );
}


TriggerZufall::TriggerZufall()
    : Aktion( TRIGGER_ZUFALL, new RCArray< Aktion >() )
{}

void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomTrigger() );
}


TriggerLastRunned::TriggerLastRunned()
    : Aktion( TRIGGER_LAST_RUNNED, new RCArray< Aktion >() )
{}

void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getLastRunnedTrigger() );
}


BariereZufall::BariereZufall()
    : Aktion( BARIERE_ZUFALL, new RCArray< Aktion >() )
{}

void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomBariere() );
}


BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
    : Aktion( BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >() )
{}

void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getZuletztEingeschalteteBariere() );
}


BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >() )
{}

void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getZuletztAusgeschalteteBariere() );
}


BariereZuletztBewegt::BariereZuletztBewegt()
    : Aktion( BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >() )
{}

void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getZuletztBewegteBariere() );
}


BaseZufall::BaseZufall()
    : Aktion( BASE_ZUFALL, new RCArray< Aktion >() )
{}

void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomBase() );
}


BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >() )
{}

void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getLastTeamChangedBase() );
}


DropZufall::DropZufall()
    : Aktion( DROP_ZUFALL, new RCArray< Aktion >() )
{}

void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomDrop() );
}


DropZuletztGedropt::DropZuletztGedropt()
    : Aktion( DROP_ZULETZT_GEDROPT, new RCArray< Aktion >() )
{}

void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getLastDrop() );
}


IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op )
    : Aktion( INTEGER_RECHNEN, subActions ),
    op()
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
}

void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Integer *l = (Integer *)zParam( 0 );
    Integer *r = (Integer *)zParam( 1 );
    switch( op )
    {
    case PLUS:
        setReturn( new Integer( l->getValue() + r->getValue() ) );
        break;
    case MINUS:
        setReturn( new Integer( l->getValue() - r->getValue() ) );
        break;
    case MAHL:
        setReturn( new Integer( l->getValue() * r->getValue() ) );
        break;
    case GETEILT:
        setReturn( new Integer( l->getValue() / r->getValue() ) );
        break;
    case HOCH:
        setReturn( new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
        break;
    case WURZEL:
        setReturn( new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
        break;
    case BIT_ODER:
        setReturn( new Integer( l->getValue() | r->getValue() ) );
        break;
    case BIT_UND:
        setReturn( new Integer( l->getValue() & r->getValue() ) );
        break;
    case BIT_XOR:
        setReturn( new Integer( l->getValue() ^ r->getValue() ) );
        break;
    case BIT_FLIP:
        setReturn( new Integer( ~l->getValue() ) );
        break;
    case BIT_SHIFT_LEFT:
        setReturn( new Integer( l->getValue() << r->getValue() ) );
        break;
    case BIT_SHIFT_RIGHT:
        setReturn( new Integer( l->getValue() >> r->getValue() ) );
        break;
    case INVERT_SIGN:
        setReturn( new Integer( -l->getValue() ) );
        break;
    case PLUS_PLUS_LEFT:
        l->setValue( l->getValue() + 1 );
        setReturn( new Integer( l->getValue() ) );
        break;
    case PLUS_PLUS_RIGHT:
    {
        int tmp = l->getValue();
        l->setValue( l->getValue() + 1 );
        setReturn( new Integer( tmp ) );
        break;
    }
    case MINUS_MINUS_LEFT:
        l->setValue( l->getValue() - 1 );
        setReturn( new Integer( l->getValue() ) );
        break;
    case MINUS_MINUS_RIGHT:
    {
        int tmp = l->getValue();
        l->setValue( l->getValue() - 1 );
        setReturn( new Integer( tmp ) );
        break;
    }
    case LOGARITHM:
        setReturn( new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
        break;
    case MODULO:
        setReturn( new Integer( l->getValue() % r->getValue() ) );
        break;
    default:
        break;
    }
}

void IntegerRechnen::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&this->op, 1 );
}


IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_ZUFALL, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
}

void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    int mi = ( (Integer *)zParam( 0 ) )->getValue();
    int ma = ( (Integer *)zParam( 1 ) )->getValue();
    setReturn( new Integer( (int)( zSpiel->getRand() * ( (double)ma - mi ) + mi ) ) );
}


IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_AUS_TEXT, subActions )
{
    erlaubteTypen.add( STRING );
}

void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (String *)zParam( 0 ) )->getValue() ) );
}


FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_X_VON_GAME_OBJEKT, subActions )
{
    erlaubteTypen.add( GAME_OBJEKT );
}

void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getX() ) );
}


FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_Y_VON_GAME_OBJEKT, subActions )
{
    erlaubteTypen.add( GAME_OBJEKT );
}

void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getY() ) );
}


IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_X_VON_TUNNEL_ZIEL, subActions )
{
    erlaubteTypen.add( TUNNEL );
}

void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielX() ) );
}


IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL, subActions )
{
    erlaubteTypen.add( TUNNEL );
}

void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielY() ) );
}


IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_MIN_X_VON_DROP, subActions )
{
    erlaubteTypen.add( DROP );
}

void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinX() ) );
}


IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_MIN_Y_VON_DROP, subActions )
{
    erlaubteTypen.add( DROP );
}

void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinY() ) );
}


IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_MAX_X_VON_DROP, subActions )
{
    erlaubteTypen.add( DROP );
}

void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxX() ) );
}


IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_MAX_Y_VON_DROP, subActions )
{
    erlaubteTypen.add( DROP );
}

void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxY() ) );
}


IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_SPIELER_LEVEL, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getLevel() ) );
}


FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_SPIELER_LEBEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLeben() ) );
}

bool isBinary( Operator op )
{
    return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
        op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
}


IntegerSpielerMaxLeben::IntegerSpielerMaxLeben( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_MAX_LEBEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxLeben() ) );
}


FloatSpielerErfahrung::FloatSpielerErfahrung( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_ERFAHRUNG, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErfahrung() ) );
}


IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_MAX_ERFAHRUNG, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxErfahrung() ) );
}


FloatSpielerTempo::FloatSpielerTempo( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_TEMPO, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLaufTempo() ) );
}


FloatSpielerGeschossTempo::FloatSpielerGeschossTempo( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_GESCHOSS_TEMPO, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerGeschossTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeschossTempo() ) );
}


FloatSpielerArmor::FloatSpielerArmor( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_ARMOR, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getArmor() ) );
}


FloatSpielerSchadenBonus::FloatSpielerSchadenBonus( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_SCHADEN_BONUS, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getSchadenBonus() ) );
}


FloatSpielerLebensraub::FloatSpielerLebensraub( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_LEBENSRAUB, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRaub() ) );
}


FloatSpielerLebensregeneration::FloatSpielerLebensregeneration( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_LEBENSREGENERATION, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRegenneration() ) );
}


FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerAbklingzeitVerringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getAbklingZeitVerringerung() ) );
}


IntegerSpielerTode::IntegerSpielerTode( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_TODE, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTode() ) );
}


IntegerSpielerKills::IntegerSpielerKills( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_KILLS, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getKills() ) );
}


IntegerSpielerTreffer::IntegerSpielerTreffer( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerTreffer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTreffer() ) );
}


IntegerSpielerGetroffen::IntegerSpielerGetroffen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGetroffen() ) );
}


FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerErlittenerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErlittenerSchaden() ) );
}


FloatSpielerSchaden::FloatSpielerSchaden( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGemachterSchaden() ) );
}


FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_SPIELER_GEHEILTES_LEBEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void FloatSpielerGeheiltesLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeheiltesLeben() ) );
}


IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerItemsAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsAufgehoben() ) );
}


IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_ITEMS_VERWENDET, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerItemsVerwendet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsVerwendet() ) );
}


IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerItemsInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsInInventory() ) );
}


IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerItemsTypeInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
}


IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_TUNNEL_BENUTZT, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTunnelBenutzt() ) );
}


IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getSchalterAktiviert() ) );
}


IntegerSpielerGeschossen::IntegerSpielerGeschossen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SPIELER_GESCHOSSEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void IntegerSpielerGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGeschossen() ) );
}


FloatDropZeit::FloatDropZeit( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_DROP_ZEIT, subActions )
{
    erlaubteTypen.add( DROP );
}

void FloatDropZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Drop *)zParam( 0 ) )->getZeit() ) );
}


IntegerDropMaxZeit::IntegerDropMaxZeit( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_DROP_MAX_ZEIT, subActions )
{
    erlaubteTypen.add( DROP );
}

void IntegerDropMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxTime() ) );
}


FloatGameObjektBreite::FloatGameObjektBreite( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_GAME_OBJEKT_BREITE, subActions )
{
    erlaubteTypen.add( GAME_OBJEKT );
}

void FloatGameObjektBreite::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getWidth() ) );
}


FloatGameObjektHeight::FloatGameObjektHeight( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_GAME_OBJEKT_HEIGHT, subActions )
{
    erlaubteTypen.add( GAME_OBJEKT );
}

void FloatGameObjektHeight::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getHeight() ) );
}


IntegerBariereVerschiebungen::IntegerBariereVerschiebungen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_BARIERE_VERSCHIEBUNGEN, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void IntegerBariereVerschiebungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getVerschiebungAnzahl() ) );
}


IntegerBariereSchaltungen::IntegerBariereSchaltungen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_BARIERE_SCHALTUNGEN, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void IntegerBariereSchaltungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getSchaltungAnzahl() ) );
}


IntegerSchalterAktivierungen::IntegerSchalterAktivierungen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_SCHALTER_AKTIVIERUNGEN, subActions )
{
    erlaubteTypen.add( SCHALTER );
}

void IntegerSchalterAktivierungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Schalter *)zParam( 0 ) )->getAnzahlAktivierungen() ) );
}


IntegerTunnelBenutzungen::IntegerTunnelBenutzungen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TUNNEL_BENUTZUNGEN, subActions )
{
    erlaubteTypen.add( TUNNEL );
}

void IntegerTunnelBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getBenutzungen() ) );
}


IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_UMLENKUNG_BENUTZUNGEN, subActions )
{
    erlaubteTypen.add( UMLENKUNG );
}

void IntegerUmlenkungBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Umlenkung *)zParam( 0 ) )->getBenutzungen() ) );
}


IntegerTeamPunkte::IntegerTeamPunkte( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TEAM_PUNKTE, subActions )
{
    erlaubteTypen.add( TEAM );
}

void IntegerTeamPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getPunkte() ) );
}


IntegerTeamKills::IntegerTeamKills( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TEAM_KILLS, subActions )
{
    erlaubteTypen.add( TEAM );
}

void IntegerTeamKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getKills() ) );
}


IntegerTeamTode::IntegerTeamTode( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TEAM_TODE, subActions )
{
    erlaubteTypen.add( TEAM );
}

void IntegerTeamTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getTode() ) );
}


FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions )
{
    erlaubteTypen.add( TEAM );
}

void FloatTeamWiederbelegungszeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Team *)zParam( 0 ) )->getMaxWiederbelebungsZeit() ) );
}


IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TEAM_SPIELERANZAHL, subActions )
{
    erlaubteTypen.add( TEAM );
}

void IntegerTeamSpieleranzahl::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getSpielerAnzahl() ) );
}


FloatTimerAktuelleZeit::FloatTimerAktuelleZeit( RCArray<Aktion> *subActions )
    : Aktion( FLOAT_TIMER_AKTUELLE_ZEIT, subActions )
{
    erlaubteTypen.add( TIMER );
}

void FloatTimerAktuelleZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( ( (Timer *)zParam( 0 ) )->getTimeLeft() ) );
}


IntegerTimerMaxZeit::IntegerTimerMaxZeit( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TIMER_MAX_ZEIT, subActions )
{
    erlaubteTypen.add( TIMER );
}

void IntegerTimerMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Timer *)zParam( 0 ) )->getMaxTime() ) );
}


IntegerTriggerRunns::IntegerTriggerRunns( RCArray<Aktion> *subActions )
    : Aktion( INTEGER_TRIGGER_RUNNS, subActions )
{
    erlaubteTypen.add( TRIGGER );
}

void IntegerTriggerRunns::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( ( (Trigger *)zParam( 0 ) )->getRuns() ) );
}


ItemSpielerInventar::ItemSpielerInventar( RCArray<Aktion> *subActions )
    : Aktion( ITEM_SPIELER_INVENTAR, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( SPIELER );
}

void ItemSpielerInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( ( ( (Spieler *)zParam( 1 ) )->getInventorySlot( ( (Integer *)zParam( 0 ) )->getValue() ) ) ) );
}


ItemZuletztAufgehoben::ItemZuletztAufgehoben()
    : Aktion( ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >() )
{}

void ItemZuletztAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAufgehoben() ) );
}


ItemZuletztAktiviert::ItemZuletztAktiviert()
    : Aktion( ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
{}

void ItemZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAktiviert() ) );
}


ItemZuletztGedropt::ItemZuletztGedropt()
    : Aktion( ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >() )
{}

void ItemZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztGedropt() ) );
}


ItemZufall::ItemZufall()
    : Aktion( ITEM_ZUFALL, new RCArray< Aktion >() )
{}

void ItemZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new GegenstandTypVar( (GegenstandTyp)(int)( zSpiel->getRand() * ITEMANZAHL ) ) );
}


GeschossZufall::GeschossZufall()
    : Aktion( GESCHOSS_ZUFALL, new RCArray< Aktion >() )
{}

void GeschossZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomGeschoss() );
}


GeschossZuletztAbgefeuert::GeschossZuletztAbgefeuert()
    : Aktion( GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >() )
{}

void GeschossZuletztAbgefeuert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getGeschossZuletztAbgefeuert() );
}


GeschossZuletztUmgelenkt::GeschossZuletztUmgelenkt()
    : Aktion( GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >() )
{}

void GeschossZuletztUmgelenkt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getGeschossZuletztUmgelenkt() );
}


GeschossZuletztBarjereGetroffen::GeschossZuletztBarjereGetroffen()
    : Aktion( GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >() )
{}

void GeschossZuletztBarjereGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getGeschossZuletztBariereGetroffen() );
}


GeschossZuletztTunnelBenutzt::GeschossZuletztTunnelBenutzt()
    : Aktion( GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
{}

void GeschossZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getGeschossZuletztTunnelBenutzt() );
}


GeschossZuletztGeschossGetroffen::GeschossZuletztGeschossGetroffen()
    : Aktion( GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >() )
{}

void GeschossZuletztGeschossGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getGeschossZuletztGeschossGetroffen() );
}


RichtungZufall::RichtungZufall()
    : Aktion( RICHTUNG_ZUFALL, new RCArray< Aktion >() )
{}

void RichtungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( (Richtung)(int)( zSpiel->getRand() * RICHTUNG_ANZAHL ) ) );
}


RichtungVonUmlenkung::RichtungVonUmlenkung( RCArray< Aktion > *subActions )
    : Aktion( RICHTUNG_VON_UMLENKUNG, subActions )
{
    erlaubteTypen.add( UMLENKUNG );
}

void RichtungVonUmlenkung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Umlenkung *)zParam( 0 ) )->getRichtung() ) );
}


RichtungVonGeschoss::RichtungVonGeschoss( RCArray< Aktion > *subActions )
    : Aktion( RICHTUNG_VON_GESCHOSS, subActions )
{
    erlaubteTypen.add( GESCHOSS );
}

void RichtungVonGeschoss::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Geschoss *)zParam( 0 ) )->getRichtung() ) );
}


SchalterZufall::SchalterZufall()
    : Aktion( SCHALTER_ZUFALL, new RCArray< Aktion >() )
{}

void SchalterZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomSchalter() );
}


SchalterZuletztAktiviert::SchalterZuletztAktiviert()
    : Aktion( SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
{}

void SchalterZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSchalterZuletztAktiviert() );
}


SpielerZufall::SpielerZufall()
    : Aktion( SPIELER_ZUFALL, new RCArray< Aktion >() )
{}

void SpielerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomSpieler() );
}


SpielerZufallAusTeam::SpielerZufallAusTeam( RCArray< Aktion > *subActions )
    : Aktion( SPIELER_ZUFALL_AUS_TEAM, subActions )
{
    erlaubteTypen.add( TEAM );
}

void SpielerZufallAusTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomSpieler( (Team *)zParam( 0 ) ) );
}


SpielerZuletztSchadenGemacht::SpielerZuletztSchadenGemacht()
    : Aktion( SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >() )
{}

void SpielerZuletztSchadenGemacht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztSchadenGemacht() );
}


SpielerZuletztSchadenGenommen::SpielerZuletztSchadenGenommen()
    : Aktion( SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >() )
{}

void SpielerZuletztSchadenGenommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztSchadenGenommen() );
}


SpielerZuletztGeheilt::SpielerZuletztGeheilt()
    : Aktion( SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >() )
{}

void SpielerZuletztGeheilt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztGeheilt() );
}


SpielerZuletztLevelUp::SpielerZuletztLevelUp()
    : Aktion( SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >() )
{}

void SpielerZuletztLevelUp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztLevelUp() );
}


SpielerZuletztErfahrungBekommen::SpielerZuletztErfahrungBekommen()
    : Aktion( SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >() )
{}

void SpielerZuletztErfahrungBekommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztErfahrungBekommen() );
}


SpielerZuletztGegenstandAktiviert::SpielerZuletztGegenstandAktiviert()
    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >() )
{}

void SpielerZuletztGegenstandAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztGegenstandAktiviert() );
}


SpielerZuletztGegenstandAufgehoben::SpielerZuletztGegenstandAufgehoben()
    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >() )
{}

void SpielerZuletztGegenstandAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztGegenstandAufgehoben() );
}


SpielerZuletztSchalterAktiviert::SpielerZuletztSchalterAktiviert()
    : Aktion( SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >() )
{}

void SpielerZuletztSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztSchalterAktiviert() );
}


SpielerZuletztTunnelBenutzt::SpielerZuletztTunnelBenutzt()
    : Aktion( SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
{}

void SpielerZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztTunnelBenutzt() );
}


SpielerZuletztGestorben::SpielerZuletztGestorben()
    : Aktion( SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >() )
{}

void SpielerZuletztGestorben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztGestorben() );
}


SpielerZuletztWiederbelebent::SpielerZuletztWiederbelebent()
    : Aktion( SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >() )
{}

void SpielerZuletztWiederbelebent::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztWiederbelebt() );
}


SpielerZuletztGeschossGeschossen::SpielerZuletztGeschossGeschossen()
    : Aktion( SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >() )
{}

void SpielerZuletztGeschossGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getSpielerZuletztGeschossen() );
}


TextConcat::TextConcat( RCArray< Aktion > *subActions )
    : Aktion( TEXT_CONCAT, subActions )
{
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( STRING );
}

void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    String *p1 = (String *)zParam( 0 );
    String *p2 = (String *)zParam( 1 );
    String *res = new String( p1->getValue().operator+( p2->getValue().getText() ) );
    setReturn( res );
}


TextAusInteger::TextAusInteger( RCArray< Aktion > *subActions )
    : Aktion( TEXT_AUS_INTEGER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void TextAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( Text( ( (Integer *)zParam( 0 ) )->getValue() ) ) );
}


TextAusRichtung::TextAusRichtung( RCArray< Aktion > *subActions )
    : Aktion( TEXT_AUS_RICHTUNG, subActions )
{
    erlaubteTypen.add( RICHTUNG );
}

void TextAusRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (String *)zParam( 0 ) )->getValue() ) );
}


TextAusBoolean::TextAusBoolean( RCArray< Aktion > *subActions )
    : Aktion( TEXT_AUS_BOOLEAN, subActions )
{
    erlaubteTypen.add( BOOLEAN );
}

void TextAusBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Boolean *)zParam( 0 ) )->getValue() ? "true" : "false" ) );
}


TextSpielerName::TextSpielerName( RCArray< Aktion > *subActions )
    : Aktion( TEXT_SPIELER_NAME, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void TextSpielerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Spieler *)zParam( 0 ) )->getName() ) );
}


TextItemName::TextItemName( RCArray< Aktion > *subActions )
    : Aktion( TEXT_ITEM_NAME, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
}

void TextItemName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    switch( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() )
    {
    case PFEIL:
        setReturn( new String( "PFEIL" ) );
        break;
    case LEBEN:
        setReturn( new String( "LEBEN" ) );
        break;
    case SCHILD:
        setReturn( new String( "SCHILD" ) );
        break;
    case SCHUH:
        setReturn( new String( "SCHUH" ) );
        break;
    case GEIST:
        setReturn( new String( "GEIST" ) );
        break;
    case KUGEL:
        setReturn( new String( "KUGEL" ) );
        break;
    case ROLLE:
        setReturn( new String( "ROLLE" ) );
        break;
    case STURM:
        setReturn( new String( "STURM" ) );
        break;
    case DRACHENAUGE:
        setReturn( new String( "DRACHENAUGE" ) );
        break;
    case FEUERBALL:
        setReturn( new String( "FEUERBALL" ) );
        break;
    case ENTERHAKEN:
        setReturn( new String( "ENTERHAKEN" ) );
        break;
    case MINE:
        setReturn( new String( "MINE" ) );
        break;
    case RWEISHEIT:
        setReturn( new String( "RWEISHEIT" ) );
        break;
    case RSTRENGTH:
        setReturn( new String( "RSTRENGTH" ) );
        break;
    case RBOSHEIT:
        setReturn( new String( "RBOSHEIT" ) );
        break;
    case RLEBEN:
        setReturn( new String( "RLEBEN" ) );
        break;
    case RTEMPO:
        setReturn( new String( "RTEMPO" ) );
        break;
    default:
        setReturn( new String( "NICHTS" ) );
        break;
    }
}


TextTriggerName::TextTriggerName( RCArray< Aktion > *subActions )
    : Aktion( TEXT_TRIGGER_NAME, subActions )
{
    erlaubteTypen.add( TRIGGER );
}

void TextTriggerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Trigger *)zParam( 0 ) )->getName() ) );
}


TextTeilVonText::TextTeilVonText( RCArray< Aktion > *subActions )
    : Aktion( TEXT_TEIL_VON_TEXT, subActions )
{
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( INTEGER );
    erlaubteTypen.add( STRING );
}

void TextTeilVonText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Text *txt = ( (String *)zParam( 2 ) )->getValue().getTeilText( ( (Integer *)zParam( 0 ) )->getValue(), ( (Integer *)zParam( 1 ) )->getValue() );
    setReturn( new String( txt->getText() ) );
    txt->release();
}


TeamZufall::TeamZufall()
    : Aktion( TEAM_ZUFALL, new RCArray< Aktion >() )
{}

void TeamZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomTeam() );
}


TeamVonSpieler::TeamVonSpieler( RCArray< Aktion > *subActions )
    : Aktion( TEAM_VON_SPIELER, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void TeamVonSpieler::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( ( (Spieler *)zParam( 0 ) )->getTeam() );
}


TeamVonBariere::TeamVonBariere( RCArray< Aktion > *subActions )
    : Aktion( TEAM_VON_BARIERE, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void TeamVonBariere::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( ( (Bariere *)zParam( 0 ) )->getTeam() );
}


TimerZufall::TimerZufall()
    : Aktion( TIMER_ZUFALL, new RCArray< Aktion >() )
{}

void TimerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomTimer() );
}


TimerZuletztAbgelaufen::TimerZuletztAbgelaufen()
    : Aktion( TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >() )
{}

void TimerZuletztAbgelaufen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTimerZuletztAbgelaufen() );
}


TimerZuletztGestartet::TimerZuletztGestartet()
    : Aktion( TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >() )
{}

void TimerZuletztGestartet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTimerZuletztGestartet() );
}


TimerZuletztPausiert::TimerZuletztPausiert()
    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
{}

void TimerZuletztPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTimerZuletztPausiert() );
}


TimerZuletztFortgesetzt::TimerZuletztFortgesetzt()
    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
{}

void TimerZuletztFortgesetzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTimerZuletztFortgesetzt() );
}


TunnelZufall::TunnelZufall()
    : Aktion( TUNNEL_ZUFALL, new RCArray< Aktion >() )
{}

void TunnelZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomTunnel() );
}


TunnelZuletztBenutzt::TunnelZuletztBenutzt()
    : Aktion( TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >() )
{}

void TunnelZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTunnelZuletztBenutzt() );
}


UmlenkungZufall::UmlenkungZufall()
    : Aktion( UMLENKUNG_ZUFALL, new RCArray< Aktion >() )
{}

void UmlenkungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRandomUmlenkung() );
}


UmlenkungZuletztBenutzt::UmlenkungZuletztBenutzt()
    : Aktion( UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >() )
{}

void UmlenkungZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getUmlenkungZuletztBenutzt() );
}


BooleanZufall::BooleanZufall()
    : Aktion( BOOLEAN_ZUFALL, new RCArray< Aktion >() )
{}

void BooleanZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getRand() < 0.5 ? new Boolean( false ) : new Boolean( true ) );
}


BooleanSpielPausiert::BooleanSpielPausiert()
    : Aktion( BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >() )
{}

void BooleanSpielPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( zSpiel->istPausiert() ) );
}


BooleanSpielerAmLeben::BooleanSpielerAmLeben( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_SPIELER_AM_LEBEN, subActions )
{
    erlaubteTypen.add( SPIELER );
}

void BooleanSpielerAmLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Spieler *)zParam( 0 ) )->istAmLeben() ) );
}


BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
    erlaubteTypen.add( SPIELER );
}

void BooleanSpielerHatGegenstand::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) != 0 ) );
}


BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions )
{
    erlaubteTypen.add( RICHTUNG );
    erlaubteTypen.add( SPIELER );
}

void BooleanSpielerIstVerwundbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->isVerwundbar( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) ) ) );
}


BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions )
{
    erlaubteTypen.add( GEGENSTAND_TYP );
    erlaubteTypen.add( SPIELER );
}

void BooleanSpielerKannItemBenutzen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->istGegenstandErlaubt( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
}


BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_UMLENKUNG_HAT_ABK, subActions )
{
    erlaubteTypen.add( UMLENKUNG );
}

void BooleanUmlenkungHatAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->hatAbklingzeit() ) );
}


BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_UMLENKUNG_IST_DREHEND, subActions )
{
    erlaubteTypen.add( UMLENKUNG );
}

void BooleanUmlenkungIstDrehend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->istDrehend() ) );
}


BooleanBariereBewegtSich::BooleanBariereBewegtSich( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_BARIERE_BEWEGT_SICH, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void BooleanBariereBewegtSich::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::InVerschiebung ) ) );
}


BooleanBariereIstSchaltend::BooleanBariereIstSchaltend( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_BARIERE_IST_SCHALTEND, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void BooleanBariereIstSchaltend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::AutoSchaltung ) ) );
}


BooleanBariereIstAktiv::BooleanBariereIstAktiv( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_BARIERE_IST_AKTIV, subActions )
{
    erlaubteTypen.add( BARIERE );
}

void BooleanBariereIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::Aktiv ) ) );
}


BooleanSchalterIstAktiv::BooleanSchalterIstAktiv( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_SCHALTER_IST_AKTIV, subActions )
{
    erlaubteTypen.add( SCHALTER );
}

void BooleanSchalterIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Schalter *)zParam( 0 ) )->isAktive() ) );
}


BooleanTunnelIstAktiv::BooleanTunnelIstAktiv( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_TUNNEL_IST_AKTIV, subActions )
{
    erlaubteTypen.add( TUNNEL );
}

void BooleanTunnelIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Tunnel *)zParam( 0 ) )->istAktiv() ) );
}


BooleanBaseIstNeutral::BooleanBaseIstNeutral( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_BASE_IST_NEUTRAL, subActions )
{
    erlaubteTypen.add( BASE );
}

void BooleanBaseIstNeutral::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Base *)zParam( 0 ) )->zTeam() == 0 ) );
}


BooleanTimerIsRunning::BooleanTimerIsRunning( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_TIMER_IS_RUNNING, subActions )
{
    erlaubteTypen.add( TIMER );
}

void BooleanTimerIsRunning::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->isRunning() ) );
}


BooleanTimerIstSichtbar::BooleanTimerIstSichtbar( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_TIMER_IST_SICHTBAR, subActions )
{
    erlaubteTypen.add( TIMER );
}

void BooleanTimerIstSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->istSichtbar() ) );
}


BooleanAusText::BooleanAusText( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_AUS_TEXT, subActions )
{
    erlaubteTypen.add( STRING );
}

void BooleanAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (String *)zParam( 0 ) )->getValue().istGleich( "true" ) ) );
}


BooleanTriggerIstAktiv::BooleanTriggerIstAktiv( RCArray< Aktion > *subActions )
    : Aktion( BOOLEAN_TRIGGER_IST_AKTIV, subActions )
{
    erlaubteTypen.add( TRIGGER );
}

void BooleanTriggerIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Boolean( ( (Trigger *)zParam( 0 ) )->istAktiv() ) );
}


BooleanRechnung::BooleanRechnung( RCArray< Aktion > *subActions, Operator op )
    : Aktion( BOOLEAN_RECHNUNG, subActions )
{
    this->op = op;
}

void BooleanRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( op == UND || op == ODER )
    {
        if( zParam( 0 )->getVariableTyp() != BOOLEAN || zParam( 1 )->getVariableTyp() != BOOLEAN )
            return;
        Boolean *b1 = (Boolean *)zParam( 0 );
        Boolean *b2 = (Boolean *)zParam( 1 );
        if( op == UND )
            setReturn( new Boolean( b1->getValue() && b2->getValue() ) );
        else
            setReturn( new Boolean( b1->getValue() || b2->getValue() ) );
    }
    if( op == GLEICH || op == UNGLEICH )
    {
        if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
        {
            setReturn( new Boolean( op == GLEICH ) );
            return;
        }
        switch( zParam( 0 )->getVariableTyp() )
        {
        case NICHTS:
            setReturn( new Boolean( op == GLEICH ) );
            break;
        case INTEGER:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
            break;
        case BOOLEAN:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Boolean *)zParam( 0 ) )->getValue() == ( (Boolean *)zParam( 1 ) )->getValue() ) ) );
            break;
        case STRING:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
            break;
        case RICHTUNG:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
            break;
        case FLOAT:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Float *)zParam( 0 ) )->getValue() == ( (Float *)zParam( 1 ) )->getValue() ) ) );
            break;
        case TASTE:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
            break;
        case GEGENSTAND_TYP:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() == ( (GegenstandTypVar *)zParam( 1 ) )->getValue() ) ) );
            break;
        case GESCHOSS_TYP:
            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
            break;
        default:
            setReturn( new Boolean( ( op == GLEICH ) == ( zParam( 0 ) == zParam( 1 ) ) ) );
        }
    }
    if( op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL )
    {
        if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
        {
            setReturn( new Boolean( op == GLEICH ) );
            return;
        }
        if( zParam( 1 )->getVariableTyp() == INTEGER )
        {
            if( op == SMALLER || op == GREATER_OR_EQUAL )
                setReturn( new Boolean( ( op == SMALLER ) == ( ( (Integer *)zParam( 0 ) )->getValue() < ( (Integer *)zParam( 1 ) )->getValue() ) ) );
            else
                setReturn( new Boolean( ( op == GREATER ) == ( ( (Integer *)zParam( 0 ) )->getValue() > ( (Integer *)zParam( 1 ) )->getValue() ) ) );
        }
        if( zParam( 1 )->getVariableTyp() == FLOAT )
        {
            if( op == SMALLER || op == GREATER_OR_EQUAL )
                setReturn( new Boolean( ( op == SMALLER ) == ( ( (Float *)zParam( 0 ) )->getValue() < ( (Float *)zParam( 1 ) )->getValue() ) ) );
            else
                setReturn( new Boolean( ( op == GREATER ) == ( ( (Float *)zParam( 0 ) )->getValue() > ( (Float *)zParam( 1 ) )->getValue() ) ) );
        }
    }
    if( op == INVERT_BOOL )
    {
        setReturn( new Boolean( !( (Boolean *)zParam( 0 ) )->getValue() ) );
    }
}

void BooleanRechnung::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&this->op, 1 );
}


Sequenz::Sequenz( RCArray< Aktion > *subActions )
    : Aktion( SEQUENZ, subActions )
{}

void Sequenz::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{}


FloatRechnung::FloatRechnung( RCArray< Aktion > *subActions, Operator op )
    : Aktion( FLOAT_RECHNUNG, subActions )
{
    this->op = op;
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( FLOAT );
}

void FloatRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Float *l = (Float *)zParam( 0 );
    Float *r = (Float *)zParam( 1 );
    switch( op )
    {
    case PLUS:
        setReturn( new Float( l->getValue() + r->getValue() ) );
        break;
    case MINUS:
        setReturn( new Float( l->getValue() - r->getValue() ) );
        break;
    case MAHL:
        setReturn( new Float( l->getValue() * r->getValue() ) );
        break;
    case GETEILT:
        setReturn( new Float( l->getValue() / r->getValue() ) );
        break;
    case HOCH:
        setReturn( new Float( (float)pow( l->getValue(), r->getValue() ) ) );
        break;
    case WURZEL:
        setReturn( new Float( (float)pow( l->getValue(), 1.0 / r->getValue() ) ) );
        break;
    case INVERT_SIGN:
        setReturn( new Float( -l->getValue() ) );
        break;
    case PLUS_PLUS_LEFT:
        l->setValue( l->getValue() + 1 );
        setReturn( new Float( l->getValue() ) );
        break;
    case PLUS_PLUS_RIGHT:
    {
        float tmp = l->getValue();
        l->setValue( l->getValue() + 1 );
        setReturn( new Float( tmp ) );
        break;
    }
    case MINUS_MINUS_LEFT:
        l->setValue( l->getValue() - 1 );
        setReturn( new Float( l->getValue() ) );
        break;
    case MINUS_MINUS_RIGHT:
    {
        float tmp = l->getValue();
        l->setValue( l->getValue() - 1 );
        setReturn( new Float( tmp ) );
        break;
    }
    case LOGARITHM:
        setReturn( new Float( (float)( log( l->getValue() ) / log( r->getValue() ) ) ) );
        break;
    case MODULO:
        setReturn( new Float( l->getValue() - (float)(int)( l->getValue() / r->getValue() ) * r->getValue() ) );
        break;
    default:
        break;
    }
}

void FloatRechnung::writeOptions( Datei &dat )
{
    dat.schreibe( (char *)&op, 1 );
}


FloatAusInteger::FloatAusInteger( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_AUS_INTEGER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void FloatAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( (float)( (Integer *)zParam( 0 ) )->getValue() ) );
}


FloatAusText::FloatAusText( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_AUS_TEXT, subActions )
{
    erlaubteTypen.add( STRING );
}

void FloatAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Float( (float)( (String *)zParam( 0 ) )->getValue() ) );
}


TextAusFloat::TextAusFloat( RCArray< Aktion > *subActions )
    : Aktion( TEXT_AUS_FLOAT, subActions )
{
    erlaubteTypen.add( FLOAT );
}

void TextAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( Text( ( (Float *)zParam( 0 ) )->getValue() ) ) );
}


FloatZufall::FloatZufall( RCArray< Aktion > *subActions )
    : Aktion( FLOAT_ZUFALL, subActions )
{
    erlaubteTypen.add( FLOAT );
    erlaubteTypen.add( FLOAT );
}

void FloatZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Float *min = ( (Float *)zParam( 0 ) );
    Float *max = ( (Float *)zParam( 0 ) );
    setReturn( new Float( (float)zSpiel->getRand() * ( max->getValue() - min->getValue() ) + min->getValue() ) );
}


IntegerAusFloat::IntegerAusFloat( RCArray< Aktion > *subActions )
    : Aktion( INTEGER_AUS_FLOAT, subActions )
{
    erlaubteTypen.add( FLOAT );
}

void IntegerAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Integer( (int)( (Float *)zParam( 0 ) )->getValue() ) );
}


BestenlisteNeu::BestenlisteNeu( RCArray<Aktion> *subActions )
    : Aktion( BESTENLISTE_NEU, subActions )
{}

void BestenlisteNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new Bestenliste( zSpiel->getNextId() ) );
}


BestenlisteAddZeile::BestenlisteAddZeile( RCArray<Aktion> *subActions )
    : Aktion( BESTENLISTE_ADD_ZEILE, subActions )
{
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( BESTENLISTE );
}

void BestenlisteAddZeile::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bestenliste *)zParam( 1 ) )->addZeile( ( (String *)zParam( 0 ) )->getValue() );
}


BestenlisteAddSpalte::BestenlisteAddSpalte( RCArray<Aktion> *subActions )
    : Aktion( BESTENLISTE_ADD_SPALTE, subActions )
{
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( BESTENLISTE );
}

void BestenlisteAddSpalte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bestenliste *)zParam( 1 ) )->addSpalte( ( (String *)zParam( 0 ) )->getValue() );
}


BestenlisteSetWert::BestenlisteSetWert( RCArray<Aktion> *subActions )
    : Aktion( BESTENLISTE_SET_WERT, subActions )
{
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( BESTENLISTE );
}

void BestenlisteSetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    ( (Bestenliste *)zParam( 3 ) )->setWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue(), ( (String *)zParam( 2 ) )->getValue() );
}


BestenlisteGetWert::BestenlisteGetWert( RCArray<Aktion> *subActions )
    : Aktion( BESTENLISTE_GET_WERT, subActions )
{
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( STRING );
    erlaubteTypen.add( BESTENLISTE );
}

void BestenlisteGetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( new String( ( (Bestenliste *)zParam( 2 ) )->getWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue() ) ) );
}


SchalterMitNummer::SchalterMitNummer( RCArray<Aktion> *subActions )
    : Aktion( SCHALTER_MIT_NUMMER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void SchalterMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Schalter *s = zSpiel->getSchalter( ( (Integer *)zParam( 0 ) )->getValue() );
    if( s )
        setReturn( s );
    else
        setReturn( new Variable( VariableTyp::NICHTS ) );
}


BaseMitNummer::BaseMitNummer( RCArray<Aktion> *subActions )
    : Aktion( BASE_MIT_NUMMER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void BaseMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Base *b = zSpiel->getBase( ( (Integer *)zParam( 0 ) )->getValue() );
    if( b )
        setReturn( b );
    else
        setReturn( new Variable( VariableTyp::NICHTS ) );
}


TeamMitNummer::TeamMitNummer( RCArray<Aktion> *subActions )
    : Aktion( TEAM_MIT_NUMMER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void TeamMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    setReturn( zSpiel->getTeam( ( (Integer *)zParam( 0 ) )->getValue() ) );
}


TeamVonBase::TeamVonBase( RCArray<Aktion> *subActions )
    : Aktion( TEAM_VON_BASE, subActions )
{
    erlaubteTypen.add( BASE );
}

void TeamVonBase::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Team *t = ( (Base *)zParam( 0 ) )->getTeam();
    if( t )
        setReturn( t );
    else
        setReturn( new Variable( VariableTyp::NICHTS ) );
}


SpielerMitNummer::SpielerMitNummer( RCArray<Aktion> *subActions )
    : Aktion( SPIELER_MIT_NUMMER, subActions )
{
    erlaubteTypen.add( INTEGER );
}

void SpielerMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    Spieler *s = zSpiel->getSpieler( ( (Integer *)zParam( 0 ) )->getValue() );
    if( s )
        setReturn( s );
    else
        setReturn( new Variable( VariableTyp::NICHTS ) );
}