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

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

Aktion::Aktion( AktionTyp typ )
    : Variable( AKTION )
{
    this->typ = typ;
}

Aktion::~Aktion()
{}


KonstantNichts::KonstantNichts()
    : Aktion( KONSTANT_NICHTS )
{}

bool KonstantNichts::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", new Variable( NICHTS ) );
    return 1;
}


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

bool KonstantInteger::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", new Integer( value ) );
    return 1;
}


KonstantBoolean::KonstantBoolean( bool val )
    : Aktion( KONSTANT_BOOLEAN )
{
    value = val;
}

bool KonstantBoolean::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", new Boolean( value ) );
    return 1;
}


KonstantString::KonstantString( Text val )
    : Aktion( KONSTANT_STRING )
{
    value = val;
}

bool KonstantString::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", new String( value ) );
    return 1;
}


KonstantFloat::KonstantFloat( float val )
    : Aktion( KONSTANT_FLOAT )
{
    value = val;
}

bool KonstantFloat::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", new Float( value ) );
    return 1;
}


KonstantVariable::KonstantVariable( Text name )
    : Aktion( KONSTANT_VARIABLE )
{
    this->name = name;
}

bool KonstantVariable::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( zMemory->zVariable( name ) )
        zMemory->setVar( "__return__", zMemory->getVariable( name ) );
    else if( zEreignis->zParameter( name ) )
        zMemory->setVar( "__return__", zEreignis->zParameter( name ) );
    else if( zSpiel->zVariable( name ) )
        zMemory->setVar( "__return__", zSpiel->getVariable( name ) );
    else
        zMemory->setVar( "__return__", new Variable( NICHTS ) );
    return 1;
}


Warten::Warten( Aktion *seconds )
    : Aktion( WARTEN )
{
    this->seconds = seconds;
}

Warten::~Warten()
{
    seconds->release();
}

bool Warten::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    bool finished = seconds->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
    if( finished )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != FLOAT )
        {
            zPC->stepOut();
            return 1;
        }
        waitCount += ( (Float *)t )->getValue();
    }
    return finished;
}


WennDannSonst::WennDannSonst( Aktion *wenn, Aktion *dann, Aktion *sonst )
    : Aktion( WENN_DANN_SONST )
{
    this->wenn = wenn;
    this->dann = dann;
    this->sonst = sonst;
}

WennDannSonst::~WennDannSonst()
{
    wenn->release();
    if( dann )
        dann->release();
    if( sonst )
        sonst->release();
}

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


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

SetVariable::~SetVariable()
{
    value->release();
}

bool SetVariable::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    bool finished = value->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
    if( finished )
    {
        if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
            zMemory->setVar( name, zMemory->getVariable( "__return__" ) );
        else
            zSpiel->setVariable( name, zMemory->getVariable( "__return__" ) );
    }
    return finished;
}


TriggerAktion::TriggerAktion( Aktion *number, Aktion *triggerName )
    : Aktion( TRIGGER_AKTION )
{
    this->number = number;
    trigger = triggerName;
}

TriggerAktion::~TriggerAktion()
{
    number->release();
    trigger->release();
}

bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( number->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TRIGGER )
            {
                zPC->stepOut();
                return 1;
            }
            int id = ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->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 *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerNachricht::SpielerNachricht( Aktion *spieler, Aktion *nachricht )
    : Aktion( SPIELER_NACHRICHT )
{
    this->spieler = spieler;
    this->nachricht = nachricht;
}

SpielerNachricht::~SpielerNachricht()
{
    spieler->release();
    nachricht->release();
}

bool SpielerNachricht::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( nachricht->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( t->getVariableTyp() != STRING )
            {
                zPC->stepOut();
                return 1;
            }
            // this is handeld on client side directly (no need to send the message to the player)
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


DisplayText::DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht )
    : Aktion( DISPLAY_TEXT )
{
    this->x = x;
    this->y = y;
    this->color = f;
    this->dauer = dauer;
    this->nachricht = nachricht;
}

DisplayText::~DisplayText()
{
    x->release();
    y->release();
    color->release();
    dauer->release();
    nachricht->release();
}

bool DisplayText::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( dauer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 3 && waitCount <= 0 )
    {
        if( color->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || ( t->getVariableTyp() != INTEGER ) )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R3__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 4 && waitCount <= 0 )
    {
        if( color->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || ( t->getVariableTyp() != STRING ) )
            {
                zPC->stepOut();
                return 1;
            }
            //Float *xv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" );
            //Float *yv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" );
            //Float *dauerv = (Float *)zMemory->zVariable( zPC->getUniqueString() + "R2__" );
            //Integer *farbev = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R3__" );
            // do nothing because the server does not need to show text
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielPause::SpielPause( Aktion *paused )
    : Aktion( SPIEL_PAUSE )
{
    this->paused = paused;
}

SpielPause::~SpielPause()
{
    paused->release();
}

bool SpielPause::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( paused->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || ( t->getVariableTyp() != BOOLEAN ) )
            return 1;
        zSpiel->setPausiert( ( (Boolean *)t )->getValue() );
        return 1;
    }
    return 0;
}


SpielEnde::SpielEnde( Aktion *gewinnerTeam )
    : Aktion( SPIEL_ENDE )
{
    this->gewinnerTeam = gewinnerTeam;
}

SpielEnde::~SpielEnde()
{
    gewinnerTeam->release();
}

bool SpielEnde::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( gewinnerTeam->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || ( t->getVariableTyp() != TEAM && t->getVariableTyp() != NICHTS ) )
            return 1;
        zSpiel->setEnde( t->getVariableTyp() == NICHTS ? 0 : (Team *)t );
        return 1;
    }
    return 0;
}


SpielerSetLevel::SpielerSetLevel( Aktion *level, Aktion *spieler )
    : Aktion( SPIELER_SET_LEVEL )
{
    this->level = level;
    this->spieler = spieler;
}

SpielerSetLevel::~SpielerSetLevel()
{
    level->release();
    spieler->release();
}

bool SpielerSetLevel::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( level->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setLevel( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerGiveItem::SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler )
    : Aktion( SPIELER_GIVE_ITEM )
{
    this->item = item;
    this->anzahl = anzahl;
    this->spieler = spieler;
}

SpielerGiveItem::~SpielerGiveItem()
{}

bool SpielerGiveItem::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( item->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GEGENSTAND_TYP )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( anzahl->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->addItem( ( (GegenstandTypVar *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
                ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue(), zSpiel );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerRemoveItem::SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler )
    : Aktion( SPIELER_REMOVE_ITEM )
{
    this->item = item;
    this->anzahl = anzahl;
    this->spieler = spieler;
}

SpielerRemoveItem::~SpielerRemoveItem()
{
    item->release();
    anzahl->release();
    spieler->release();
}

bool SpielerRemoveItem::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( item->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GEGENSTAND_TYP )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( anzahl->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->removeItem( ( (GegenstandTypVar *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
                ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetPosition::SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler )
    : Aktion( SPIELER_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->spieler = spieler;
}

SpielerSetPosition::~SpielerSetPosition()
{
    x->release();
    y->release();
    spieler->release();
}

bool SpielerSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Spieler *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetLeben::SpielerSetLeben( Aktion *leben, Aktion *spieler )
    : Aktion( SPIELER_SET_LEBEN )
{
    this->leben = leben;
    this->spieler = spieler;
}

SpielerSetLeben::~SpielerSetLeben()
{
    leben->release();
    spieler->release();
}

bool SpielerSetLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( leben->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setLeben( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetMaxLeben::SpielerSetMaxLeben( Aktion *leben, Aktion *spieler )
    : Aktion( SPIELER_SET_LEBEN )
{
    this->leben = leben;
    this->spieler = spieler;
}

SpielerSetMaxLeben::~SpielerSetMaxLeben()
{
    leben->release();
    spieler->release();
}

bool SpielerSetMaxLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( leben->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setMaxLeben( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetErfahrung::SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler )
    : Aktion( SPIELER_SET_ERFAHRUNG )
{
    this->erfahrung = erfahrung;
    this->spieler = spieler;
}

SpielerSetErfahrung::~SpielerSetErfahrung()
{}

bool SpielerSetErfahrung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( erfahrung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setErfahrung( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler )
    : Aktion( SPIELER_SET_MAX_ERFAHRUNG )
{
    this->erfahrung = erfahrung;
    this->spieler = spieler;
}

SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung()
{
    erfahrung->release();
    spieler->release();
}

bool SpielerSetMaxErfahrung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( erfahrung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setMaxErfahrung( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetTempo::SpielerSetTempo( Aktion *tempo, Aktion *spieler )
    : Aktion( SPIELER_SET_TEMPO )
{
    this->tempo = tempo;
    this->spieler = spieler;
}

SpielerSetTempo::~SpielerSetTempo()
{
    tempo->release();
    spieler->release();
}

bool SpielerSetTempo::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( tempo->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setLaufTempo( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetWaffenTempo::SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler )
    : Aktion( SPIELER_SET_GESCHOSS_TEMPO )
{
    this->tempo = tempo;
    this->spieler = spieler;
}

SpielerSetWaffenTempo::~SpielerSetWaffenTempo()
{
    tempo->release();
    spieler->release();
}

bool SpielerSetWaffenTempo::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( tempo->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setGeschossTempo( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetArmor::SpielerSetArmor( Aktion *armor, Aktion *spieler )
    : Aktion( SPIELER_SET_ARMOR )
{
    this->armor = armor;
    this->spieler = spieler;
}

SpielerSetArmor::~SpielerSetArmor()
{
    armor->release();
    spieler->release();
}

bool SpielerSetArmor::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( armor->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setArmor( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetSchadenBonus::SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler )
    : Aktion( SPIELER_SET_SCHADEN_BONUS )
{
    this->bonus = bonus;
    this->spieler = spieler;
}

SpielerSetSchadenBonus::~SpielerSetSchadenBonus()
{
    bonus->release();
    spieler->release();
}

bool SpielerSetSchadenBonus::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( bonus->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setSchadenBonus( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetLebensraub::SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler )
    : Aktion( SPIELER_SET_LEBENSRAUB )
{
    this->lebensraub = lebensraub;
    this->spieler = spieler;
}

SpielerSetLebensraub::~SpielerSetLebensraub()
{
    lebensraub->release();
    spieler->release();
}

bool SpielerSetLebensraub::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( lebensraub->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setLebensRaub( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetLebensregeneration::SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler )
    : Aktion( SPIELER_SET_LEBENSRAUB )
{
    this->regeneration = regeneration;
    this->spieler = spieler;
}

SpielerSetLebensregeneration::~SpielerSetLebensregeneration()
{
    regeneration->release();
    spieler->release();
}

bool SpielerSetLebensregeneration::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( regeneration->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setLebensRegeneration( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler )
    : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG )
{
    this->verringerung = verringerung;
    this->spieler = spieler;
}

SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung()
{
    verringerung->release();
    spieler->release();
}

bool SpielerSetAbklingzeitverringerung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( verringerung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Spieler *)t )->setAbklingZeitVerringerung( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


DropSetTime::DropSetTime( Aktion *time, Aktion *drop )
    : Aktion( DROP_SET_TIME )
{
    this->time = time;
    this->drop = drop;
}

DropSetTime::~DropSetTime()
{
    time->release();
    drop->release();
}

bool DropSetTime::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( time->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != DROP )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Drop *)t )->setTime( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


DropSetMaxTime::DropSetMaxTime( Aktion *time, Aktion *drop )
    : Aktion( DROP_SET_MAX_TIME )
{
    this->time = time;
    this->drop = drop;
}

DropSetMaxTime::~DropSetMaxTime()
{
    time->release();
    drop->release();
}

bool DropSetMaxTime::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( time->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != DROP )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Drop *)t )->setMaxTime( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


DropSetArea::DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop )
    : Aktion( DROP_SET_AREA )
{
    this->minX = minX;
    this->maxX = maxX;
    this->minY = minY;
    this->maxY = maxY;
    this->drop = drop;
}

DropSetArea::~DropSetArea()
{
    minX->release();
    maxX->release();
    minY->release();
    maxY->release();
    drop->release();
}

bool DropSetArea::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( minX->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( maxX->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( minY->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 3 && waitCount <= 0 )
    {
        if( maxY->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R3__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 4 && waitCount <= 0 )
    {
        if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != DROP )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Drop *)t )->setMinX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Drop *)t )->setMaxX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            ( (Drop *)t )->setMinY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R2__" ) )->getValue() );
            ( (Drop *)t )->setMaxY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R3__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


DropDoDrop::DropDoDrop( Aktion *drop )
    : Aktion( DROP_DO_DROP )
{
    this->drop = drop;
}

DropDoDrop::~DropDoDrop()
{}

bool DropDoDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != DROP )
        {
            zPC->stepOut();
            return 1;
        }
        ( (Drop *)t )->doDrop( zSpiel );
        return 1;
    }
    return 0;
}


BariereBewegung::BariereBewegung( Aktion *bariere )
    : Aktion( BARIERE_BEWEGUNG )
{
    this->bariere = bariere;
}

BariereBewegung::~BariereBewegung()
{
    bariere->release();
}

bool BariereBewegung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != BARIERE )
        {
            zPC->stepOut();
            return 1;
        }
        ( (Bariere *)t )->startAutoVerschiebung( zSpiel );
        return 1;
    }
    return 0;
}


BariereSetEingeschaltet::BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere )
    : Aktion( BARIERE_SET_EINGESCHALTET )
{
    this->eingeschaltet = eingeschaltet;
    this->bariere = bariere;
}

BariereSetEingeschaltet::~BariereSetEingeschaltet()
{
    eingeschaltet->release();
    bariere->release();
}

bool BariereSetEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( eingeschaltet->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BARIERE )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Bariere *)t )->setEingeschaltet( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


BariereSetPosition::BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere )
    : Aktion( BARIERE_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->bariere = bariere;
}

BariereSetPosition::~BariereSetPosition()
{
    x->release();
    y->release();
    bariere->release();
}

bool BariereSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BARIERE )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Bariere *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Bariere *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


BariereSetTeam::BariereSetTeam( Aktion *team, Aktion *bariere )
    : Aktion( BARIERE_SET_TEAM )
{
    this->team = team;
    this->bariere = bariere;
}

BariereSetTeam::~BariereSetTeam()
{
    team->release();
    bariere->release();
}

bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TEAM )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BARIERE )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Bariere *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SchalterSetPosition::SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter )
    : Aktion( SCHALTER_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->schalter = schalter;
}

SchalterSetPosition::~SchalterSetPosition()
{
    x->release();
    y->release();
    schalter->release();
}

bool SchalterSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SCHALTER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Schalter *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Schalter *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SchalterSetErlaubt::SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter )
    : Aktion( SCHALTER_SET_ERLAUBT )
{
    this->erlaubt = erlaubt;
    this->schalter = schalter;
}

SchalterSetErlaubt::~SchalterSetErlaubt()
{
    erlaubt->release();
    schalter->release();
}

bool SchalterSetErlaubt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( erlaubt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SCHALTER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Schalter *)t )->setAktive( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


SchalterAktivieren::SchalterAktivieren( Aktion *schalter )
    : Aktion( SCHALTER_AKTIVIEREN )
{
    this->schalter = schalter;
}

SchalterAktivieren::~SchalterAktivieren()
{
    schalter->release();
}

bool SchalterAktivieren::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != SCHALTER )
        {
            zPC->stepOut();
            return 1;
        }
        zSpiel->activateShalter( ( (Schalter *)t )->getId() );
        return 1;
    }
    return 0;
}


TunnelSetPosition::TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel )
    : Aktion( TUNNEL_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->tunnel = tunnel;
}

TunnelSetPosition::~TunnelSetPosition()
{
    x->release();
    y->release();
    tunnel->release();
}

bool TunnelSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TUNNEL )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Tunnel *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Tunnel *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TunnelSetZielPosition::TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel )
    : Aktion( TUNNEL_SET_ZIEL_POSITION )
{
    this->x = x;
    this->y = y;
    this->tunnel = tunnel;
}

TunnelSetZielPosition::~TunnelSetZielPosition()
{
    x->release();
    y->release();
    tunnel->release();
}

bool TunnelSetZielPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TUNNEL )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Tunnel *)t )->setZielX( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Tunnel *)t )->setZielY( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TunnelSetErlaubt::TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel )
    : Aktion( TUNNEL_SET_ERLAUBT )
{
    this->erlaubt = erlaubt;
    this->tunnel = tunnel;
}

TunnelSetErlaubt::~TunnelSetErlaubt()
{
    erlaubt->release();
    tunnel->release();
}

bool TunnelSetErlaubt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( erlaubt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TUNNEL )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Tunnel *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


UmlenkungSetPosition::UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung )
    : Aktion( UMLENKUNG_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->umlenkung = umlenkung;
}

UmlenkungSetPosition::~UmlenkungSetPosition()
{
    x->release();
    y->release();
    umlenkung->release();
}

bool UmlenkungSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != UMLENKUNG )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Umlenkung *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Umlenkung *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


UmlenkungSetRichtung::UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung )
    : Aktion( UMLENKUNG_SET_RICHTUNG )
{
    this->richtung = richtung;
    this->umlenkung = umlenkung;
}

UmlenkungSetRichtung::~UmlenkungSetRichtung()
{
    richtung->release();
    umlenkung->release();
}

bool UmlenkungSetRichtung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != RICHTUNG )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != UMLENKUNG )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Umlenkung *)t )->setRichtung( getRichtungFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung )
    : Aktion( UMLENKUNG_SET_MAX_ABK )
{
    this->abk = abk;
    this->umlenkung = umlenkung;
}

UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk()
{
    abk->release();
    umlenkung->release();
}

bool UmlenkungSetMaxAbk::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( abk->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != UMLENKUNG )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Umlenkung *)t )->setMaxAbklingzeit( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


UmlenkungSetEnabled::UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung )
    : Aktion( UMLENKUNG_SET_ERLAUBT )
{
    this->enabled = enabled;
    this->umlenkung = umlenkung;
}

UmlenkungSetEnabled::~UmlenkungSetEnabled()
{
    enabled->release();
    umlenkung->release();
}

bool UmlenkungSetEnabled::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( enabled->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != UMLENKUNG )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Umlenkung *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


BaseSetPosition::BaseSetPosition( Aktion *x, Aktion *y, Aktion *base )
    : Aktion( BASE_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->base = base;
}

BaseSetPosition::~BaseSetPosition()
{
    x->release();
    y->release();
    base->release();
}

bool BaseSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( base->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BASE )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Base *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Base *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


BaseSetTeam::BaseSetTeam( Aktion *team, Aktion *base )
    : Aktion( BASE_SET_TEAM )
{
    this->team = team;
    this->base = base;
}

BaseSetTeam::~BaseSetTeam()
{
    team->release();
    base->release();
}

bool BaseSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TEAM )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( base->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BASE )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Base *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}

TriggerRunStart::TriggerRunStart( Aktion *trigger )
    : Aktion( TRIGGER_RUN_START )
{
    this->trigger = trigger;
}

TriggerRunStart::~TriggerRunStart()
{
    trigger->release();
}

bool TriggerRunStart::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != TRIGGER )
        {
            zPC->stepOut();
            return 1;
        }
        zSpiel->addTriggerRun( ( (Trigger *)t )->runTrigger( zEreignis->getThis(), zSpiel ) );
        zPC->stepOut();
        return 1;
    }
    return 0;
}


TriggerSetEnabled::TriggerSetEnabled( Aktion *enabled, Aktion *trigger )
    : Aktion( TRIGGER_SET_ENABLED )
{
    this->enabled = enabled;
    this->trigger = trigger;
}

TriggerSetEnabled::~TriggerSetEnabled()
{
    enabled->release();
    trigger->release();
}

bool TriggerSetEnabled::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( enabled->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( trigger->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TRIGGER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Trigger *)t )->setAktiv( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TeamSetPunkte::TeamSetPunkte( Aktion *punkte, Aktion *team )
    : Aktion( TEAM_SET_PUNKTE )
{
    this->punkte = punkte;
    this->team = team;
}

TeamSetPunkte::~TeamSetPunkte()
{
    punkte->release();
    team->release();
}

bool TeamSetPunkte::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( punkte->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TEAM )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Team *)t )->setPunkte( ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TimerSetPosition::TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer )
    : Aktion( TIMER_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->timer = timer;
}

TimerSetPosition::~TimerSetPosition()
{
    x->release();
    y->release();
    timer->release();
}

bool TimerSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TIMER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Timer *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Timer *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TimerSetPause::TimerSetPause( Aktion *pause, Aktion *timer )
    : Aktion( TIMER_SET_PAUSE )
{
    this->pause = pause;
    this->timer = timer;
}

TimerSetPause::~TimerSetPause()
{
    pause->release();
    timer->release();
}

bool TimerSetPause::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( pause->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TIMER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Timer *)t )->setPause( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TimerStart::TimerStart( Aktion *timer )
    : Aktion( TIMER_START )
{
    this->timer = timer;
}

TimerStart::~TimerStart()
{
    timer->release();
}

bool TimerStart::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
    {
        Variable *t = zMemory->zVariable( "__return__" );
        if( !t || t->getVariableTyp() != TIMER )
        {
            zPC->stepOut();
            return 1;
        }
        ( (Timer *)t )->start( zSpiel );
        zPC->stepOut();
        return 1;
    }
    return 0;
}


TimerSetZeit::TimerSetZeit( Aktion *zeit, Aktion *timer )
    : Aktion( TIMER_SET_ZEIT )
{
    this->zeit = zeit;
    this->timer = timer;
}

TimerSetZeit::~TimerSetZeit()
{
    zeit->release();
    timer->release();
}

bool TimerSetZeit::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( zeit->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TIMER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Timer *)t )->setZeit( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TimerSetSichtbar::TimerSetSichtbar( Aktion *sichtbar, Aktion *timer )
    : Aktion( TIMER_SET_SICHTBAR )
{
    this->sichtbar = sichtbar;
    this->timer = timer;
}

TimerSetSichtbar::~TimerSetSichtbar()
{
    sichtbar->release();
    timer->release();
}

bool TimerSetSichtbar::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( sichtbar->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != BOOLEAN )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != TIMER )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Timer *)t )->setSichtbar( ( (Boolean *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossNeu::GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung )
    : Aktion( GESCHOSS_NEU )
{
    this->x = x;
    this->y = y;
    this->typ = typ;
    this->richtung = richtung;
}

GeschossNeu::~GeschossNeu()
{
    x->release();
    y->release();
    typ->release();
    richtung->release();
}

bool GeschossNeu::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( typ->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS_TYP )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R2__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 3 && waitCount <= 0 )
    {
        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != RICHTUNG )
            {
                zPC->stepOut();
                return 1;
            }
            Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
                                        getGeschossTypFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ),
                                        getRichtungFromString( ( (String *)t )->getValue() ),
                                        ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue(),
                                        ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue(), 0 );
            zSpiel->addGeschoss( (Geschoss *)g->getThis() );
            zMemory->setVar( "__return__", g );
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossSetPosition::GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss )
    : Aktion( GESCHOSS_SET_POSITION )
{
    this->x = x;
    this->y = y;
    this->geschoss = geschoss;
}

GeschossSetPosition::~GeschossSetPosition()
{
    x->release();
    y->release();
    geschoss->release();
}

bool GeschossSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 2 && waitCount <= 0 )
    {
        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Geschoss *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            ( (Geschoss *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossSetSpeed::GeschossSetSpeed( Aktion *speed, Aktion *geschoss )
    : Aktion( GESCHOSS_SET_SPEED )
{
    this->speed = speed;
    this->geschoss = geschoss;
}

GeschossSetSpeed::~GeschossSetSpeed()
{
    speed->release();
    geschoss->release();
}

bool GeschossSetSpeed::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( speed->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != FLOAT )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Geschoss *)t )->setSpeed( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossSetPlayer::GeschossSetPlayer( Aktion *player, Aktion *geschoss )
    : Aktion( GESCHOSS_SET_PLAYER )
{
    this->player = player;
    this->geschoss = geschoss;
}

GeschossSetPlayer::~GeschossSetPlayer()
{
    player->release();
    geschoss->release();
}

bool GeschossSetPlayer::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( player->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != SPIELER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Geschoss *)t )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossSetRichtung::GeschossSetRichtung( Aktion *richtung, Aktion *geschoss )
    : Aktion( GESCHOSS_SET_RICHTUNG )
{
    this->richtung = richtung;
    this->geschoss = geschoss;
}

GeschossSetRichtung::~GeschossSetRichtung()
{
    richtung->release();
    geschoss->release();
}

bool GeschossSetRichtung::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( richtung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != RICHTUNG )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Geschoss *)t )->setRichtung( getRichtungFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


GeschossSetType::GeschossSetType( Aktion *type, Aktion *geschoss )
    : Aktion( GESCHOSS_SET_TYPE )
{
    this->type = type;
    this->geschoss = geschoss;
}

GeschossSetType::~GeschossSetType()
{
    type->release();
    geschoss->release();
}

bool GeschossSetType::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    if( zPC->currentPosition() == 0 )
    {
        if( type->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS_TYP )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != GESCHOSS )
            {
                zPC->stepOut();
                return 1;
            }
            ( (Geschoss *)t )->setTyp( getGeschossTypFromString( ( (String *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() ) );
            zPC->stepOut();
            return 1;
        }
    }
    zPC->stepOut();
    return 0;
}


TriggerZufall::TriggerZufall()
    : Aktion( TRIGGER_ZUFALL )
{}

bool TriggerZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getRandomTrigger() );
    return 1;
}


TriggerLastRunned::TriggerLastRunned()
    : Aktion( TRIGGER_LAST_RUNNED )
{}

bool TriggerLastRunned::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getLastRunnedTrigger() );
    return 1;
}


BariereZufall::BariereZufall()
    : Aktion( BARIERE_ZUFALL )
{}

bool BariereZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getRandomBariere() );
    return 1;
}


BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
    : Aktion( BARIERE_ZULETZT_EINGESCHALTET )
{}

bool BariereZuletztEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getZuletztEingeschalteteBariere() );
    return 1;
}


BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET )
{}

bool BariereZuletztAusgeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getZuletztAusgeschalteteBariere() );
    return 1;
}


BariereZuletztBewegt::BariereZuletztBewegt()
    : Aktion( BARIERE_ZULETZT_BEWEGT )
{}

bool BariereZuletztBewegt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getZuletztBewegteBariere() );
    return 1;
}


BaseZufall::BaseZufall()
    : Aktion( BASE_ZUFALL )
{}

bool BaseZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getRandomBase() );
    return 1;
}


BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT )
{}

bool BaseZuletztBesitzerGewechselt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getLastTeamChangedBase() );
    return 1;
}


DropZufall::DropZufall()
    : Aktion( DROP_ZUFALL )
{}

bool DropZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getRandomDrop() );
    return 1;
}


DropZuletztGedropt::DropZuletztGedropt()
    : Aktion( DROP_ZULETZT_GEDROPT )
{}

bool DropZuletztGedropt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zMemory->setVar( "__return__", zSpiel->getLastDrop() );
    return 1;
}


IntegerRechnen::IntegerRechnen( Aktion *left, Aktion *right, Operator op )
    : Aktion( INTEGER_RECHNEN )
{
    this->left = left;
    this->right = right;
    this->op = op;
}

IntegerRechnen::~IntegerRechnen()
{
    left->release();
    right->release();
}

bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
{
    zPC->stepIn();
    bool finished = 0;
    if( zPC->currentPosition() == 0 )
    {
        if( left->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
            if( !isBinary( op ) )
                finished = 1;
            else
                zPC->count();
        }
    }
    if( zPC->currentPosition() == 1 && waitCount <= 0 )
    {
        if( right->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
        {
            Variable *t = zMemory->zVariable( "__return__" );
            if( !t || t->getVariableTyp() != INTEGER )
            {
                zPC->stepOut();
                return 1;
            }
            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
            finished = 1;
        }
    }
    if( finished )
    {
        Integer *l = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" );
        Integer *r = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" );
        switch( op )
        {
        case PLUS:
            zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) );
            break;
        case MINUS:
            zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) );
            break;
        case MAHL:
            zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) );
            break;
        case GETEILT:
            zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) );
            break;
        case HOCH:
            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
            break;
        case WURZEL:
            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
            break;
        case BIT_ODER:
            zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) );
            break;
        case BIT_UND:
            zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) );
            break;
        case BIT_XOR:
            zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) );
            break;
        case BIT_FLIP:
            zMemory->setVar( "__return__", new Integer( ~l->getValue() ) );
            break;
        case BIT_SHIFT_LEFT:
            zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) );
            break;
        case BIT_SHIFT_RIGHT:
            zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) );
            break;
        case INVERT_SIGN:
            zMemory->setVar( "__return__", new Integer( -l->getValue() ) );
            break;
        case PLUS_PLUS_LEFT:
            l->setValue( l->getValue() + 1 );
            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
            break;
        case PLUS_PLUS_RIGHT:
        {
            int tmp = l->getValue();
            l->setValue( l->getValue() + 1 );
            zMemory->setVar( "__return__", new Integer( tmp ) );
            break;
        }
        case MINUS_MINUS_LEFT:
            l->setValue( l->getValue() - 1 );
            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
            break;
        case MINUS_MINUS_RIGHT:
        {
            int tmp = l->getValue();
            l->setValue( l->getValue() - 1 );
            zMemory->setVar( "__return__", new Integer( tmp ) );
            break;
        }
        case LOGARITHM:
            zMemory->setVar( "__return__", new Integer( log( l->getValue() ) / log( r->getValue() ) ) );
            break;
        case MODULO:
            zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
            break;
        }
        zPC->stepOut();
        return 1;
    }
    zPC->stepOut();
    return 0;
}