framework changes

StickmanWorldOnline/Aktionen.cpp

@@ -10,3037 +10,3037 @@
 #define getReturn      zMemory->getVariable( "__return__" )
 
 
-Aktion::Aktion( AktionTyp typ, RCArray< Aktion > *subActions )
-    : Variable( AKTION )
+Aktion::Aktion(AktionTyp typ, RCArray< Aktion >* subActions)
+	: Variable(AKTION)
 {
-    this->subActions = subActions;
-    for( int i = 0; i < subActions->getEintragAnzahl(); i++ )
-        erlaubteTypen.add( ALLE );
-    this->typ = typ;
+	this->subActions = subActions;
+	for (int i = 0; i < subActions->getEintragAnzahl(); i++)
+		erlaubteTypen.add(ALLE);
+	this->typ = typ;
 }
 
 Aktion::~Aktion()
 {
-    subActions->release();
-}
-
-Variable *Aktion::zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
-{
-    return zMemory->zVariable( zPC->getUniqueString() + "R" + number + "__" );
-}
-
-Variable *Aktion::getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC )
-{
-    return zMemory->getVariable( zPC->getUniqueString() + "R" + number + "__" );
-}
-
-bool Aktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    if( waitCount > 0 )
-        return 0;
-    zPC->stepIn();
-    // evaluate parameters
-    for( int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++ )
-    {
-        if( !subActions->z( i )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            zPC->stepOut();
-            return 0;
-        }
-        Variable *result = zReturn;
-        if( ( !result && erlaubteTypen.get( i ) != NICHTS ) || ( result && result->getVariableTyp() != erlaubteTypen.get( i ) ) )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-        if( result )
-            zMemory->setVar( zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable *>( result->getThis() ) );
-        zPC->count();
-        if( waitCount > 0 )
-        {
-            zPC->stepOut();
-            return 0;
-        }
-    }
-    if( zPC->currentPosition() == subActions->getEintragAnzahl() )
-    {
-        // evaluate result
-        run( zSpiel, zEreignis, zMemory, zPC, waitCount );
-        zPC->stepOut();
-        return 1;
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-void Aktion::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+	subActions->release();
+}
+
+Variable* Aktion::zEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
+{
+	return zMemory->zVariable(zPC->getUniqueString() + "R" + number + "__");
+}
+
+Variable* Aktion::getEvaluatedParam(int number, LocalMemory* zMemory, ProgramCounter* zPC)
+{
+	return zMemory->getVariable(zPC->getUniqueString() + "R" + number + "__");
+}
+
+bool Aktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	if (waitCount > 0)
+		return 0;
+	zPC->stepIn();
+	// evaluate parameters
+	for (int i = zPC->currentPosition(); i < subActions->getEintragAnzahl(); i++)
+	{
+		if (!subActions->z(i)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
+		{
+			zPC->stepOut();
+			return 0;
+		}
+		Variable* result = zReturn;
+		if ((!result && erlaubteTypen.get(i) != NICHTS) || (result && result->getVariableTyp() != erlaubteTypen.get(i)))
+		{
+			zPC->stepOut();
+			return 1;
+		}
+		if (result)
+			zMemory->setVar(zPC->getUniqueString() + "R" + i + "__", dynamic_cast<Variable*>(result->getThis()));
+		zPC->count();
+		if (waitCount > 0)
+		{
+			zPC->stepOut();
+			return 0;
+		}
+	}
+	if (zPC->currentPosition() == subActions->getEintragAnzahl())
+	{
+		// evaluate result
+		run(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		zPC->stepOut();
+		return 1;
+	}
+	zPC->stepOut();
+	return 0;
+}
+
+void Aktion::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {}
 
-void Aktion::writeOptions( StreamWriter &dat )
+void Aktion::writeOptions(StreamWriter& dat)
 {}
 
 AktionTyp Aktion::getTyp() const
 {
-    return typ;
+	return typ;
 }
 
-RCArray< Aktion > *Aktion::zSubActions() const
+RCArray< Aktion >* Aktion::zSubActions() const
 {
-    return subActions;
+	return subActions;
 }
 
 
 KonstantNichts::KonstantNichts()
-    : Aktion( KONSTANT_NICHTS, new RCArray< Aktion >() )
+	: Aktion(KONSTANT_NICHTS, new RCArray< Aktion >())
 {}
 
-void KonstantNichts::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantNichts::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Variable( NICHTS ) );
+	setReturn(new Variable(NICHTS));
 }
 
 
-KonstantInteger::KonstantInteger( int val )
-    : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
+KonstantInteger::KonstantInteger(int val)
+	: Aktion(KONSTANT_INTEGER, new RCArray< Aktion >())
 {
-    this->value = val;
+	this->value = val;
 }
 
-void KonstantInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( value ) );
+	setReturn(new Integer(value));
 }
 
-void KonstantInteger::writeOptions( StreamWriter &dat )
+void KonstantInteger::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&value, 4 );
+	dat.schreibe((char*)&value, 4);
 }
 
 
-KonstantGegenstandTyp::KonstantGegenstandTyp( GegenstandTyp val )
-    : Aktion( KONSTANT_GEGENSTAND_TYP, new RCArray< Aktion >() )
+KonstantGegenstandTyp::KonstantGegenstandTyp(GegenstandTyp val)
+	: Aktion(KONSTANT_GEGENSTAND_TYP, new RCArray< Aktion >())
 {
-    this->value = val;
+	this->value = val;
 }
 
-void KonstantGegenstandTyp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantGegenstandTyp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( value ) );
+	setReturn(new GegenstandTypVar(value));
 }
 
-void KonstantGegenstandTyp::writeOptions( StreamWriter &dat )
+void KonstantGegenstandTyp::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&value, 4 );
+	dat.schreibe((char*)&value, 4);
 }
 
 
-KonstantTaste::KonstantTaste( unsigned char val )
-    : Aktion( KONSTANT_TASTE, new RCArray< Aktion >() )
+KonstantTaste::KonstantTaste(unsigned char val)
+	: Aktion(KONSTANT_TASTE, new RCArray< Aktion >())
 {
-    this->value = val;
+	this->value = val;
 }
 
-void KonstantTaste::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantTaste::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( (int)value, 1 ) );
+	setReturn(new Integer((int)value, 1));
 }
 
-void KonstantTaste::writeOptions( StreamWriter &dat )
+void KonstantTaste::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&value, 1 );
+	dat.schreibe((char*)&value, 1);
 }
 
 
-KonstantBoolean::KonstantBoolean( bool val )
-    : Aktion( KONSTANT_BOOLEAN, new RCArray< Aktion >() )
+KonstantBoolean::KonstantBoolean(bool val)
+	: Aktion(KONSTANT_BOOLEAN, new RCArray< Aktion >())
 {
-    value = val;
+	value = val;
 }
 
-void KonstantBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( value ) );
+	setReturn(new Boolean(value));
 }
 
-void KonstantBoolean::writeOptions( StreamWriter &dat )
+void KonstantBoolean::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&value, 1 );
+	dat.schreibe((char*)&value, 1);
 }
 
 
-KonstantString::KonstantString( Text val )
-    : Aktion( KONSTANT_STRING, new RCArray< Aktion >() )
+KonstantString::KonstantString(Text val)
+	: Aktion(KONSTANT_STRING, new RCArray< Aktion >())
 {
-    value = val;
+	value = val;
 }
 
-void KonstantString::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantString::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( value ) );
+	setReturn(new String(value));
 }
 
-void KonstantString::writeOptions( StreamWriter &dat )
+void KonstantString::writeOptions(StreamWriter& dat)
 {
-    char len = (char)value.getLength();
-    dat.schreibe( (char *)&len, 1 );
-    dat.schreibe( value, len );
+	char len = (char)value.getLength();
+	dat.schreibe((char*)&len, 1);
+	dat.schreibe(value, len);
 }
 
 
-KonstantFloat::KonstantFloat( float val )
-    : Aktion( KONSTANT_FLOAT, new RCArray< Aktion >() )
+KonstantFloat::KonstantFloat(float val)
+	: Aktion(KONSTANT_FLOAT, new RCArray< Aktion >())
 {
-    value = val;
+	value = val;
 }
 
-void KonstantFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( value ) );
+	setReturn(new Float(value));
 }
 
-void KonstantFloat::writeOptions( StreamWriter &dat )
+void KonstantFloat::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&value, 4 );
+	dat.schreibe((char*)&value, 4);
 }
 
 
-KonstantVariable::KonstantVariable( Text name )
-    : Aktion( KONSTANT_VARIABLE, new RCArray< Aktion >() )
+KonstantVariable::KonstantVariable(Text name)
+	: Aktion(KONSTANT_VARIABLE, new RCArray< Aktion >())
 {
-    this->name = name;
+	this->name = name;
 }
 
-void KonstantVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void KonstantVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    if( zMemory->zVariable( name ) )
-        setReturn( zMemory->getVariable( name ) );
-    else if( zEreignis->zParameter( name ) )
-        setReturn( zEreignis->getParameter( name ) );
-    else if( zSpiel->zVariable( name ) )
-        setReturn( zSpiel->getVariable( name ) );
-    else
-        setReturn( new Variable( NICHTS ) );
+	if (zMemory->zVariable(name))
+		setReturn(zMemory->getVariable(name));
+	else if (zEreignis->zParameter(name))
+		setReturn(zEreignis->getParameter(name));
+	else if (zSpiel->zVariable(name))
+		setReturn(zSpiel->getVariable(name));
+	else
+		setReturn(new Variable(NICHTS));
 }
 
-void KonstantVariable::writeOptions( StreamWriter &dat )
+void KonstantVariable::writeOptions(StreamWriter& dat)
 {
-    char len = (char)name.getLength();
-    dat.schreibe( (char *)&len, 1 );
-    dat.schreibe( name, len );
+	char len = (char)name.getLength();
+	dat.schreibe((char*)&len, 1);
+	dat.schreibe(name, len);
 }
 
 
-Warten::Warten( RCArray< Aktion > *subActions )
-    : Aktion( WARTEN, subActions )
+Warten::Warten(RCArray< Aktion >* subActions)
+	: Aktion(WARTEN, subActions)
 {
-    this->erlaubteTypen.add( FLOAT );
+	this->erlaubteTypen.add(FLOAT);
 }
 
-void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void Warten::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    waitCount += ( (Float *)zParam( 0 ) )->getValue();
+	waitCount += ((Float*)zParam(0))->getValue();
 }
 
 
-WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions )
-    : Aktion( WENN_DANN_SONST, subActions )
+WennDannSonst::WennDannSonst(RCArray< Aktion >* subActions)
+	: Aktion(WENN_DANN_SONST, subActions)
 {}
 
-bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        bool finished = subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
-        if( finished )
-        {
-            Variable *ret = zReturn;
-            zPC->count();
-            if( !isTrue( ret ) )
-            {
-                zPC->count();
-                if( !subActions->z( 2 ) )
-                {
-                    zPC->stepOut();
-                    return 1;
-                }
-            }
-            else
-            {
-                if( !subActions->z( 1 ) )
-                {
-                    zPC->stepOut();
-                    return 1;
-                }
-            }
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        bool finished = subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
-        if( finished )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        bool finished = subActions->z( 2 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount );
-        if( finished )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
-SetVariable::SetVariable( Text name, RCArray< Aktion > *subActions )
-    : Aktion( SET_VARIABLE, subActions )
-{
-    this->name = name;
-}
-
-void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
-        zMemory->setVar( name, getParam( 0 ) );
-    else
-        zSpiel->setVariable( name, getParam( 0 ) );
-}
-
-void SetVariable::writeOptions( StreamWriter &dat )
-{
-    char len = (char)name.getLength();
-    dat.schreibe( (char *)&len, 1 );
-    dat.schreibe( name, len );
-}
-
-
-TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
-    : Aktion( TRIGGER_AKTION, subActions )
+bool WennDannSonst::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	zPC->stepIn();
+	if (zPC->currentPosition() == 0)
+	{
+		bool finished = subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			Variable* ret = zReturn;
+			zPC->count();
+			if (!isTrue(ret))
+			{
+				zPC->count();
+				if (!subActions->z(2))
+				{
+					zPC->stepOut();
+					return 1;
+				}
+			}
+			else
+			{
+				if (!subActions->z(1))
+				{
+					zPC->stepOut();
+					return 1;
+				}
+			}
+		}
+	}
+	if (zPC->currentPosition() == 1 && waitCount <= 0)
+	{
+		bool finished = subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			zPC->stepOut();
+			return 1;
+		}
+	}
+	if (zPC->currentPosition() == 2 && waitCount <= 0)
+	{
+		bool finished = subActions->z(2)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			zPC->stepOut();
+			return 1;
+		}
+	}
+	zPC->stepOut();
+	return 0;
+}
+
+
+SetVariable::SetVariable(Text name, RCArray< Aktion >* subActions)
+	: Aktion(SET_VARIABLE, subActions)
+{
+	this->name = name;
+}
+
+void SetVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	if (zMemory->zVariable(name) || zEreignis->zParameter(name) || !zSpiel->zVariable(name))
+		zMemory->setVar(name, getParam(0));
+	else
+		zSpiel->setVariable(name, getParam(0));
+}
+
+void SetVariable::writeOptions(StreamWriter& dat)
+{
+	char len = (char)name.getLength();
+	dat.schreibe((char*)&len, 1);
+	dat.schreibe(name, len);
+}
+
+
+TriggerAktion::TriggerAktion(RCArray< Aktion >* subActions)
+	: Aktion(TRIGGER_AKTION, subActions)
 {}
 
-bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+bool TriggerAktion::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( subActions->z( 0 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zReturn;
-            if( !t || t->getVariableTyp() != INTEGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", dynamic_cast<Variable *>( t->getThis() ) );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( subActions->z( 1 )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zReturn;
-            if( !t || t->getVariableTyp() != TRIGGER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            int id = ( (Integer *)zParam( 0 ) )->getValue();
-            if( id >= ( (Trigger *)t )->getAktionAnzahl() )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", ( (Trigger *)t )->getAktion( id ) );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( ( (Aktion *)zParam( 0 ) )->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
+	zPC->stepIn();
+	if (zPC->currentPosition() == 0)
+	{
+		if (subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
+		{
+			Variable* t = zReturn;
+			if (!t || t->getVariableTyp() != INTEGER)
+			{
+				zPC->stepOut();
+				return 1;
+			}
+			zMemory->setVar(zPC->getUniqueString() + "R0__", dynamic_cast<Variable*>(t->getThis()));
+			zPC->count();
+		}
+	}
+	if (zPC->currentPosition() == 1 && waitCount <= 0)
+	{
+		if (subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
+		{
+			Variable* t = zReturn;
+			if (!t || t->getVariableTyp() != TRIGGER)
+			{
+				zPC->stepOut();
+				return 1;
+			}
+			int id = ((Integer*)zParam(0))->getValue();
+			if (id >= ((Trigger*)t)->getAktionAnzahl())
+			{
+				zPC->stepOut();
+				return 1;
+			}
+			zMemory->setVar(zPC->getUniqueString() + "R0__", ((Trigger*)t)->getAktion(id));
+			zPC->count();
+		}
+	}
+	if (zPC->currentPosition() == 2 && waitCount <= 0)
+	{
+		if (((Aktion*)zParam(0))->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount))
+		{
+			zPC->stepOut();
+			return 1;
+		}
+	}
+	zPC->stepOut();
+	return 0;
 }
 
 
-SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_NACHRICHT, subActions )
+SpielerNachricht::SpielerNachricht(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_NACHRICHT, subActions)
 {
-    erlaubteTypen.add( SPIELER );
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(SPIELER);
+	erlaubteTypen.add(STRING);
 }
 
-void SpielerNachricht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerNachricht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    // this is handeld on client side directly (no need to send the message to the player)
+	// this is handeld on client side directly (no need to send the message to the player)
 }
 
 
-DisplayText::DisplayText( RCArray< Aktion > *subActions )
-    : Aktion( DISPLAY_TEXT, subActions )
+DisplayText::DisplayText(RCArray< Aktion >* subActions)
+	: Aktion(DISPLAY_TEXT, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(STRING);
 }
 
-void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DisplayText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    // do nothing because the server does not need to show text
+	// do nothing because the server does not need to show text
 }
 
 
-SpielPause::SpielPause( RCArray< Aktion > *subActions )
-    : Aktion( SPIEL_PAUSE, subActions )
+SpielPause::SpielPause(RCArray< Aktion >* subActions)
+	: Aktion(SPIEL_PAUSE, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
+	erlaubteTypen.add(BOOLEAN);
 }
 
-void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    zSpiel->setPausiert( ( (Boolean *)zParam( 0 ) )->getValue() );
+	zSpiel->setPausiert(((Boolean*)zParam(0))->getValue());
 }
 
 
-SpielEnde::SpielEnde( RCArray< Aktion > *subActions )
-    : Aktion( SPIEL_ENDE, subActions )
+SpielEnde::SpielEnde(RCArray< Aktion >* subActions)
+	: Aktion(SPIEL_ENDE, subActions)
 {}
 
-void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielEnde::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Variable *t = zParam( 0 );
-    if( t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM )
-        t = 0;
-    zSpiel->setEnde( ( !t || t->getVariableTyp() == NICHTS ) ? 0 : (Team *)t );
+	Variable* t = zParam(0);
+	if (t->getVariableTyp() != NICHTS && t->getVariableTyp() != TEAM)
+		t = 0;
+	zSpiel->setEnde((!t || t->getVariableTyp() == NICHTS) ? 0 : (Team*)t);
 }
 
 
-SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_LEVEL, subActions )
+SpielerSetLevel::SpielerSetLevel(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_LEVEL, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue(), zSpiel );
+	((Spieler*)zParam(1))->setLevel(((Integer*)zParam(0))->getValue(), zSpiel);
 }
 
 
-SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_GIVE_ITEM, subActions )
+SpielerGiveItem::SpielerGiveItem(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_GIVE_ITEM, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(GEGENSTAND_TYP);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerGiveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 2 ) )->addItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
-                                         ( (Integer *)zParam( 1 ) )->getValue(), zSpiel );
+	((Spieler*)zParam(2))->addItem(((GegenstandTypVar*)zParam(0))->getValue(),
+		((Integer*)zParam(1))->getValue(), zSpiel);
 }
 
 
-SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_REMOVE_ITEM, subActions )
+SpielerRemoveItem::SpielerRemoveItem(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_REMOVE_ITEM, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(GEGENSTAND_TYP);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerRemoveItem::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 2 ) )->removeItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
-                                            ( (Integer *)zParam( 1 ) )->getValue() );
+	((Spieler*)zParam(2))->removeItem(((GegenstandTypVar*)zParam(0))->getValue(),
+		((Integer*)zParam(1))->getValue());
 }
 
 
-SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_LEBEN, subActions )
+SpielerSetLeben::SpielerSetLeben(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_LEBEN, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setLeben( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setLeben(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_LEBEN, subActions )
+SpielerSetMaxLeben::SpielerSetMaxLeben(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_LEBEN, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setMaxLeben( ( (Integer *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setMaxLeben(((Integer*)zParam(0))->getValue());
 }
 
 
-SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_ERFAHRUNG, subActions )
+SpielerSetErfahrung::SpielerSetErfahrung(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_ERFAHRUNG, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue(), zSpiel );
+	((Spieler*)zParam(1))->setErfahrung(((Float*)zParam(0))->getValue(), zSpiel);
 }
 
 
-SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_MAX_ERFAHRUNG, subActions )
+SpielerSetMaxErfahrung::SpielerSetMaxErfahrung(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_MAX_ERFAHRUNG, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setMaxErfahrung( ( (Integer *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setMaxErfahrung(((Integer*)zParam(0))->getValue());
 }
 
 
-SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_TEMPO, subActions )
+SpielerSetTempo::SpielerSetTempo(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_TEMPO, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setLaufTempo( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setLaufTempo(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_GESCHOSS_TEMPO, subActions )
+SpielerSetWaffenTempo::SpielerSetWaffenTempo(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_GESCHOSS_TEMPO, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetWaffenTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setGeschossTempo( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setGeschossTempo(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_ARMOR, subActions )
+SpielerSetArmor::SpielerSetArmor(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_ARMOR, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setArmor( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setArmor(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_SCHADEN_BONUS, subActions )
+SpielerSetSchadenBonus::SpielerSetSchadenBonus(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_SCHADEN_BONUS, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setSchadenBonus( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setSchadenBonus(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
+SpielerSetLebensraub::SpielerSetLebensraub(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_LEBENSRAUB, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setLebensRaub( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setLebensRaub(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_LEBENSRAUB, subActions )
+SpielerSetLebensregeneration::SpielerSetLebensregeneration(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_LEBENSRAUB, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setLebensRegeneration( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setLebensRegeneration(((Float*)zParam(0))->getValue());
 }
 
 
-SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions )
+SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_SET_ABKLINGZEITVERRINGERUNG, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(SPIELER);
 }
 
-void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerSetAbklingzeitverringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Spieler *)zParam( 1 ) )->setAbklingZeitVerringerung( ( (Float *)zParam( 0 ) )->getValue() );
+	((Spieler*)zParam(1))->setAbklingZeitVerringerung(((Float*)zParam(0))->getValue());
 }
 
 
-DropSetTime::DropSetTime( RCArray< Aktion > *subActions )
-    : Aktion( DROP_SET_TIME, subActions )
+DropSetTime::DropSetTime(RCArray< Aktion >* subActions)
+	: Aktion(DROP_SET_TIME, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(DROP);
 }
 
-void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropSetTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Drop *)zParam( 1 ) )->setTime( ( (Float *)zParam( 0 ) )->getValue() );
+	((Drop*)zParam(1))->setTime(((Float*)zParam(0))->getValue());
 }
 
 
-DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions )
-    : Aktion( DROP_SET_MAX_TIME, subActions )
+DropSetMaxTime::DropSetMaxTime(RCArray< Aktion >* subActions)
+	: Aktion(DROP_SET_MAX_TIME, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(DROP);
 }
 
-void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropSetMaxTime::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Drop *)zParam( 1 ) )->setMaxTime( ( (Integer *)zParam( 0 ) )->getValue() );
+	((Drop*)zParam(1))->setMaxTime(((Integer*)zParam(0))->getValue());
 }
 
 
-DropSetArea::DropSetArea( RCArray< Aktion > *subActions )
-    : Aktion( DROP_SET_AREA, subActions )
+DropSetArea::DropSetArea(RCArray< Aktion >* subActions)
+	: Aktion(DROP_SET_AREA, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(DROP);
 }
 
-void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropSetArea::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Drop *)zParam( 4 ) )->setMinX( ( (Integer *)zParam( 0 ) )->getValue() );
-    ( (Drop *)zParam( 4 ) )->setMaxX( ( (Integer *)zParam( 1 ) )->getValue() );
-    ( (Drop *)zParam( 4 ) )->setMinY( ( (Integer *)zParam( 2 ) )->getValue() );
-    ( (Drop *)zParam( 4 ) )->setMaxY( ( (Integer *)zParam( 3 ) )->getValue() );
+	((Drop*)zParam(4))->setMinX(((Integer*)zParam(0))->getValue());
+	((Drop*)zParam(4))->setMaxX(((Integer*)zParam(1))->getValue());
+	((Drop*)zParam(4))->setMinY(((Integer*)zParam(2))->getValue());
+	((Drop*)zParam(4))->setMaxY(((Integer*)zParam(3))->getValue());
 }
 
 
-DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions )
-    : Aktion( DROP_DO_DROP, subActions )
+DropDoDrop::DropDoDrop(RCArray< Aktion >* subActions)
+	: Aktion(DROP_DO_DROP, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropDoDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Drop *)zParam( 0 ) )->doDrop( zSpiel );
+	((Drop*)zParam(0))->doDrop(zSpiel);
 }
 
 
-BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions )
-    : Aktion( BARIERE_BEWEGUNG, subActions )
+BariereBewegung::BariereBewegung(RCArray< Aktion >* subActions)
+	: Aktion(BARIERE_BEWEGUNG, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereBewegung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bariere *)zParam( 0 ) )->startAutoVerschiebung( zSpiel );
+	((Bariere*)zParam(0))->startAutoVerschiebung(zSpiel);
 }
 
 
-BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions )
-    : Aktion( BARIERE_SET_EINGESCHALTET, subActions )
+BariereSetEingeschaltet::BariereSetEingeschaltet(RCArray< Aktion >* subActions)
+	: Aktion(BARIERE_SET_EINGESCHALTET, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(DROP);
 }
 
-void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereSetEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bariere *)zParam( 1 ) )->setStyle( Bariere::Style::Aktiv, ( (Boolean *)zParam( 0 ) )->getValue(), zSpiel );
+	((Bariere*)zParam(1))->setStyle(Bariere::Style::Aktiv, ((Boolean*)zParam(0))->getValue(), zSpiel);
 }
 
 
-GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions )
-    : Aktion( GAME_OBJEKT_SET_POSITION, subActions )
+GameObjektSetPosition::GameObjektSetPosition(RCArray< Aktion >* subActions)
+	: Aktion(GAME_OBJEKT_SET_POSITION, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GameObjektSetPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (GameObject *)zParam( 2 ) )->setX( ( (Float *)zParam( 0 ) )->getValue() );
-    ( (GameObject *)zParam( 2 ) )->setY( ( (Float *)zParam( 1 ) )->getValue() );
+	((GameObject*)zParam(2))->setX(((Float*)zParam(0))->getValue());
+	((GameObject*)zParam(2))->setY(((Float*)zParam(1))->getValue());
 }
 
 
-GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions )
-    : Aktion( GAME_OBJEKT_SET_SIZE, subActions )
+GameObjektSetSize::GameObjektSetSize(RCArray< Aktion >* subActions)
+	: Aktion(GAME_OBJEKT_SET_SIZE, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GameObjektSetSize::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (GameObject *)zParam( 2 ) )->setWidth( ( (Float *)zParam( 0 ) )->getValue() );
-    ( (GameObject *)zParam( 2 ) )->setHeight( ( (Float *)zParam( 1 ) )->getValue() );
+	((GameObject*)zParam(2))->setWidth(((Float*)zParam(0))->getValue());
+	((GameObject*)zParam(2))->setHeight(((Float*)zParam(1))->getValue());
 }
 
 
-BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions )
-    : Aktion( BARIERE_SET_TEAM, subActions )
+BariereSetTeam::BariereSetTeam(RCArray< Aktion >* subActions)
+	: Aktion(BARIERE_SET_TEAM, subActions)
 {
-    erlaubteTypen.add( TEAM );
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(TEAM);
+	erlaubteTypen.add(BARIERE);
 }
 
-void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bariere *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ) );
+	((Bariere*)zParam(1))->setTeam(((Team*)getParam(0)));
 }
 
 
-SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions )
-    : Aktion( SCHALTER_SET_ERLAUBT, subActions )
+SchalterSetErlaubt::SchalterSetErlaubt(RCArray< Aktion >* subActions)
+	: Aktion(SCHALTER_SET_ERLAUBT, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( SCHALTER );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(SCHALTER);
 }
 
-void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SchalterSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Schalter *)zParam( 1 ) )->setAktive( ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Schalter*)zParam(1))->setAktive(((Boolean*)zParam(0))->getValue());
 }
 
 
-SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions )
-    : Aktion( SCHALTER_AKTIVIEREN, subActions )
+SchalterAktivieren::SchalterAktivieren(RCArray< Aktion >* subActions)
+	: Aktion(SCHALTER_AKTIVIEREN, subActions)
 {
-    erlaubteTypen.add( SCHALTER );
+	erlaubteTypen.add(SCHALTER);
 }
 
-void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SchalterAktivieren::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    zSpiel->activateShalter( ( (Schalter *)zParam( 0 ) )->getId() );
+	zSpiel->activateShalter(((Schalter*)zParam(0))->getId());
 }
 
 
-TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions )
-    : Aktion( TUNNEL_SET_ZIEL_POSITION, subActions )
+TunnelSetZielPosition::TunnelSetZielPosition(RCArray< Aktion >* subActions)
+	: Aktion(TUNNEL_SET_ZIEL_POSITION, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(TUNNEL);
 }
 
-void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TunnelSetZielPosition::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Tunnel *)zParam( 2 ) )->setZielX( ( (Integer *)zParam( 0 ) )->getValue() );
-    ( (Tunnel *)zParam( 2 ) )->setZielY( ( (Integer *)zParam( 1 ) )->getValue() );
+	((Tunnel*)zParam(2))->setZielX(((Integer*)zParam(0))->getValue());
+	((Tunnel*)zParam(2))->setZielY(((Integer*)zParam(1))->getValue());
 }
 
 
-TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions )
-    : Aktion( TUNNEL_SET_ERLAUBT, subActions )
+TunnelSetErlaubt::TunnelSetErlaubt(RCArray< Aktion >* subActions)
+	: Aktion(TUNNEL_SET_ERLAUBT, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(TUNNEL);
 }
 
-void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TunnelSetErlaubt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Tunnel *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Tunnel*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
 }
 
 
-UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions )
-    : Aktion( UMLENKUNG_SET_RICHTUNG, subActions )
+UmlenkungSetRichtung::UmlenkungSetRichtung(RCArray< Aktion >* subActions)
+	: Aktion(UMLENKUNG_SET_RICHTUNG, subActions)
 {
-    erlaubteTypen.add( RICHTUNG );
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(RICHTUNG);
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void UmlenkungSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Umlenkung *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
+	((Umlenkung*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
 }
 
 
-UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions )
-    : Aktion( UMLENKUNG_SET_MAX_ABK, subActions )
+UmlenkungSetMaxAbk::UmlenkungSetMaxAbk(RCArray< Aktion >* subActions)
+	: Aktion(UMLENKUNG_SET_MAX_ABK, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void UmlenkungSetMaxAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Umlenkung *)zParam( 1 ) )->setMaxAbklingzeit( ( (Integer *)zParam( 0 ) )->getValue() );
+	((Umlenkung*)zParam(1))->setMaxAbklingzeit(((Integer*)zParam(0))->getValue());
 }
 
 
-UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions )
-    : Aktion( UMLENKUNG_SET_ERLAUBT, subActions )
+UmlenkungSetEnabled::UmlenkungSetEnabled(RCArray< Aktion >* subActions)
+	: Aktion(UMLENKUNG_SET_ERLAUBT, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void UmlenkungSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Umlenkung *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Umlenkung*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
 }
 
 
-BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
-    : Aktion( BASE_SET_TEAM, subActions )
+BaseSetTeam::BaseSetTeam(RCArray< Aktion >* subActions)
+	: Aktion(BASE_SET_TEAM, subActions)
 {
-    erlaubteTypen.add( TEAM );
-    erlaubteTypen.add( BASE );
+	erlaubteTypen.add(TEAM);
+	erlaubteTypen.add(BASE);
 }
 
-void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseSetTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)getParam( 0 ) ), zSpiel );
+	((Base*)zParam(1))->setTeam(((Team*)getParam(0)), zSpiel);
 }
 
 
-BaseStartTeamChange::BaseStartTeamChange( RCArray< Aktion > *subActions )
-    : Aktion( BASE_START_TEAM_CHANGE, subActions )
+BaseStartTeamChange::BaseStartTeamChange(RCArray< Aktion >* subActions)
+	: Aktion(BASE_START_TEAM_CHANGE, subActions)
 {
-    erlaubteTypen.add( TEAM );
-    erlaubteTypen.add( BASE );
+	erlaubteTypen.add(TEAM);
+	erlaubteTypen.add(BASE);
 }
 
-void BaseStartTeamChange::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseStartTeamChange::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Base *)zParam( 1 ) )->startChange( ( (Team *)getParam( 0 ) ) );
+	((Base*)zParam(1))->startChange(((Team*)getParam(0)));
 }
 
 
-TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
-    : Aktion( TRIGGER_RUN_START, subActions )
+TriggerRunStart::TriggerRunStart(RCArray< Aktion >* subActions)
+	: Aktion(TRIGGER_RUN_START, subActions)
 {
-    erlaubteTypen.add( TRIGGER );
+	erlaubteTypen.add(TRIGGER);
 }
 
-void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerRunStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    zSpiel->addTriggerRun( ( (Trigger *)zParam( 0 ) )->runTrigger( dynamic_cast<Ereignis *>( zEreignis->getThis() ), zSpiel ) );
+	zSpiel->addTriggerRun(((Trigger*)zParam(0))->runTrigger(dynamic_cast<Ereignis*>(zEreignis->getThis()), zSpiel));
 }
 
 
-TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions )
-    : Aktion( TRIGGER_SET_ENABLED, subActions )
+TriggerSetEnabled::TriggerSetEnabled(RCArray< Aktion >* subActions)
+	: Aktion(TRIGGER_SET_ENABLED, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( TRIGGER );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(TRIGGER);
 }
 
-void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerSetEnabled::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Trigger *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Trigger*)zParam(1))->setAktiv(((Boolean*)zParam(0))->getValue());
 }
 
 
-TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions )
-    : Aktion( TEAM_SET_PUNKTE, subActions )
+TeamSetPunkte::TeamSetPunkte(RCArray< Aktion >* subActions)
+	: Aktion(TEAM_SET_PUNKTE, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(TEAM);
 }
 
-void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamSetPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Team *)zParam( 1 ) )->setPunkte( ( (Integer *)zParam( 0 ) )->getValue() );
+	((Team*)zParam(1))->setPunkte(((Integer*)zParam(0))->getValue());
 }
 
 
-TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
-    : Aktion( TIMER_SET_PAUSE, subActions )
+TimerSetPause::TimerSetPause(RCArray< Aktion >* subActions)
+	: Aktion(TIMER_SET_PAUSE, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(TIMER);
 }
 
-void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerSetPause::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Timer *)zParam( 1 ) )->setPause( zSpiel, ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Timer*)zParam(1))->setPause(zSpiel, ((Boolean*)zParam(0))->getValue());
 }
 
 
-TimerStart::TimerStart( RCArray< Aktion > *subActions )
-    : Aktion( TIMER_START, subActions )
+TimerStart::TimerStart(RCArray< Aktion >* subActions)
+	: Aktion(TIMER_START, subActions)
 {
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(TIMER);
 }
 
-void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerStart::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Timer *)zParam( 0 ) )->start( zSpiel );
+	((Timer*)zParam(0))->start(zSpiel);
 }
 
 
-TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions )
-    : Aktion( TIMER_SET_ZEIT, subActions )
+TimerSetZeit::TimerSetZeit(RCArray< Aktion >* subActions)
+	: Aktion(TIMER_SET_ZEIT, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(TIMER);
 }
 
-void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerSetZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Timer *)zParam( 1 ) )->setZeit( ( (Float *)zParam( 0 ) )->getValue() );
+	((Timer*)zParam(1))->setZeit(((Float*)zParam(0))->getValue());
 }
 
 
-TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions )
-    : Aktion( TIMER_SET_SICHTBAR, subActions )
+TimerSetSichtbar::TimerSetSichtbar(RCArray< Aktion >* subActions)
+	: Aktion(TIMER_SET_SICHTBAR, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(BOOLEAN);
+	erlaubteTypen.add(TIMER);
 }
 
-void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerSetSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Timer *)zParam( 1 ) )->setSichtbar( ( (Boolean *)zParam( 0 ) )->getValue() );
+	((Timer*)zParam(1))->setSichtbar(((Boolean*)zParam(0))->getValue());
 }
 
 
-GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions )
-    : Aktion( GESCHOSS_NEU, subActions )
+GeschossNeu::GeschossNeu(RCArray< Aktion >* subActions)
+	: Aktion(GESCHOSS_NEU, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( GESCHOSS_TYP );
-    erlaubteTypen.add( RICHTUNG );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(GESCHOSS_TYP);
+	erlaubteTypen.add(RICHTUNG);
 }
 
-void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Geschoss *g = new Geschoss( zSpiel->zResources(), zSpiel->getNextId(), 0,
-                                getGeschossTypFromString( ( (String *)zParam( 2 ) )->getValue() ),
-                                getRichtungFromString( ( (String *)zParam( 3 ) )->getValue() ),
-                                ( (Integer *)zParam( 0 ) )->getValue(),
-                                ( (Integer *)zParam( 1 ) )->getValue(), 0 );
-    zSpiel->addGeschoss( dynamic_cast<Geschoss *>( g->getThis() ) );
-    setReturn( g );
+	Geschoss* g = new Geschoss(zSpiel->zResources(), zSpiel->getNextId(), 0,
+		getGeschossTypFromString(((String*)zParam(2))->getValue()),
+		getRichtungFromString(((String*)zParam(3))->getValue()),
+		((Integer*)zParam(0))->getValue(),
+		((Integer*)zParam(1))->getValue(), 0);
+	zSpiel->addGeschoss(dynamic_cast<Geschoss*>(g->getThis()));
+	setReturn(g);
 }
 
 
-GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions )
-    : Aktion( GESCHOSS_SET_SPEED, subActions )
+GeschossSetSpeed::GeschossSetSpeed(RCArray< Aktion >* subActions)
+	: Aktion(GESCHOSS_SET_SPEED, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( GESCHOSS );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(GESCHOSS);
 }
 
-void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossSetSpeed::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Geschoss *)zParam( 1 ) )->setSpeed( ( (Float *)zParam( 0 ) )->getValue() );
+	((Geschoss*)zParam(1))->setSpeed(((Float*)zParam(0))->getValue());
 }
 
 
-GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions )
-    : Aktion( GESCHOSS_SET_PLAYER, subActions )
+GeschossSetPlayer::GeschossSetPlayer(RCArray< Aktion >* subActions)
+	: Aktion(GESCHOSS_SET_PLAYER, subActions)
 {
-    erlaubteTypen.add( SPIELER );
-    erlaubteTypen.add( GESCHOSS );
+	erlaubteTypen.add(SPIELER);
+	erlaubteTypen.add(GESCHOSS);
 }
 
-void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossSetPlayer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Geschoss *)zParam( 1 ) )->setBesitzer( ( (Spieler *)getParam( 0 ) ) );
+	((Geschoss*)zParam(1))->setBesitzer(((Spieler*)getParam(0)));
 }
 
 
-GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions )
-    : Aktion( GESCHOSS_SET_RICHTUNG, subActions )
+GeschossSetRichtung::GeschossSetRichtung(RCArray< Aktion >* subActions)
+	: Aktion(GESCHOSS_SET_RICHTUNG, subActions)
 {
-    erlaubteTypen.add( RICHTUNG );
-    erlaubteTypen.add( GESCHOSS );
+	erlaubteTypen.add(RICHTUNG);
+	erlaubteTypen.add(GESCHOSS);
 }
 
-void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossSetRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Geschoss *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
+	((Geschoss*)zParam(1))->setRichtung(getRichtungFromString(((String*)zParam(0))->getValue()));
 }
 
 
-GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions )
-    : Aktion( GESCHOSS_SET_TYPE, subActions )
+GeschossSetType::GeschossSetType(RCArray< Aktion >* subActions)
+	: Aktion(GESCHOSS_SET_TYPE, subActions)
 {
-    erlaubteTypen.add( GESCHOSS_TYP );
-    erlaubteTypen.add( GESCHOSS );
+	erlaubteTypen.add(GESCHOSS_TYP);
+	erlaubteTypen.add(GESCHOSS);
 }
 
-void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossSetType::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Geschoss *)zParam( 1 ) )->setTyp( getGeschossTypFromString( ( (String *)zParam( 0 ) )->getValue() ) );
+	((Geschoss*)zParam(1))->setTyp(getGeschossTypFromString(((String*)zParam(0))->getValue()));
 }
 
 
 TriggerZufall::TriggerZufall()
-    : Aktion( TRIGGER_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(TRIGGER_ZUFALL, new RCArray< Aktion >())
 {}
 
-void TriggerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomTrigger() );
+	setReturn(zSpiel->getRandomTrigger());
 }
 
 
 TriggerLastRunned::TriggerLastRunned()
-    : Aktion( TRIGGER_LAST_RUNNED, new RCArray< Aktion >() )
+	: Aktion(TRIGGER_LAST_RUNNED, new RCArray< Aktion >())
 {}
 
-void TriggerLastRunned::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TriggerLastRunned::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getLastRunnedTrigger() );
+	setReturn(zSpiel->getLastRunnedTrigger());
 }
 
 
 BariereZufall::BariereZufall()
-    : Aktion( BARIERE_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(BARIERE_ZUFALL, new RCArray< Aktion >())
 {}
 
-void BariereZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomBariere() );
+	setReturn(zSpiel->getRandomBariere());
 }
 
 
 BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
-    : Aktion( BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >() )
+	: Aktion(BARIERE_ZULETZT_EINGESCHALTET, new RCArray< Aktion >())
 {}
 
-void BariereZuletztEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztEingeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getZuletztEingeschalteteBariere() );
+	setReturn(zSpiel->getZuletztEingeschalteteBariere());
 }
 
 
 BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
-    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >() )
+	: Aktion(BARIERE_ZULETZT_AUSGESCHALTET, new RCArray< Aktion >())
 {}
 
-void BariereZuletztAusgeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztAusgeschaltet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getZuletztAusgeschalteteBariere() );
+	setReturn(zSpiel->getZuletztAusgeschalteteBariere());
 }
 
 
 BariereZuletztBewegt::BariereZuletztBewegt()
-    : Aktion( BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >() )
+	: Aktion(BARIERE_ZULETZT_BEWEGT, new RCArray< Aktion >())
 {}
 
-void BariereZuletztBewegt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BariereZuletztBewegt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getZuletztBewegteBariere() );
+	setReturn(zSpiel->getZuletztBewegteBariere());
 }
 
 
 BaseZufall::BaseZufall()
-    : Aktion( BASE_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(BASE_ZUFALL, new RCArray< Aktion >())
 {}
 
-void BaseZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomBase() );
+	setReturn(zSpiel->getRandomBase());
 }
 
 
 BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
-    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >() )
+	: Aktion(BASE_ZULETZT_BESITZER_GEWECHSELT, new RCArray< Aktion >())
 {}
 
-void BaseZuletztBesitzerGewechselt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseZuletztBesitzerGewechselt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getLastTeamChangedBase() );
+	setReturn(zSpiel->getLastTeamChangedBase());
 }
 
 
 DropZufall::DropZufall()
-    : Aktion( DROP_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(DROP_ZUFALL, new RCArray< Aktion >())
 {}
 
-void DropZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void DropZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomDrop() );
+	setReturn(zSpiel->getRandomDrop());
 }
 
 
 DropZuletztGedropt::DropZuletztGedropt()
-    : Aktion( DROP_ZULETZT_GEDROPT, new RCArray< Aktion >() )
+	: Aktion(DROP_ZULETZT_GEDROPT, new RCArray< Aktion >())
 {}
 
-void DropZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    setReturn( zSpiel->getLastDrop() );
-}
-
-
-IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op )
-    : Aktion( INTEGER_RECHNEN, subActions ),
-    op()
-{
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-}
-
-void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    Integer *l = (Integer *)zParam( 0 );
-    Integer *r = (Integer *)zParam( 1 );
-    switch( op )
-    {
-    case PLUS:
-        setReturn( new Integer( l->getValue() + r->getValue() ) );
-        break;
-    case MINUS:
-        setReturn( new Integer( l->getValue() - r->getValue() ) );
-        break;
-    case MAHL:
-        setReturn( new Integer( l->getValue() * r->getValue() ) );
-        break;
-    case GETEILT:
-        setReturn( new Integer( l->getValue() / r->getValue() ) );
-        break;
-    case HOCH:
-        setReturn( new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
-        break;
-    case WURZEL:
-        setReturn( new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
-        break;
-    case BIT_ODER:
-        setReturn( new Integer( l->getValue() | r->getValue() ) );
-        break;
-    case BIT_UND:
-        setReturn( new Integer( l->getValue() & r->getValue() ) );
-        break;
-    case BIT_XOR:
-        setReturn( new Integer( l->getValue() ^ r->getValue() ) );
-        break;
-    case BIT_FLIP:
-        setReturn( new Integer( ~l->getValue() ) );
-        break;
-    case BIT_SHIFT_LEFT:
-        setReturn( new Integer( l->getValue() << r->getValue() ) );
-        break;
-    case BIT_SHIFT_RIGHT:
-        setReturn( new Integer( l->getValue() >> r->getValue() ) );
-        break;
-    case INVERT_SIGN:
-        setReturn( new Integer( -l->getValue() ) );
-        break;
-    case PLUS_PLUS_LEFT:
-        l->setValue( l->getValue() + 1 );
-        setReturn( new Integer( l->getValue() ) );
-        break;
-    case PLUS_PLUS_RIGHT:
-    {
-        int tmp = l->getValue();
-        l->setValue( l->getValue() + 1 );
-        setReturn( new Integer( tmp ) );
-        break;
-    }
-    case MINUS_MINUS_LEFT:
-        l->setValue( l->getValue() - 1 );
-        setReturn( new Integer( l->getValue() ) );
-        break;
-    case MINUS_MINUS_RIGHT:
-    {
-        int tmp = l->getValue();
-        l->setValue( l->getValue() - 1 );
-        setReturn( new Integer( tmp ) );
-        break;
-    }
-    case LOGARITHM:
-        setReturn( new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
-        break;
-    case MODULO:
-        setReturn( new Integer( l->getValue() % r->getValue() ) );
-        break;
-    default:
-        break;
-    }
+void DropZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	setReturn(zSpiel->getLastDrop());
+}
+
+
+IntegerRechnen::IntegerRechnen(RCArray< Aktion >* subActions, Operator op)
+	: Aktion(INTEGER_RECHNEN, subActions),
+	op()
+{
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+}
+
+void IntegerRechnen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	Integer* l = (Integer*)zParam(0);
+	Integer* r = (Integer*)zParam(1);
+	switch (op)
+	{
+	case PLUS:
+		setReturn(new Integer(l->getValue() + r->getValue()));
+		break;
+	case MINUS:
+		setReturn(new Integer(l->getValue() - r->getValue()));
+		break;
+	case MAHL:
+		setReturn(new Integer(l->getValue() * r->getValue()));
+		break;
+	case GETEILT:
+		setReturn(new Integer(l->getValue() / r->getValue()));
+		break;
+	case HOCH:
+		setReturn(new Integer((int)pow(l->getValue(), r->getValue())));
+		break;
+	case WURZEL:
+		setReturn(new Integer((int)pow(l->getValue(), 1.0 / r->getValue())));
+		break;
+	case BIT_ODER:
+		setReturn(new Integer(l->getValue() | r->getValue()));
+		break;
+	case BIT_UND:
+		setReturn(new Integer(l->getValue() & r->getValue()));
+		break;
+	case BIT_XOR:
+		setReturn(new Integer(l->getValue() ^ r->getValue()));
+		break;
+	case BIT_FLIP:
+		setReturn(new Integer(~l->getValue()));
+		break;
+	case BIT_SHIFT_LEFT:
+		setReturn(new Integer(l->getValue() << r->getValue()));
+		break;
+	case BIT_SHIFT_RIGHT:
+		setReturn(new Integer(l->getValue() >> r->getValue()));
+		break;
+	case INVERT_SIGN:
+		setReturn(new Integer(-l->getValue()));
+		break;
+	case PLUS_PLUS_LEFT:
+		l->setValue(l->getValue() + 1);
+		setReturn(new Integer(l->getValue()));
+		break;
+	case PLUS_PLUS_RIGHT:
+	{
+		int tmp = l->getValue();
+		l->setValue(l->getValue() + 1);
+		setReturn(new Integer(tmp));
+		break;
+	}
+	case MINUS_MINUS_LEFT:
+		l->setValue(l->getValue() - 1);
+		setReturn(new Integer(l->getValue()));
+		break;
+	case MINUS_MINUS_RIGHT:
+	{
+		int tmp = l->getValue();
+		l->setValue(l->getValue() - 1);
+		setReturn(new Integer(tmp));
+		break;
+	}
+	case LOGARITHM:
+		setReturn(new Integer((int)(log(l->getValue()) / log(r->getValue()))));
+		break;
+	case MODULO:
+		setReturn(new Integer(l->getValue() % r->getValue()));
+		break;
+	default:
+		break;
+	}
 }
 
-void IntegerRechnen::writeOptions( StreamWriter &dat )
+void IntegerRechnen::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&this->op, 1 );
+	dat.schreibe((char*)&this->op, 1);
 }
 
 
-IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_ZUFALL, subActions )
+IntegerZufall::IntegerZufall(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_ZUFALL, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
 }
 
-void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    int mi = ( (Integer *)zParam( 0 ) )->getValue();
-    int ma = ( (Integer *)zParam( 1 ) )->getValue();
-    setReturn( new Integer( (int)( zSpiel->getRand() * ( (double)ma - mi ) + mi ) ) );
+	int mi = ((Integer*)zParam(0))->getValue();
+	int ma = ((Integer*)zParam(1))->getValue();
+	setReturn(new Integer((int)(zSpiel->getRand() * ((double)ma - mi) + mi)));
 }
 
 
-IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_AUS_TEXT, subActions )
+IntegerAusText::IntegerAusText(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_AUS_TEXT, subActions)
 {
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(STRING);
 }
 
-void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (String *)zParam( 0 ) )->getValue() ) );
+	setReturn(new Integer((int)((String*)zParam(0))->getValue()));
 }
 
 
-FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_X_VON_GAME_OBJEKT, subActions )
+FloatXVonGameObjekt::FloatXVonGameObjekt(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_X_VON_GAME_OBJEKT, subActions)
 {
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatXVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getX() ) );
+	setReturn(new Float(((GameObject*)zParam(0))->getX()));
 }
 
 
-FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_Y_VON_GAME_OBJEKT, subActions )
+FloatYVonGameObjekt::FloatYVonGameObjekt(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_Y_VON_GAME_OBJEKT, subActions)
 {
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatYVonGameObjekt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getY() ) );
+	setReturn(new Float(((GameObject*)zParam(0))->getY()));
 }
 
 
-IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_X_VON_TUNNEL_ZIEL, subActions )
+IntegerXVonTunnelZiel::IntegerXVonTunnelZiel(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_X_VON_TUNNEL_ZIEL, subActions)
 {
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(TUNNEL);
 }
 
-void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerXVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielX() ) );
+	setReturn(new Integer(((Tunnel*)zParam(0))->getZielX()));
 }
 
 
-IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL, subActions )
+IntegerYVonTunnelZiel::IntegerYVonTunnelZiel(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_Y_VON_TUNNEL_ZIEL, subActions)
 {
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(TUNNEL);
 }
 
-void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerYVonTunnelZiel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielY() ) );
+	setReturn(new Integer(((Tunnel*)zParam(0))->getZielY()));
 }
 
 
-IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_MIN_X_VON_DROP, subActions )
+IntegerMinXVonDrop::IntegerMinXVonDrop(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_MIN_X_VON_DROP, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMinXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinX() ) );
+	setReturn(new Integer(((Drop*)zParam(0))->getMinX()));
 }
 
 
-IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_MIN_Y_VON_DROP, subActions )
+IntegerMinYVonDrop::IntegerMinYVonDrop(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_MIN_Y_VON_DROP, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMinYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinY() ) );
+	setReturn(new Integer(((Drop*)zParam(0))->getMinY()));
 }
 
 
-IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_MAX_X_VON_DROP, subActions )
+IntegerMaxXVonDrop::IntegerMaxXVonDrop(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_MAX_X_VON_DROP, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMaxXVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxX() ) );
+	setReturn(new Integer(((Drop*)zParam(0))->getMaxX()));
 }
 
 
-IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_MAX_Y_VON_DROP, subActions )
+IntegerMaxYVonDrop::IntegerMaxYVonDrop(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_MAX_Y_VON_DROP, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerMaxYVonDrop::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxY() ) );
+	setReturn(new Integer(((Drop*)zParam(0))->getMaxY()));
 }
 
 
-IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_SPIELER_LEVEL, subActions )
+IntegerSpielerLevel::IntegerSpielerLevel(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_SPIELER_LEVEL, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerLevel::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getLevel() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getLevel()));
 }
 
 
-FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_SPIELER_LEBEN, subActions )
+FloatSpielerLeben::FloatSpielerLeben(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_SPIELER_LEBEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLeben() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getLeben()));
 }
 
-bool isBinary( Operator op )
+bool isBinary(Operator op)
 {
-    return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
-        op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
+	return op != BIT_FLIP && op != INVERT_SIGN && op != PLUS_PLUS_LEFT && op != PLUS_PLUS_RIGHT &&
+		op != MINUS_MINUS_LEFT && op != MINUS_MINUS_RIGHT && op != INVERT_BOOL;
 }
 
 
-IntegerSpielerMaxLeben::IntegerSpielerMaxLeben( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_MAX_LEBEN, subActions )
+IntegerSpielerMaxLeben::IntegerSpielerMaxLeben(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_MAX_LEBEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerMaxLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxLeben() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getMaxLeben()));
 }
 
 
-FloatSpielerErfahrung::FloatSpielerErfahrung( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_ERFAHRUNG, subActions )
+FloatSpielerErfahrung::FloatSpielerErfahrung(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_ERFAHRUNG, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErfahrung() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getErfahrung()));
 }
 
 
-IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_MAX_ERFAHRUNG, subActions )
+IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_MAX_ERFAHRUNG, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerMaxErfahrung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxErfahrung() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getMaxErfahrung()));
 }
 
 
-FloatSpielerTempo::FloatSpielerTempo( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_TEMPO, subActions )
+FloatSpielerTempo::FloatSpielerTempo(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_TEMPO, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLaufTempo() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getLaufTempo()));
 }
 
 
-FloatSpielerGeschossTempo::FloatSpielerGeschossTempo( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_GESCHOSS_TEMPO, subActions )
+FloatSpielerGeschossTempo::FloatSpielerGeschossTempo(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_GESCHOSS_TEMPO, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerGeschossTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerGeschossTempo::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeschossTempo() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getGeschossTempo()));
 }
 
 
-FloatSpielerArmor::FloatSpielerArmor( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_ARMOR, subActions )
+FloatSpielerArmor::FloatSpielerArmor(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_ARMOR, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerArmor::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getArmor() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getArmor()));
 }
 
 
-FloatSpielerSchadenBonus::FloatSpielerSchadenBonus( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_SCHADEN_BONUS, subActions )
+FloatSpielerSchadenBonus::FloatSpielerSchadenBonus(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_SCHADEN_BONUS, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerSchadenBonus::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getSchadenBonus() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getSchadenBonus()));
 }
 
 
-FloatSpielerLebensraub::FloatSpielerLebensraub( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_LEBENSRAUB, subActions )
+FloatSpielerLebensraub::FloatSpielerLebensraub(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_LEBENSRAUB, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerLebensraub::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRaub() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getLebensRaub()));
 }
 
 
-FloatSpielerLebensregeneration::FloatSpielerLebensregeneration( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_LEBENSREGENERATION, subActions )
+FloatSpielerLebensregeneration::FloatSpielerLebensregeneration(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_LEBENSREGENERATION, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerLebensregeneration::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRegenneration() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getLebensRegenneration()));
 }
 
 
-FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions )
+FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerAbklingzeitVerringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerAbklingzeitVerringerung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getAbklingZeitVerringerung() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getAbklingZeitVerringerung()));
 }
 
 
-IntegerSpielerTode::IntegerSpielerTode( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_TODE, subActions )
+IntegerSpielerTode::IntegerSpielerTode(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_TODE, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTode() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getTode()));
 }
 
 
-IntegerSpielerKills::IntegerSpielerKills( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_KILLS, subActions )
+IntegerSpielerKills::IntegerSpielerKills(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_KILLS, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getKills() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getKills()));
 }
 
 
-IntegerSpielerTreffer::IntegerSpielerTreffer( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
+IntegerSpielerTreffer::IntegerSpielerTreffer(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_TREFFER, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerTreffer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerTreffer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTreffer() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getTreffer()));
 }
 
 
-IntegerSpielerGetroffen::IntegerSpielerGetroffen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
+IntegerSpielerGetroffen::IntegerSpielerGetroffen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_TREFFER, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGetroffen() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getGetroffen()));
 }
 
 
-FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
+FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerErlittenerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerErlittenerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErlittenerSchaden() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getErlittenerSchaden()));
 }
 
 
-FloatSpielerSchaden::FloatSpielerSchaden( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
+FloatSpielerSchaden::FloatSpielerSchaden(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerSchaden::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGemachterSchaden() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getGemachterSchaden()));
 }
 
 
-FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_SPIELER_GEHEILTES_LEBEN, subActions )
+FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_SPIELER_GEHEILTES_LEBEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void FloatSpielerGeheiltesLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatSpielerGeheiltesLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeheiltesLeben() ) );
+	setReturn(new Float(((Spieler*)zParam(0))->getGeheiltesLeben()));
 }
 
 
-IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions )
+IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerItemsAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerItemsAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsAufgehoben() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getItemsAufgehoben()));
 }
 
 
-IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_ITEMS_VERWENDET, subActions )
+IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_ITEMS_VERWENDET, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerItemsVerwendet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerItemsVerwendet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsVerwendet() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getItemsVerwendet()));
 }
 
 
-IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions )
+IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerItemsInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerItemsInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsInInventory() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getItemsInInventory()));
 }
 
 
-IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions )
+IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(GEGENSTAND_TYP);
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerItemsTypeInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerItemsTypeInInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
+	setReturn(new Integer(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue())));
 }
 
 
-IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_TUNNEL_BENUTZT, subActions )
+IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_TUNNEL_BENUTZT, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTunnelBenutzt() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getTunnelBenutzt()));
 }
 
 
-IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions )
+IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getSchalterAktiviert() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getSchalterAktiviert()));
 }
 
 
-IntegerSpielerGeschossen::IntegerSpielerGeschossen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SPIELER_GESCHOSSEN, subActions )
+IntegerSpielerGeschossen::IntegerSpielerGeschossen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SPIELER_GESCHOSSEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void IntegerSpielerGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSpielerGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGeschossen() ) );
+	setReturn(new Integer(((Spieler*)zParam(0))->getGeschossen()));
 }
 
 
-FloatDropZeit::FloatDropZeit( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_DROP_ZEIT, subActions )
+FloatDropZeit::FloatDropZeit(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_DROP_ZEIT, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void FloatDropZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatDropZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Drop *)zParam( 0 ) )->getZeit() ) );
+	setReturn(new Float(((Drop*)zParam(0))->getZeit()));
 }
 
 
-IntegerDropMaxZeit::IntegerDropMaxZeit( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_DROP_MAX_ZEIT, subActions )
+IntegerDropMaxZeit::IntegerDropMaxZeit(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_DROP_MAX_ZEIT, subActions)
 {
-    erlaubteTypen.add( DROP );
+	erlaubteTypen.add(DROP);
 }
 
-void IntegerDropMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerDropMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxTime() ) );
+	setReturn(new Integer(((Drop*)zParam(0))->getMaxTime()));
 }
 
 
-FloatGameObjektBreite::FloatGameObjektBreite( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_GAME_OBJEKT_BREITE, subActions )
+FloatGameObjektBreite::FloatGameObjektBreite(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_GAME_OBJEKT_BREITE, subActions)
 {
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void FloatGameObjektBreite::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatGameObjektBreite::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getWidth() ) );
+	setReturn(new Float(((GameObject*)zParam(0))->getWidth()));
 }
 
 
-FloatGameObjektHeight::FloatGameObjektHeight( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_GAME_OBJEKT_HEIGHT, subActions )
+FloatGameObjektHeight::FloatGameObjektHeight(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_GAME_OBJEKT_HEIGHT, subActions)
 {
-    erlaubteTypen.add( GAME_OBJEKT );
+	erlaubteTypen.add(GAME_OBJEKT);
 }
 
-void FloatGameObjektHeight::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatGameObjektHeight::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getHeight() ) );
+	setReturn(new Float(((GameObject*)zParam(0))->getHeight()));
 }
 
 
-IntegerBariereVerschiebungen::IntegerBariereVerschiebungen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_BARIERE_VERSCHIEBUNGEN, subActions )
+IntegerBariereVerschiebungen::IntegerBariereVerschiebungen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_BARIERE_VERSCHIEBUNGEN, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void IntegerBariereVerschiebungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerBariereVerschiebungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getVerschiebungAnzahl() ) );
+	setReturn(new Integer(((Bariere*)zParam(0))->getVerschiebungAnzahl()));
 }
 
 
-IntegerBariereSchaltungen::IntegerBariereSchaltungen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_BARIERE_SCHALTUNGEN, subActions )
+IntegerBariereSchaltungen::IntegerBariereSchaltungen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_BARIERE_SCHALTUNGEN, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void IntegerBariereSchaltungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerBariereSchaltungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getSchaltungAnzahl() ) );
+	setReturn(new Integer(((Bariere*)zParam(0))->getSchaltungAnzahl()));
 }
 
 
-IntegerSchalterAktivierungen::IntegerSchalterAktivierungen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_SCHALTER_AKTIVIERUNGEN, subActions )
+IntegerSchalterAktivierungen::IntegerSchalterAktivierungen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_SCHALTER_AKTIVIERUNGEN, subActions)
 {
-    erlaubteTypen.add( SCHALTER );
+	erlaubteTypen.add(SCHALTER);
 }
 
-void IntegerSchalterAktivierungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerSchalterAktivierungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Schalter *)zParam( 0 ) )->getAnzahlAktivierungen() ) );
+	setReturn(new Integer(((Schalter*)zParam(0))->getAnzahlAktivierungen()));
 }
 
 
-IntegerTunnelBenutzungen::IntegerTunnelBenutzungen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TUNNEL_BENUTZUNGEN, subActions )
+IntegerTunnelBenutzungen::IntegerTunnelBenutzungen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TUNNEL_BENUTZUNGEN, subActions)
 {
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(TUNNEL);
 }
 
-void IntegerTunnelBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTunnelBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getBenutzungen() ) );
+	setReturn(new Integer(((Tunnel*)zParam(0))->getBenutzungen()));
 }
 
 
-IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_UMLENKUNG_BENUTZUNGEN, subActions )
+IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_UMLENKUNG_BENUTZUNGEN, subActions)
 {
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void IntegerUmlenkungBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerUmlenkungBenutzungen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Umlenkung *)zParam( 0 ) )->getBenutzungen() ) );
+	setReturn(new Integer(((Umlenkung*)zParam(0))->getBenutzungen()));
 }
 
 
-IntegerTeamPunkte::IntegerTeamPunkte( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TEAM_PUNKTE, subActions )
+IntegerTeamPunkte::IntegerTeamPunkte(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TEAM_PUNKTE, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void IntegerTeamPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTeamPunkte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getPunkte() ) );
+	setReturn(new Integer(((Team*)zParam(0))->getPunkte()));
 }
 
 
-IntegerTeamKills::IntegerTeamKills( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TEAM_KILLS, subActions )
+IntegerTeamKills::IntegerTeamKills(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TEAM_KILLS, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void IntegerTeamKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTeamKills::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getKills() ) );
+	setReturn(new Integer(((Team*)zParam(0))->getKills()));
 }
 
 
-IntegerTeamTode::IntegerTeamTode( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TEAM_TODE, subActions )
+IntegerTeamTode::IntegerTeamTode(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TEAM_TODE, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void IntegerTeamTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTeamTode::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getTode() ) );
+	setReturn(new Integer(((Team*)zParam(0))->getTode()));
 }
 
 
-FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions )
+FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void FloatTeamWiederbelegungszeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatTeamWiederbelegungszeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Team *)zParam( 0 ) )->getMaxWiederbelebungsZeit() ) );
+	setReturn(new Float(((Team*)zParam(0))->getMaxWiederbelebungsZeit()));
 }
 
 
-IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TEAM_SPIELERANZAHL, subActions )
+IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TEAM_SPIELERANZAHL, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void IntegerTeamSpieleranzahl::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTeamSpieleranzahl::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getSpielerAnzahl() ) );
+	setReturn(new Integer(((Team*)zParam(0))->getSpielerAnzahl()));
 }
 
 
-FloatTimerAktuelleZeit::FloatTimerAktuelleZeit( RCArray<Aktion> *subActions )
-    : Aktion( FLOAT_TIMER_AKTUELLE_ZEIT, subActions )
+FloatTimerAktuelleZeit::FloatTimerAktuelleZeit(RCArray<Aktion>* subActions)
+	: Aktion(FLOAT_TIMER_AKTUELLE_ZEIT, subActions)
 {
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(TIMER);
 }
 
-void FloatTimerAktuelleZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatTimerAktuelleZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( ( (Timer *)zParam( 0 ) )->getTimeLeft() ) );
+	setReturn(new Float(((Timer*)zParam(0))->getTimeLeft()));
 }
 
 
-IntegerTimerMaxZeit::IntegerTimerMaxZeit( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TIMER_MAX_ZEIT, subActions )
+IntegerTimerMaxZeit::IntegerTimerMaxZeit(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TIMER_MAX_ZEIT, subActions)
 {
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(TIMER);
 }
 
-void IntegerTimerMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTimerMaxZeit::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Timer *)zParam( 0 ) )->getMaxTime() ) );
+	setReturn(new Integer(((Timer*)zParam(0))->getMaxTime()));
 }
 
 
-IntegerTriggerRunns::IntegerTriggerRunns( RCArray<Aktion> *subActions )
-    : Aktion( INTEGER_TRIGGER_RUNNS, subActions )
+IntegerTriggerRunns::IntegerTriggerRunns(RCArray<Aktion>* subActions)
+	: Aktion(INTEGER_TRIGGER_RUNNS, subActions)
 {
-    erlaubteTypen.add( TRIGGER );
+	erlaubteTypen.add(TRIGGER);
 }
 
-void IntegerTriggerRunns::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerTriggerRunns::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( ( (Trigger *)zParam( 0 ) )->getRuns() ) );
+	setReturn(new Integer(((Trigger*)zParam(0))->getRuns()));
 }
 
 
-ItemSpielerInventar::ItemSpielerInventar( RCArray<Aktion> *subActions )
-    : Aktion( ITEM_SPIELER_INVENTAR, subActions )
+ItemSpielerInventar::ItemSpielerInventar(RCArray<Aktion>* subActions)
+	: Aktion(ITEM_SPIELER_INVENTAR, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(SPIELER);
 }
 
-void ItemSpielerInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void ItemSpielerInventar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( ( ( (Spieler *)zParam( 1 ) )->getInventorySlot( ( (Integer *)zParam( 0 ) )->getValue() ) ) ) );
+	setReturn(new GegenstandTypVar((((Spieler*)zParam(1))->getInventorySlot(((Integer*)zParam(0))->getValue()))));
 }
 
 
 ItemZuletztAufgehoben::ItemZuletztAufgehoben()
-    : Aktion( ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >() )
+	: Aktion(ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >())
 {}
 
-void ItemZuletztAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void ItemZuletztAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAufgehoben() ) );
+	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAufgehoben()));
 }
 
 
 ItemZuletztAktiviert::ItemZuletztAktiviert()
-    : Aktion( ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
+	: Aktion(ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
 {}
 
-void ItemZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void ItemZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAktiviert() ) );
+	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztAktiviert()));
 }
 
 
 ItemZuletztGedropt::ItemZuletztGedropt()
-    : Aktion( ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >() )
+	: Aktion(ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >())
 {}
 
-void ItemZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void ItemZuletztGedropt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztGedropt() ) );
+	setReturn(new GegenstandTypVar(zSpiel->getItemZuletztGedropt()));
 }
 
 
 ItemZufall::ItemZufall()
-    : Aktion( ITEM_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(ITEM_ZUFALL, new RCArray< Aktion >())
 {}
 
-void ItemZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void ItemZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new GegenstandTypVar( (GegenstandTyp)(int)( zSpiel->getRand() * ITEMANZAHL ) ) );
+	setReturn(new GegenstandTypVar((GegenstandTyp)(int)(zSpiel->getRand() * ITEMANZAHL)));
 }
 
 
 GeschossZufall::GeschossZufall()
-    : Aktion( GESCHOSS_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZUFALL, new RCArray< Aktion >())
 {}
 
-void GeschossZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomGeschoss() );
+	setReturn(zSpiel->getRandomGeschoss());
 }
 
 
 GeschossZuletztAbgefeuert::GeschossZuletztAbgefeuert()
-    : Aktion( GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >())
 {}
 
-void GeschossZuletztAbgefeuert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZuletztAbgefeuert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getGeschossZuletztAbgefeuert() );
+	setReturn(zSpiel->getGeschossZuletztAbgefeuert());
 }
 
 
 GeschossZuletztUmgelenkt::GeschossZuletztUmgelenkt()
-    : Aktion( GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >())
 {}
 
-void GeschossZuletztUmgelenkt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZuletztUmgelenkt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getGeschossZuletztUmgelenkt() );
+	setReturn(zSpiel->getGeschossZuletztUmgelenkt());
 }
 
 
 GeschossZuletztBarjereGetroffen::GeschossZuletztBarjereGetroffen()
-    : Aktion( GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >())
 {}
 
-void GeschossZuletztBarjereGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZuletztBarjereGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getGeschossZuletztBariereGetroffen() );
+	setReturn(zSpiel->getGeschossZuletztBariereGetroffen());
 }
 
 
 GeschossZuletztTunnelBenutzt::GeschossZuletztTunnelBenutzt()
-    : Aktion( GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
 {}
 
-void GeschossZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getGeschossZuletztTunnelBenutzt() );
+	setReturn(zSpiel->getGeschossZuletztTunnelBenutzt());
 }
 
 
 GeschossZuletztGeschossGetroffen::GeschossZuletztGeschossGetroffen()
-    : Aktion( GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >() )
+	: Aktion(GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >())
 {}
 
-void GeschossZuletztGeschossGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void GeschossZuletztGeschossGetroffen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getGeschossZuletztGeschossGetroffen() );
+	setReturn(zSpiel->getGeschossZuletztGeschossGetroffen());
 }
 
 
 RichtungZufall::RichtungZufall()
-    : Aktion( RICHTUNG_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(RICHTUNG_ZUFALL, new RCArray< Aktion >())
 {}
 
-void RichtungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void RichtungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( (Richtung)(int)( zSpiel->getRand() * RICHTUNG_ANZAHL ) ) );
+	setReturn(new String((Richtung)(int)(zSpiel->getRand() * RICHTUNG_ANZAHL)));
 }
 
 
-RichtungVonUmlenkung::RichtungVonUmlenkung( RCArray< Aktion > *subActions )
-    : Aktion( RICHTUNG_VON_UMLENKUNG, subActions )
+RichtungVonUmlenkung::RichtungVonUmlenkung(RCArray< Aktion >* subActions)
+	: Aktion(RICHTUNG_VON_UMLENKUNG, subActions)
 {
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void RichtungVonUmlenkung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void RichtungVonUmlenkung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Umlenkung *)zParam( 0 ) )->getRichtung() ) );
+	setReturn(new String(((Umlenkung*)zParam(0))->getRichtung()));
 }
 
 
-RichtungVonGeschoss::RichtungVonGeschoss( RCArray< Aktion > *subActions )
-    : Aktion( RICHTUNG_VON_GESCHOSS, subActions )
+RichtungVonGeschoss::RichtungVonGeschoss(RCArray< Aktion >* subActions)
+	: Aktion(RICHTUNG_VON_GESCHOSS, subActions)
 {
-    erlaubteTypen.add( GESCHOSS );
+	erlaubteTypen.add(GESCHOSS);
 }
 
-void RichtungVonGeschoss::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void RichtungVonGeschoss::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Geschoss *)zParam( 0 ) )->getRichtung() ) );
+	setReturn(new String(((Geschoss*)zParam(0))->getRichtung()));
 }
 
 
 SchalterZufall::SchalterZufall()
-    : Aktion( SCHALTER_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(SCHALTER_ZUFALL, new RCArray< Aktion >())
 {}
 
-void SchalterZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SchalterZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomSchalter() );
+	setReturn(zSpiel->getRandomSchalter());
 }
 
 
 SchalterZuletztAktiviert::SchalterZuletztAktiviert()
-    : Aktion( SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
+	: Aktion(SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >())
 {}
 
-void SchalterZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SchalterZuletztAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSchalterZuletztAktiviert() );
+	setReturn(zSpiel->getSchalterZuletztAktiviert());
 }
 
 
 SpielerZufall::SpielerZufall()
-    : Aktion( SPIELER_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZUFALL, new RCArray< Aktion >())
 {}
 
-void SpielerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomSpieler() );
+	setReturn(zSpiel->getRandomSpieler());
 }
 
 
-SpielerZufallAusTeam::SpielerZufallAusTeam( RCArray< Aktion > *subActions )
-    : Aktion( SPIELER_ZUFALL_AUS_TEAM, subActions )
+SpielerZufallAusTeam::SpielerZufallAusTeam(RCArray< Aktion >* subActions)
+	: Aktion(SPIELER_ZUFALL_AUS_TEAM, subActions)
 {
-    erlaubteTypen.add( TEAM );
+	erlaubteTypen.add(TEAM);
 }
 
-void SpielerZufallAusTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZufallAusTeam::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomSpieler( (Team *)zParam( 0 ) ) );
+	setReturn(zSpiel->getRandomSpieler((Team*)zParam(0)));
 }
 
 
 SpielerZuletztSchadenGemacht::SpielerZuletztSchadenGemacht()
-    : Aktion( SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztSchadenGemacht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztSchadenGemacht::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztSchadenGemacht() );
+	setReturn(zSpiel->getSpielerZuletztSchadenGemacht());
 }
 
 
 SpielerZuletztSchadenGenommen::SpielerZuletztSchadenGenommen()
-    : Aktion( SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztSchadenGenommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztSchadenGenommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztSchadenGenommen() );
+	setReturn(zSpiel->getSpielerZuletztSchadenGenommen());
 }
 
 
 SpielerZuletztGeheilt::SpielerZuletztGeheilt()
-    : Aktion( SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztGeheilt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztGeheilt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztGeheilt() );
+	setReturn(zSpiel->getSpielerZuletztGeheilt());
 }
 
 
 SpielerZuletztLevelUp::SpielerZuletztLevelUp()
-    : Aktion( SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztLevelUp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztLevelUp::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztLevelUp() );
+	setReturn(zSpiel->getSpielerZuletztLevelUp());
 }
 
 
 SpielerZuletztErfahrungBekommen::SpielerZuletztErfahrungBekommen()
-    : Aktion( SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztErfahrungBekommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztErfahrungBekommen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztErfahrungBekommen() );
+	setReturn(zSpiel->getSpielerZuletztErfahrungBekommen());
 }
 
 
 SpielerZuletztGegenstandAktiviert::SpielerZuletztGegenstandAktiviert()
-    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztGegenstandAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztGegenstandAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztGegenstandAktiviert() );
+	setReturn(zSpiel->getSpielerZuletztGegenstandAktiviert());
 }
 
 
 SpielerZuletztGegenstandAufgehoben::SpielerZuletztGegenstandAufgehoben()
-    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztGegenstandAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztGegenstandAufgehoben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztGegenstandAufgehoben() );
+	setReturn(zSpiel->getSpielerZuletztGegenstandAufgehoben());
 }
 
 
 SpielerZuletztSchalterAktiviert::SpielerZuletztSchalterAktiviert()
-    : Aktion( SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztSchalterAktiviert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztSchalterAktiviert() );
+	setReturn(zSpiel->getSpielerZuletztSchalterAktiviert());
 }
 
 
 SpielerZuletztTunnelBenutzt::SpielerZuletztTunnelBenutzt()
-    : Aktion( SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztTunnelBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztTunnelBenutzt() );
+	setReturn(zSpiel->getSpielerZuletztTunnelBenutzt());
 }
 
 
 SpielerZuletztGestorben::SpielerZuletztGestorben()
-    : Aktion( SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztGestorben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztGestorben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztGestorben() );
+	setReturn(zSpiel->getSpielerZuletztGestorben());
 }
 
 
 SpielerZuletztWiederbelebent::SpielerZuletztWiederbelebent()
-    : Aktion( SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztWiederbelebent::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztWiederbelebent::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztWiederbelebt() );
+	setReturn(zSpiel->getSpielerZuletztWiederbelebt());
 }
 
 
 SpielerZuletztGeschossGeschossen::SpielerZuletztGeschossGeschossen()
-    : Aktion( SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >() )
+	: Aktion(SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >())
 {}
 
-void SpielerZuletztGeschossGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerZuletztGeschossGeschossen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getSpielerZuletztGeschossen() );
+	setReturn(zSpiel->getSpielerZuletztGeschossen());
 }
 
 
-TextConcat::TextConcat( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_CONCAT, subActions )
+TextConcat::TextConcat(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_CONCAT, subActions)
 {
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(STRING);
 }
 
-void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextConcat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    String *p1 = (String *)zParam( 0 );
-    String *p2 = (String *)zParam( 1 );
-    String *res = new String( p1->getValue().operator+( p2->getValue().getText() ) );
-    setReturn( res );
+	String* p1 = (String*)zParam(0);
+	String* p2 = (String*)zParam(1);
+	String* res = new String(p1->getValue().operator+(p2->getValue().getText()));
+	setReturn(res);
 }
 
 
-TextAusInteger::TextAusInteger( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_AUS_INTEGER, subActions )
+TextAusInteger::TextAusInteger(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_AUS_INTEGER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void TextAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( Text( ( (Integer *)zParam( 0 ) )->getValue() ) ) );
+	setReturn(new String(Text(((Integer*)zParam(0))->getValue())));
 }
 
 
-TextAusRichtung::TextAusRichtung( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_AUS_RICHTUNG, subActions )
+TextAusRichtung::TextAusRichtung(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_AUS_RICHTUNG, subActions)
 {
-    erlaubteTypen.add( RICHTUNG );
+	erlaubteTypen.add(RICHTUNG);
 }
 
-void TextAusRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextAusRichtung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (String *)zParam( 0 ) )->getValue() ) );
+	setReturn(new String(((String*)zParam(0))->getValue()));
 }
 
 
-TextAusBoolean::TextAusBoolean( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_AUS_BOOLEAN, subActions )
+TextAusBoolean::TextAusBoolean(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_AUS_BOOLEAN, subActions)
 {
-    erlaubteTypen.add( BOOLEAN );
+	erlaubteTypen.add(BOOLEAN);
 }
 
-void TextAusBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextAusBoolean::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Boolean *)zParam( 0 ) )->getValue() ? "true" : "false" ) );
+	setReturn(new String(((Boolean*)zParam(0))->getValue() ? "true" : "false"));
 }
 
 
-TextSpielerName::TextSpielerName( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_SPIELER_NAME, subActions )
+TextSpielerName::TextSpielerName(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_SPIELER_NAME, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void TextSpielerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextSpielerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Spieler *)zParam( 0 ) )->getName() ) );
+	setReturn(new String(((Spieler*)zParam(0))->getName()));
 }
 
 
-TextItemName::TextItemName( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_ITEM_NAME, subActions )
+TextItemName::TextItemName(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_ITEM_NAME, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
+	erlaubteTypen.add(GEGENSTAND_TYP);
 }
 
-void TextItemName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextItemName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    switch( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() )
-    {
-    case PFEIL:
-        setReturn( new String( "PFEIL" ) );
-        break;
-    case LEBEN:
-        setReturn( new String( "LEBEN" ) );
-        break;
-    case SCHILD:
-        setReturn( new String( "SCHILD" ) );
-        break;
-    case SCHUH:
-        setReturn( new String( "SCHUH" ) );
-        break;
-    case GEIST:
-        setReturn( new String( "GEIST" ) );
-        break;
-    case KUGEL:
-        setReturn( new String( "KUGEL" ) );
-        break;
-    case ROLLE:
-        setReturn( new String( "ROLLE" ) );
-        break;
-    case STURM:
-        setReturn( new String( "STURM" ) );
-        break;
-    case DRACHENAUGE:
-        setReturn( new String( "DRACHENAUGE" ) );
-        break;
-    case FEUERBALL:
-        setReturn( new String( "FEUERBALL" ) );
-        break;
-    case ENTERHAKEN:
-        setReturn( new String( "ENTERHAKEN" ) );
-        break;
-    case MINE:
-        setReturn( new String( "MINE" ) );
-        break;
-    case RWEISHEIT:
-        setReturn( new String( "RWEISHEIT" ) );
-        break;
-    case RSTRENGTH:
-        setReturn( new String( "RSTRENGTH" ) );
-        break;
-    case RBOSHEIT:
-        setReturn( new String( "RBOSHEIT" ) );
-        break;
-    case RLEBEN:
-        setReturn( new String( "RLEBEN" ) );
-        break;
-    case RTEMPO:
-        setReturn( new String( "RTEMPO" ) );
-        break;
-    default:
-        setReturn( new String( "NICHTS" ) );
-        break;
-    }
+	switch (((GegenstandTypVar*)zParam(0))->getValue())
+	{
+	case PFEIL:
+		setReturn(new String("PFEIL"));
+		break;
+	case LEBEN:
+		setReturn(new String("LEBEN"));
+		break;
+	case SCHILD:
+		setReturn(new String("SCHILD"));
+		break;
+	case SCHUH:
+		setReturn(new String("SCHUH"));
+		break;
+	case GEIST:
+		setReturn(new String("GEIST"));
+		break;
+	case KUGEL:
+		setReturn(new String("KUGEL"));
+		break;
+	case ROLLE:
+		setReturn(new String("ROLLE"));
+		break;
+	case STURM:
+		setReturn(new String("STURM"));
+		break;
+	case DRACHENAUGE:
+		setReturn(new String("DRACHENAUGE"));
+		break;
+	case FEUERBALL:
+		setReturn(new String("FEUERBALL"));
+		break;
+	case ENTERHAKEN:
+		setReturn(new String("ENTERHAKEN"));
+		break;
+	case MINE:
+		setReturn(new String("MINE"));
+		break;
+	case RWEISHEIT:
+		setReturn(new String("RWEISHEIT"));
+		break;
+	case RSTRENGTH:
+		setReturn(new String("RSTRENGTH"));
+		break;
+	case RBOSHEIT:
+		setReturn(new String("RBOSHEIT"));
+		break;
+	case RLEBEN:
+		setReturn(new String("RLEBEN"));
+		break;
+	case RTEMPO:
+		setReturn(new String("RTEMPO"));
+		break;
+	default:
+		setReturn(new String("NICHTS"));
+		break;
+	}
 }
 
 
-TextTriggerName::TextTriggerName( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_TRIGGER_NAME, subActions )
+TextTriggerName::TextTriggerName(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_TRIGGER_NAME, subActions)
 {
-    erlaubteTypen.add( TRIGGER );
+	erlaubteTypen.add(TRIGGER);
 }
 
-void TextTriggerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextTriggerName::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Trigger *)zParam( 0 ) )->getName() ) );
+	setReturn(new String(((Trigger*)zParam(0))->getName()));
 }
 
 
-TextTeilVonText::TextTeilVonText( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_TEIL_VON_TEXT, subActions )
+TextTeilVonText::TextTeilVonText(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_TEIL_VON_TEXT, subActions)
 {
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( INTEGER );
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(INTEGER);
+	erlaubteTypen.add(STRING);
 }
 
-void TextTeilVonText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextTeilVonText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Text *txt = ( (String *)zParam( 2 ) )->getValue().getTeilText( ( (Integer *)zParam( 0 ) )->getValue(), ( (Integer *)zParam( 1 ) )->getValue() );
-    setReturn( new String( txt->getText() ) );
-    txt->release();
+	Text* txt = ((String*)zParam(2))->getValue().getTeilText(((Integer*)zParam(0))->getValue(), ((Integer*)zParam(1))->getValue());
+	setReturn(new String(txt->getText()));
+	txt->release();
 }
 
 
 TeamZufall::TeamZufall()
-    : Aktion( TEAM_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(TEAM_ZUFALL, new RCArray< Aktion >())
 {}
 
-void TeamZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomTeam() );
+	setReturn(zSpiel->getRandomTeam());
 }
 
 
-TeamVonSpieler::TeamVonSpieler( RCArray< Aktion > *subActions )
-    : Aktion( TEAM_VON_SPIELER, subActions )
+TeamVonSpieler::TeamVonSpieler(RCArray< Aktion >* subActions)
+	: Aktion(TEAM_VON_SPIELER, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void TeamVonSpieler::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamVonSpieler::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( ( (Spieler *)zParam( 0 ) )->getTeam() );
+	setReturn(((Spieler*)zParam(0))->getTeam());
 }
 
 
-TeamVonBariere::TeamVonBariere( RCArray< Aktion > *subActions )
-    : Aktion( TEAM_VON_BARIERE, subActions )
+TeamVonBariere::TeamVonBariere(RCArray< Aktion >* subActions)
+	: Aktion(TEAM_VON_BARIERE, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void TeamVonBariere::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamVonBariere::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( ( (Bariere *)zParam( 0 ) )->getTeam() );
+	setReturn(((Bariere*)zParam(0))->getTeam());
 }
 
 
 TimerZufall::TimerZufall()
-    : Aktion( TIMER_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(TIMER_ZUFALL, new RCArray< Aktion >())
 {}
 
-void TimerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomTimer() );
+	setReturn(zSpiel->getRandomTimer());
 }
 
 
 TimerZuletztAbgelaufen::TimerZuletztAbgelaufen()
-    : Aktion( TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >() )
+	: Aktion(TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >())
 {}
 
-void TimerZuletztAbgelaufen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerZuletztAbgelaufen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTimerZuletztAbgelaufen() );
+	setReturn(zSpiel->getTimerZuletztAbgelaufen());
 }
 
 
 TimerZuletztGestartet::TimerZuletztGestartet()
-    : Aktion( TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >() )
+	: Aktion(TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >())
 {}
 
-void TimerZuletztGestartet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerZuletztGestartet::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTimerZuletztGestartet() );
+	setReturn(zSpiel->getTimerZuletztGestartet());
 }
 
 
 TimerZuletztPausiert::TimerZuletztPausiert()
-    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
+	: Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
 {}
 
-void TimerZuletztPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerZuletztPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTimerZuletztPausiert() );
+	setReturn(zSpiel->getTimerZuletztPausiert());
 }
 
 
 TimerZuletztFortgesetzt::TimerZuletztFortgesetzt()
-    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
+	: Aktion(TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >())
 {}
 
-void TimerZuletztFortgesetzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TimerZuletztFortgesetzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTimerZuletztFortgesetzt() );
+	setReturn(zSpiel->getTimerZuletztFortgesetzt());
 }
 
 
 TunnelZufall::TunnelZufall()
-    : Aktion( TUNNEL_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(TUNNEL_ZUFALL, new RCArray< Aktion >())
 {}
 
-void TunnelZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TunnelZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomTunnel() );
+	setReturn(zSpiel->getRandomTunnel());
 }
 
 
 TunnelZuletztBenutzt::TunnelZuletztBenutzt()
-    : Aktion( TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >() )
+	: Aktion(TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >())
 {}
 
-void TunnelZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TunnelZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTunnelZuletztBenutzt() );
+	setReturn(zSpiel->getTunnelZuletztBenutzt());
 }
 
 
 UmlenkungZufall::UmlenkungZufall()
-    : Aktion( UMLENKUNG_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(UMLENKUNG_ZUFALL, new RCArray< Aktion >())
 {}
 
-void UmlenkungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void UmlenkungZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRandomUmlenkung() );
+	setReturn(zSpiel->getRandomUmlenkung());
 }
 
 
 UmlenkungZuletztBenutzt::UmlenkungZuletztBenutzt()
-    : Aktion( UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >() )
+	: Aktion(UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >())
 {}
 
-void UmlenkungZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void UmlenkungZuletztBenutzt::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getUmlenkungZuletztBenutzt() );
+	setReturn(zSpiel->getUmlenkungZuletztBenutzt());
 }
 
 
 BooleanZufall::BooleanZufall()
-    : Aktion( BOOLEAN_ZUFALL, new RCArray< Aktion >() )
+	: Aktion(BOOLEAN_ZUFALL, new RCArray< Aktion >())
 {}
 
-void BooleanZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getRand() < 0.5 ? new Boolean( false ) : new Boolean( true ) );
+	setReturn(zSpiel->getRand() < 0.5 ? new Boolean(false) : new Boolean(true));
 }
 
 
 BooleanSpielPausiert::BooleanSpielPausiert()
-    : Aktion( BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >() )
+	: Aktion(BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >())
 {}
 
-void BooleanSpielPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSpielPausiert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( zSpiel->istPausiert() ) );
+	setReturn(new Boolean(zSpiel->istPausiert()));
 }
 
 
-BooleanSpielerAmLeben::BooleanSpielerAmLeben( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_SPIELER_AM_LEBEN, subActions )
+BooleanSpielerAmLeben::BooleanSpielerAmLeben(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_SPIELER_AM_LEBEN, subActions)
 {
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(SPIELER);
 }
 
-void BooleanSpielerAmLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSpielerAmLeben::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Spieler *)zParam( 0 ) )->istAmLeben() ) );
+	setReturn(new Boolean(((Spieler*)zParam(0))->istAmLeben()));
 }
 
 
-BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions )
+BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(GEGENSTAND_TYP);
+	erlaubteTypen.add(SPIELER);
 }
 
-void BooleanSpielerHatGegenstand::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSpielerHatGegenstand::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) != 0 ) );
+	setReturn(new Boolean(((Spieler*)zParam(1))->getItemsInInventory(((GegenstandTypVar*)zParam(0))->getValue()) != 0));
 }
 
 
-BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions )
+BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions)
 {
-    erlaubteTypen.add( RICHTUNG );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(RICHTUNG);
+	erlaubteTypen.add(SPIELER);
 }
 
-void BooleanSpielerIstVerwundbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSpielerIstVerwundbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->isVerwundbar( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) ) ) );
+	setReturn(new Boolean(((Spieler*)zParam(1))->isVerwundbar(getRichtungFromString(((String*)zParam(0))->getValue()))));
 }
 
 
-BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions )
+BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions)
 {
-    erlaubteTypen.add( GEGENSTAND_TYP );
-    erlaubteTypen.add( SPIELER );
+	erlaubteTypen.add(GEGENSTAND_TYP);
+	erlaubteTypen.add(SPIELER);
 }
 
-void BooleanSpielerKannItemBenutzen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSpielerKannItemBenutzen::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->istGegenstandErlaubt( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
+	setReturn(new Boolean(((Spieler*)zParam(1))->istGegenstandErlaubt(((GegenstandTypVar*)zParam(0))->getValue())));
 }
 
 
-BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_UMLENKUNG_HAT_ABK, subActions )
+BooleanUmlenkungHatAbk::BooleanUmlenkungHatAbk(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_UMLENKUNG_HAT_ABK, subActions)
 {
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void BooleanUmlenkungHatAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanUmlenkungHatAbk::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->hatAbklingzeit() ) );
+	setReturn(new Boolean(((Umlenkung*)zParam(0))->hatAbklingzeit()));
 }
 
 
-BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_UMLENKUNG_IST_DREHEND, subActions )
+BooleanUmlenkungIstDrehend::BooleanUmlenkungIstDrehend(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_UMLENKUNG_IST_DREHEND, subActions)
 {
-    erlaubteTypen.add( UMLENKUNG );
+	erlaubteTypen.add(UMLENKUNG);
 }
 
-void BooleanUmlenkungIstDrehend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanUmlenkungIstDrehend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Umlenkung *)zParam( 0 ) )->istDrehend() ) );
+	setReturn(new Boolean(((Umlenkung*)zParam(0))->istDrehend()));
 }
 
 
-BooleanBariereBewegtSich::BooleanBariereBewegtSich( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_BARIERE_BEWEGT_SICH, subActions )
+BooleanBariereBewegtSich::BooleanBariereBewegtSich(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_BARIERE_BEWEGT_SICH, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void BooleanBariereBewegtSich::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanBariereBewegtSich::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::InVerschiebung ) ) );
+	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::InVerschiebung)));
 }
 
 
-BooleanBariereIstSchaltend::BooleanBariereIstSchaltend( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_BARIERE_IST_SCHALTEND, subActions )
+BooleanBariereIstSchaltend::BooleanBariereIstSchaltend(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_BARIERE_IST_SCHALTEND, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void BooleanBariereIstSchaltend::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanBariereIstSchaltend::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::AutoSchaltung ) ) );
+	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::AutoSchaltung)));
 }
 
 
-BooleanBariereIstAktiv::BooleanBariereIstAktiv( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_BARIERE_IST_AKTIV, subActions )
+BooleanBariereIstAktiv::BooleanBariereIstAktiv(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_BARIERE_IST_AKTIV, subActions)
 {
-    erlaubteTypen.add( BARIERE );
+	erlaubteTypen.add(BARIERE);
 }
 
-void BooleanBariereIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanBariereIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Bariere *)zParam( 0 ) )->hatStyle( Bariere::Style::Aktiv ) ) );
+	setReturn(new Boolean(((Bariere*)zParam(0))->hatStyle(Bariere::Style::Aktiv)));
 }
 
 
-BooleanSchalterIstAktiv::BooleanSchalterIstAktiv( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_SCHALTER_IST_AKTIV, subActions )
+BooleanSchalterIstAktiv::BooleanSchalterIstAktiv(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_SCHALTER_IST_AKTIV, subActions)
 {
-    erlaubteTypen.add( SCHALTER );
+	erlaubteTypen.add(SCHALTER);
 }
 
-void BooleanSchalterIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanSchalterIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Schalter *)zParam( 0 ) )->isAktive() ) );
+	setReturn(new Boolean(((Schalter*)zParam(0))->isAktive()));
 }
 
 
-BooleanTunnelIstAktiv::BooleanTunnelIstAktiv( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_TUNNEL_IST_AKTIV, subActions )
+BooleanTunnelIstAktiv::BooleanTunnelIstAktiv(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_TUNNEL_IST_AKTIV, subActions)
 {
-    erlaubteTypen.add( TUNNEL );
+	erlaubteTypen.add(TUNNEL);
 }
 
-void BooleanTunnelIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanTunnelIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Tunnel *)zParam( 0 ) )->istAktiv() ) );
+	setReturn(new Boolean(((Tunnel*)zParam(0))->istAktiv()));
 }
 
 
-BooleanBaseIstNeutral::BooleanBaseIstNeutral( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_BASE_IST_NEUTRAL, subActions )
+BooleanBaseIstNeutral::BooleanBaseIstNeutral(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_BASE_IST_NEUTRAL, subActions)
 {
-    erlaubteTypen.add( BASE );
+	erlaubteTypen.add(BASE);
 }
 
-void BooleanBaseIstNeutral::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanBaseIstNeutral::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Base *)zParam( 0 ) )->zTeam() == 0 ) );
+	setReturn(new Boolean(((Base*)zParam(0))->zTeam() == 0));
 }
 
 
-BooleanTimerIsRunning::BooleanTimerIsRunning( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_TIMER_IS_RUNNING, subActions )
+BooleanTimerIsRunning::BooleanTimerIsRunning(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_TIMER_IS_RUNNING, subActions)
 {
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(TIMER);
 }
 
-void BooleanTimerIsRunning::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanTimerIsRunning::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->isRunning() ) );
+	setReturn(new Boolean(((Timer*)zParam(0))->isRunning()));
 }
 
 
-BooleanTimerIstSichtbar::BooleanTimerIstSichtbar( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_TIMER_IST_SICHTBAR, subActions )
+BooleanTimerIstSichtbar::BooleanTimerIstSichtbar(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_TIMER_IST_SICHTBAR, subActions)
 {
-    erlaubteTypen.add( TIMER );
+	erlaubteTypen.add(TIMER);
 }
 
-void BooleanTimerIstSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanTimerIstSichtbar::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Timer *)zParam( 0 ) )->istSichtbar() ) );
+	setReturn(new Boolean(((Timer*)zParam(0))->istSichtbar()));
 }
 
 
-BooleanAusText::BooleanAusText( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_AUS_TEXT, subActions )
+BooleanAusText::BooleanAusText(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_AUS_TEXT, subActions)
 {
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(STRING);
 }
 
-void BooleanAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (String *)zParam( 0 ) )->getValue().istGleich( "true" ) ) );
+	setReturn(new Boolean(((String*)zParam(0))->getValue().istGleich("true")));
 }
 
 
-BooleanTriggerIstAktiv::BooleanTriggerIstAktiv( RCArray< Aktion > *subActions )
-    : Aktion( BOOLEAN_TRIGGER_IST_AKTIV, subActions )
+BooleanTriggerIstAktiv::BooleanTriggerIstAktiv(RCArray< Aktion >* subActions)
+	: Aktion(BOOLEAN_TRIGGER_IST_AKTIV, subActions)
 {
-    erlaubteTypen.add( TRIGGER );
+	erlaubteTypen.add(TRIGGER);
 }
 
-void BooleanTriggerIstAktiv::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanTriggerIstAktiv::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Boolean( ( (Trigger *)zParam( 0 ) )->istAktiv() ) );
+	setReturn(new Boolean(((Trigger*)zParam(0))->istAktiv()));
 }
 
 
-BooleanRechnung::BooleanRechnung( RCArray< Aktion > *subActions, Operator op )
-    : Aktion( BOOLEAN_RECHNUNG, subActions )
+BooleanRechnung::BooleanRechnung(RCArray< Aktion >* subActions, Operator op)
+	: Aktion(BOOLEAN_RECHNUNG, subActions)
 {
-    this->op = op;
+	this->op = op;
 }
 
-void BooleanRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BooleanRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    if( op == UND || op == ODER )
-    {
-        if( zParam( 0 )->getVariableTyp() != BOOLEAN || zParam( 1 )->getVariableTyp() != BOOLEAN )
-            return;
-        Boolean *b1 = (Boolean *)zParam( 0 );
-        Boolean *b2 = (Boolean *)zParam( 1 );
-        if( op == UND )
-            setReturn( new Boolean( b1->getValue() && b2->getValue() ) );
-        else
-            setReturn( new Boolean( b1->getValue() || b2->getValue() ) );
-    }
-    if( op == GLEICH || op == UNGLEICH )
-    {
-        if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
-        {
-            setReturn( new Boolean( op == GLEICH ) );
-            return;
-        }
-        switch( zParam( 0 )->getVariableTyp() )
-        {
-        case NICHTS:
-            setReturn( new Boolean( op == GLEICH ) );
-            break;
-        case INTEGER:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
-            break;
-        case BOOLEAN:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Boolean *)zParam( 0 ) )->getValue() == ( (Boolean *)zParam( 1 ) )->getValue() ) ) );
-            break;
-        case STRING:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
-            break;
-        case RICHTUNG:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
-            break;
-        case FLOAT:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Float *)zParam( 0 ) )->getValue() == ( (Float *)zParam( 1 ) )->getValue() ) ) );
-            break;
-        case TASTE:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (Integer *)zParam( 0 ) )->getValue() == ( (Integer *)zParam( 1 ) )->getValue() ) ) );
-            break;
-        case GEGENSTAND_TYP:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() == ( (GegenstandTypVar *)zParam( 1 ) )->getValue() ) ) );
-            break;
-        case GESCHOSS_TYP:
-            setReturn( new Boolean( ( op == GLEICH ) == ( ( (String *)zParam( 0 ) )->getValue().istGleich( ( (String *)zParam( 1 ) )->getValue() ) ) ) );
-            break;
-        default:
-            setReturn( new Boolean( ( op == GLEICH ) == ( zParam( 0 ) == zParam( 1 ) ) ) );
-        }
-    }
-    if( op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL )
-    {
-        if( zParam( 1 )->getVariableTyp() != zParam( 0 )->getVariableTyp() )
-        {
-            setReturn( new Boolean( op == GLEICH ) );
-            return;
-        }
-        if( zParam( 1 )->getVariableTyp() == INTEGER )
-        {
-            if( op == SMALLER || op == GREATER_OR_EQUAL )
-                setReturn( new Boolean( ( op == SMALLER ) == ( ( (Integer *)zParam( 0 ) )->getValue() < ( (Integer *)zParam( 1 ) )->getValue() ) ) );
-            else
-                setReturn( new Boolean( ( op == GREATER ) == ( ( (Integer *)zParam( 0 ) )->getValue() > ( (Integer *)zParam( 1 ) )->getValue() ) ) );
-        }
-        if( zParam( 1 )->getVariableTyp() == FLOAT )
-        {
-            if( op == SMALLER || op == GREATER_OR_EQUAL )
-                setReturn( new Boolean( ( op == SMALLER ) == ( ( (Float *)zParam( 0 ) )->getValue() < ( (Float *)zParam( 1 ) )->getValue() ) ) );
-            else
-                setReturn( new Boolean( ( op == GREATER ) == ( ( (Float *)zParam( 0 ) )->getValue() > ( (Float *)zParam( 1 ) )->getValue() ) ) );
-        }
-    }
-    if( op == INVERT_BOOL )
-    {
-        setReturn( new Boolean( !( (Boolean *)zParam( 0 ) )->getValue() ) );
-    }
-}
-
-void BooleanRechnung::writeOptions( StreamWriter &dat )
-{
-    dat.schreibe( (char *)&this->op, 1 );
-}
-
-
-Sequenz::Sequenz( RCArray< Aktion > *subActions )
-    : Aktion( SEQUENZ, subActions )
+	if (op == UND || op == ODER)
+	{
+		if (zParam(0)->getVariableTyp() != BOOLEAN || zParam(1)->getVariableTyp() != BOOLEAN)
+			return;
+		Boolean* b1 = (Boolean*)zParam(0);
+		Boolean* b2 = (Boolean*)zParam(1);
+		if (op == UND)
+			setReturn(new Boolean(b1->getValue() && b2->getValue()));
+		else
+			setReturn(new Boolean(b1->getValue() || b2->getValue()));
+	}
+	if (op == GLEICH || op == UNGLEICH)
+	{
+		if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
+		{
+			setReturn(new Boolean(op == GLEICH));
+			return;
+		}
+		switch (zParam(0)->getVariableTyp())
+		{
+		case NICHTS:
+			setReturn(new Boolean(op == GLEICH));
+			break;
+		case INTEGER:
+			setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
+			break;
+		case BOOLEAN:
+			setReturn(new Boolean((op == GLEICH) == (((Boolean*)zParam(0))->getValue() == ((Boolean*)zParam(1))->getValue())));
+			break;
+		case STRING:
+			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
+			break;
+		case RICHTUNG:
+			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
+			break;
+		case FLOAT:
+			setReturn(new Boolean((op == GLEICH) == (((Float*)zParam(0))->getValue() == ((Float*)zParam(1))->getValue())));
+			break;
+		case TASTE:
+			setReturn(new Boolean((op == GLEICH) == (((Integer*)zParam(0))->getValue() == ((Integer*)zParam(1))->getValue())));
+			break;
+		case GEGENSTAND_TYP:
+			setReturn(new Boolean((op == GLEICH) == (((GegenstandTypVar*)zParam(0))->getValue() == ((GegenstandTypVar*)zParam(1))->getValue())));
+			break;
+		case GESCHOSS_TYP:
+			setReturn(new Boolean((op == GLEICH) == (((String*)zParam(0))->getValue().istGleich(((String*)zParam(1))->getValue()))));
+			break;
+		default:
+			setReturn(new Boolean((op == GLEICH) == (zParam(0) == zParam(1))));
+		}
+	}
+	if (op == GREATER || op == SMALLER || op == GREATER_OR_EQUAL || op == SMALLER_OR_EQUAL)
+	{
+		if (zParam(1)->getVariableTyp() != zParam(0)->getVariableTyp())
+		{
+			setReturn(new Boolean(op == GLEICH));
+			return;
+		}
+		if (zParam(1)->getVariableTyp() == INTEGER)
+		{
+			if (op == SMALLER || op == GREATER_OR_EQUAL)
+				setReturn(new Boolean((op == SMALLER) == (((Integer*)zParam(0))->getValue() < ((Integer*)zParam(1))->getValue())));
+			else
+				setReturn(new Boolean((op == GREATER) == (((Integer*)zParam(0))->getValue() > ((Integer*)zParam(1))->getValue())));
+		}
+		if (zParam(1)->getVariableTyp() == FLOAT)
+		{
+			if (op == SMALLER || op == GREATER_OR_EQUAL)
+				setReturn(new Boolean((op == SMALLER) == (((Float*)zParam(0))->getValue() < ((Float*)zParam(1))->getValue())));
+			else
+				setReturn(new Boolean((op == GREATER) == (((Float*)zParam(0))->getValue() > ((Float*)zParam(1))->getValue())));
+		}
+	}
+	if (op == INVERT_BOOL)
+	{
+		setReturn(new Boolean(!((Boolean*)zParam(0))->getValue()));
+	}
+}
+
+void BooleanRechnung::writeOptions(StreamWriter& dat)
+{
+	dat.schreibe((char*)&this->op, 1);
+}
+
+
+Sequenz::Sequenz(RCArray< Aktion >* subActions)
+	: Aktion(SEQUENZ, subActions)
 {}
 
-void Sequenz::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void Sequenz::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {}
 
 
-FloatRechnung::FloatRechnung( RCArray< Aktion > *subActions, Operator op )
-    : Aktion( FLOAT_RECHNUNG, subActions )
+FloatRechnung::FloatRechnung(RCArray< Aktion >* subActions, Operator op)
+	: Aktion(FLOAT_RECHNUNG, subActions)
 {
-    this->op = op;
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( FLOAT );
+	this->op = op;
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(FLOAT);
 }
 
-void FloatRechnung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatRechnung::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Float *l = (Float *)zParam( 0 );
-    Float *r = (Float *)zParam( 1 );
-    switch( op )
-    {
-    case PLUS:
-        setReturn( new Float( l->getValue() + r->getValue() ) );
-        break;
-    case MINUS:
-        setReturn( new Float( l->getValue() - r->getValue() ) );
-        break;
-    case MAHL:
-        setReturn( new Float( l->getValue() * r->getValue() ) );
-        break;
-    case GETEILT:
-        setReturn( new Float( l->getValue() / r->getValue() ) );
-        break;
-    case HOCH:
-        setReturn( new Float( (float)pow( l->getValue(), r->getValue() ) ) );
-        break;
-    case WURZEL:
-        setReturn( new Float( (float)pow( l->getValue(), 1.0 / r->getValue() ) ) );
-        break;
-    case INVERT_SIGN:
-        setReturn( new Float( -l->getValue() ) );
-        break;
-    case PLUS_PLUS_LEFT:
-        l->setValue( l->getValue() + 1 );
-        setReturn( new Float( l->getValue() ) );
-        break;
-    case PLUS_PLUS_RIGHT:
-    {
-        float tmp = l->getValue();
-        l->setValue( l->getValue() + 1 );
-        setReturn( new Float( tmp ) );
-        break;
-    }
-    case MINUS_MINUS_LEFT:
-        l->setValue( l->getValue() - 1 );
-        setReturn( new Float( l->getValue() ) );
-        break;
-    case MINUS_MINUS_RIGHT:
-    {
-        float tmp = l->getValue();
-        l->setValue( l->getValue() - 1 );
-        setReturn( new Float( tmp ) );
-        break;
-    }
-    case LOGARITHM:
-        setReturn( new Float( (float)( log( l->getValue() ) / log( r->getValue() ) ) ) );
-        break;
-    case MODULO:
-        setReturn( new Float( l->getValue() - (float)(int)( l->getValue() / r->getValue() ) * r->getValue() ) );
-        break;
-    default:
-        break;
-    }
+	Float* l = (Float*)zParam(0);
+	Float* r = (Float*)zParam(1);
+	switch (op)
+	{
+	case PLUS:
+		setReturn(new Float(l->getValue() + r->getValue()));
+		break;
+	case MINUS:
+		setReturn(new Float(l->getValue() - r->getValue()));
+		break;
+	case MAHL:
+		setReturn(new Float(l->getValue() * r->getValue()));
+		break;
+	case GETEILT:
+		setReturn(new Float(l->getValue() / r->getValue()));
+		break;
+	case HOCH:
+		setReturn(new Float((float)pow(l->getValue(), r->getValue())));
+		break;
+	case WURZEL:
+		setReturn(new Float((float)pow(l->getValue(), 1.0 / r->getValue())));
+		break;
+	case INVERT_SIGN:
+		setReturn(new Float(-l->getValue()));
+		break;
+	case PLUS_PLUS_LEFT:
+		l->setValue(l->getValue() + 1);
+		setReturn(new Float(l->getValue()));
+		break;
+	case PLUS_PLUS_RIGHT:
+	{
+		float tmp = l->getValue();
+		l->setValue(l->getValue() + 1);
+		setReturn(new Float(tmp));
+		break;
+	}
+	case MINUS_MINUS_LEFT:
+		l->setValue(l->getValue() - 1);
+		setReturn(new Float(l->getValue()));
+		break;
+	case MINUS_MINUS_RIGHT:
+	{
+		float tmp = l->getValue();
+		l->setValue(l->getValue() - 1);
+		setReturn(new Float(tmp));
+		break;
+	}
+	case LOGARITHM:
+		setReturn(new Float((float)(log(l->getValue()) / log(r->getValue()))));
+		break;
+	case MODULO:
+		setReturn(new Float(l->getValue() - (float)(int)(l->getValue() / r->getValue()) * r->getValue()));
+		break;
+	default:
+		break;
+	}
 }
 
-void FloatRechnung::writeOptions( StreamWriter &dat )
+void FloatRechnung::writeOptions(StreamWriter& dat)
 {
-    dat.schreibe( (char *)&op, 1 );
+	dat.schreibe((char*)&op, 1);
 }
 
 
-FloatAusInteger::FloatAusInteger( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_AUS_INTEGER, subActions )
+FloatAusInteger::FloatAusInteger(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_AUS_INTEGER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void FloatAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatAusInteger::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( (float)( (Integer *)zParam( 0 ) )->getValue() ) );
+	setReturn(new Float((float)((Integer*)zParam(0))->getValue()));
 }
 
 
-FloatAusText::FloatAusText( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_AUS_TEXT, subActions )
+FloatAusText::FloatAusText(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_AUS_TEXT, subActions)
 {
-    erlaubteTypen.add( STRING );
+	erlaubteTypen.add(STRING);
 }
 
-void FloatAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatAusText::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Float( (float)( (String *)zParam( 0 ) )->getValue() ) );
+	setReturn(new Float((float)((String*)zParam(0))->getValue()));
 }
 
 
-TextAusFloat::TextAusFloat( RCArray< Aktion > *subActions )
-    : Aktion( TEXT_AUS_FLOAT, subActions )
+TextAusFloat::TextAusFloat(RCArray< Aktion >* subActions)
+	: Aktion(TEXT_AUS_FLOAT, subActions)
 {
-    erlaubteTypen.add( FLOAT );
+	erlaubteTypen.add(FLOAT);
 }
 
-void TextAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TextAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( Text( ( (Float *)zParam( 0 ) )->getValue() ) ) );
+	setReturn(new String(Text(((Float*)zParam(0))->getValue())));
 }
 
 
-FloatZufall::FloatZufall( RCArray< Aktion > *subActions )
-    : Aktion( FLOAT_ZUFALL, subActions )
+FloatZufall::FloatZufall(RCArray< Aktion >* subActions)
+	: Aktion(FLOAT_ZUFALL, subActions)
 {
-    erlaubteTypen.add( FLOAT );
-    erlaubteTypen.add( FLOAT );
+	erlaubteTypen.add(FLOAT);
+	erlaubteTypen.add(FLOAT);
 }
 
-void FloatZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void FloatZufall::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Float *min = ( (Float *)zParam( 0 ) );
-    Float *max = ( (Float *)zParam( 0 ) );
-    setReturn( new Float( (float)zSpiel->getRand() * ( max->getValue() - min->getValue() ) + min->getValue() ) );
+	Float* min = ((Float*)zParam(0));
+	Float* max = ((Float*)zParam(0));
+	setReturn(new Float((float)zSpiel->getRand() * (max->getValue() - min->getValue()) + min->getValue()));
 }
 
 
-IntegerAusFloat::IntegerAusFloat( RCArray< Aktion > *subActions )
-    : Aktion( INTEGER_AUS_FLOAT, subActions )
+IntegerAusFloat::IntegerAusFloat(RCArray< Aktion >* subActions)
+	: Aktion(INTEGER_AUS_FLOAT, subActions)
 {
-    erlaubteTypen.add( FLOAT );
+	erlaubteTypen.add(FLOAT);
 }
 
-void IntegerAusFloat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void IntegerAusFloat::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new Integer( (int)( (Float *)zParam( 0 ) )->getValue() ) );
+	setReturn(new Integer((int)((Float*)zParam(0))->getValue()));
 }
 
 
-BestenlisteNeu::BestenlisteNeu( RCArray<Aktion> *subActions )
-    : Aktion( BESTENLISTE_NEU, subActions )
+BestenlisteNeu::BestenlisteNeu(RCArray<Aktion>* subActions)
+	: Aktion(BESTENLISTE_NEU, subActions)
 {}
 
-void BestenlisteNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BestenlisteNeu::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Bestenliste *b = new Bestenliste( zSpiel->getNextId(), zSpiel->zResources()->getUIFactory() );
-    zSpiel->addBestenliste( b );
-    setReturn( dynamic_cast<Bestenliste *>( b->getThis() ) );
+	Bestenliste* b = new Bestenliste(zSpiel->getNextId(), zSpiel->zResources()->getUIFactory());
+	zSpiel->addBestenliste(b);
+	setReturn(dynamic_cast<Bestenliste*>(b->getThis()));
 }
 
 
-BestenlisteAddZeile::BestenlisteAddZeile( RCArray<Aktion> *subActions )
-    : Aktion( BESTENLISTE_ADD_ZEILE, subActions )
+BestenlisteAddZeile::BestenlisteAddZeile(RCArray<Aktion>* subActions)
+	: Aktion(BESTENLISTE_ADD_ZEILE, subActions)
 {
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( BESTENLISTE );
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(BESTENLISTE);
 }
 
-void BestenlisteAddZeile::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BestenlisteAddZeile::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bestenliste *)zParam( 1 ) )->addZeile( ( (String *)zParam( 0 ) )->getValue() );
+	((Bestenliste*)zParam(1))->addZeile(((String*)zParam(0))->getValue());
 }
 
 
-BestenlisteAddSpalte::BestenlisteAddSpalte( RCArray<Aktion> *subActions )
-    : Aktion( BESTENLISTE_ADD_SPALTE, subActions )
+BestenlisteAddSpalte::BestenlisteAddSpalte(RCArray<Aktion>* subActions)
+	: Aktion(BESTENLISTE_ADD_SPALTE, subActions)
 {
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( BESTENLISTE );
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(BESTENLISTE);
 }
 
-void BestenlisteAddSpalte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BestenlisteAddSpalte::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bestenliste *)zParam( 1 ) )->addSpalte( ( (String *)zParam( 0 ) )->getValue() );
+	((Bestenliste*)zParam(1))->addSpalte(((String*)zParam(0))->getValue());
 }
 
 
-BestenlisteSetWert::BestenlisteSetWert( RCArray<Aktion> *subActions )
-    : Aktion( BESTENLISTE_SET_WERT, subActions )
+BestenlisteSetWert::BestenlisteSetWert(RCArray<Aktion>* subActions)
+	: Aktion(BESTENLISTE_SET_WERT, subActions)
 {
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( BESTENLISTE );
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(BESTENLISTE);
 }
 
-void BestenlisteSetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BestenlisteSetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    ( (Bestenliste *)zParam( 3 ) )->setWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue(), ( (String *)zParam( 2 ) )->getValue() );
+	((Bestenliste*)zParam(3))->setWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue(), ((String*)zParam(2))->getValue());
 }
 
 
-BestenlisteGetWert::BestenlisteGetWert( RCArray<Aktion> *subActions )
-    : Aktion( BESTENLISTE_GET_WERT, subActions )
+BestenlisteGetWert::BestenlisteGetWert(RCArray<Aktion>* subActions)
+	: Aktion(BESTENLISTE_GET_WERT, subActions)
 {
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( STRING );
-    erlaubteTypen.add( BESTENLISTE );
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(STRING);
+	erlaubteTypen.add(BESTENLISTE);
 }
 
-void BestenlisteGetWert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BestenlisteGetWert::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( new String( ( (Bestenliste *)zParam( 2 ) )->getWert( ( (String *)zParam( 0 ) )->getValue(), ( (String *)zParam( 1 ) )->getValue() ) ) );
+	setReturn(new String(((Bestenliste*)zParam(2))->getWert(((String*)zParam(0))->getValue(), ((String*)zParam(1))->getValue())));
 }
 
 
-SchalterMitNummer::SchalterMitNummer( RCArray<Aktion> *subActions )
-    : Aktion( SCHALTER_MIT_NUMMER, subActions )
+SchalterMitNummer::SchalterMitNummer(RCArray<Aktion>* subActions)
+	: Aktion(SCHALTER_MIT_NUMMER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void SchalterMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SchalterMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Schalter *s = zSpiel->getSchalter( ( (Integer *)zParam( 0 ) )->getValue() );
-    if( s )
-        setReturn( s );
-    else
-        setReturn( new Variable( VariableTyp::NICHTS ) );
+	Schalter* s = zSpiel->getSchalter(((Integer*)zParam(0))->getValue());
+	if (s)
+		setReturn(s);
+	else
+		setReturn(new Variable(VariableTyp::NICHTS));
 }
 
 
-BaseMitNummer::BaseMitNummer( RCArray<Aktion> *subActions )
-    : Aktion( BASE_MIT_NUMMER, subActions )
+BaseMitNummer::BaseMitNummer(RCArray<Aktion>* subActions)
+	: Aktion(BASE_MIT_NUMMER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void BaseMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void BaseMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Base *b = zSpiel->getBase( ( (Integer *)zParam( 0 ) )->getValue() );
-    if( b )
-        setReturn( b );
-    else
-        setReturn( new Variable( VariableTyp::NICHTS ) );
+	Base* b = zSpiel->getBase(((Integer*)zParam(0))->getValue());
+	if (b)
+		setReturn(b);
+	else
+		setReturn(new Variable(VariableTyp::NICHTS));
 }
 
 
-TeamMitNummer::TeamMitNummer( RCArray<Aktion> *subActions )
-    : Aktion( TEAM_MIT_NUMMER, subActions )
+TeamMitNummer::TeamMitNummer(RCArray<Aktion>* subActions)
+	: Aktion(TEAM_MIT_NUMMER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void TeamMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    setReturn( zSpiel->getTeam( ( (Integer *)zParam( 0 ) )->getValue() ) );
+	setReturn(zSpiel->getTeam(((Integer*)zParam(0))->getValue()));
 }
 
 
-TeamVonBase::TeamVonBase( RCArray<Aktion> *subActions )
-    : Aktion( TEAM_VON_BASE, subActions )
+TeamVonBase::TeamVonBase(RCArray<Aktion>* subActions)
+	: Aktion(TEAM_VON_BASE, subActions)
 {
-    erlaubteTypen.add( BASE );
+	erlaubteTypen.add(BASE);
 }
 
-void TeamVonBase::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void TeamVonBase::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Team *t = ( (Base *)zParam( 0 ) )->getTeam();
-    if( t )
-        setReturn( t );
-    else
-        setReturn( new Variable( VariableTyp::NICHTS ) );
+	Team* t = ((Base*)zParam(0))->getTeam();
+	if (t)
+		setReturn(t);
+	else
+		setReturn(new Variable(VariableTyp::NICHTS));
 }
 
 
-SpielerMitNummer::SpielerMitNummer( RCArray<Aktion> *subActions )
-    : Aktion( SPIELER_MIT_NUMMER, subActions )
+SpielerMitNummer::SpielerMitNummer(RCArray<Aktion>* subActions)
+	: Aktion(SPIELER_MIT_NUMMER, subActions)
 {
-    erlaubteTypen.add( INTEGER );
+	erlaubteTypen.add(INTEGER);
 }
 
-void SpielerMitNummer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+void SpielerMitNummer::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
 {
-    Spieler *s = zSpiel->getSpieler( ( (Integer *)zParam( 0 ) )->getValue() );
-    if( s )
-        setReturn( s );
-    else
-        setReturn( new Variable( VariableTyp::NICHTS ) );
+	Spieler* s = zSpiel->getSpieler(((Integer*)zParam(0))->getValue());
+	if (s)
+		setReturn(s);
+	else
+		setReturn(new Variable(VariableTyp::NICHTS));
 }

StickmanWorldOnline/Reader.cpp

@@ -4,1115 +4,1115 @@
 
 struct SpielerTeamStruktur
 {
-    int spielerAnzahl;
-    int teamAnzahl;
-    Array< int > spielerFarbe;
-    Array< int > teamFarbe;
-    RCArray< Text > teamName;
-    Array< int > teamSize;
+	int spielerAnzahl;
+	int teamAnzahl;
+	Array< int > spielerFarbe;
+	Array< int > teamFarbe;
+	RCArray< Text > teamName;
+	Array< int > teamSize;
 };
 
 
 // Konstruktor
-MapReader::MapReader( int karteId, char* tmpPfad )
-    : ReferenceCounter()
+MapReader::MapReader(int karteId, const char* tmpPfad)
+	: ReferenceCounter()
 {
-    this->karteId = karteId;
-    pfad = new Text( tmpPfad );
+	this->karteId = karteId;
+	pfad = new Text(tmpPfad);
 }
 
 // Destruktor
 MapReader::~MapReader()
 {
-    if( pfad )
-        pfad->release();
+	if (pfad)
+		pfad->release();
 }
 
 Array<int>* MapReader::getSpielerFarben()
 {
-    Text* pf = new Text( pfad->getText() );
-    pf->append( "data.sts" );
-    Datei* datei = new Datei();
-    datei->setDatei( pf );
-    if( !datei->existiert() || datei->istOrdner() )
-    {
-        datei->release();
-        return 0;
-    }
-    int spielerAnzahl;
-    int teamAnzahl;
-    datei->open( Datei::Style::lesen );
-    datei->lese( (char*)&spielerAnzahl, 4 );
-    datei->lese( (char*)&teamAnzahl, 4 );
-    Array< int >* result = new Array< int >();
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        int f = 0;
-        datei->lese( (char*)&f, 4 );
-        result->add( f );
-    }
-    datei->close();
-    datei->release();
-    return result;
+	Text* pf = new Text(pfad->getText());
+	pf->append("data.sts");
+	Datei* datei = new Datei();
+	datei->setDatei(pf);
+	if (!datei->existiert() || datei->istOrdner())
+	{
+		datei->release();
+		return 0;
+	}
+	int spielerAnzahl;
+	int teamAnzahl;
+	datei->open(Datei::Style::lesen);
+	datei->lese((char*)&spielerAnzahl, 4);
+	datei->lese((char*)&teamAnzahl, 4);
+	Array< int >* result = new Array< int >();
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		int f = 0;
+		datei->lese((char*)&f, 4);
+		result->add(f);
+	}
+	datei->close();
+	datei->release();
+	return result;
 }
 
 Array<int>* MapReader::getTeamFarben()
 {
-    Text* pf = new Text( pfad->getText() );
-    pf->append( "data.sts" );
-    Datei* datei = new Datei();
-    datei->setDatei( pf );
-    if( !datei->existiert() || datei->istOrdner() )
-    {
-        datei->release();
-        return 0;
-    }
-    int spielerAnzahl;
-    int teamAnzahl;
-    datei->open( Datei::Style::lesen );
-    datei->lese( (char*)&spielerAnzahl, 4 );
-    datei->lese( (char*)&teamAnzahl, 4 );
-    for( int i = 0; i < spielerAnzahl; i++ )
-    {
-        int f = 0;
-        datei->lese( (char*)&f, 4 );
-    }
-    Array< int >* result = new Array< int >();
-    for( int i = 0; i < teamAnzahl; i++ )
-    {
-        int f = 0;
-        datei->lese( (char*)&f, 4 );
-        result->add( f );
-    }
-    datei->close();
-    datei->release();
-    return result;
+	Text* pf = new Text(pfad->getText());
+	pf->append("data.sts");
+	Datei* datei = new Datei();
+	datei->setDatei(pf);
+	if (!datei->existiert() || datei->istOrdner())
+	{
+		datei->release();
+		return 0;
+	}
+	int spielerAnzahl;
+	int teamAnzahl;
+	datei->open(Datei::Style::lesen);
+	datei->lese((char*)&spielerAnzahl, 4);
+	datei->lese((char*)&teamAnzahl, 4);
+	for (int i = 0; i < spielerAnzahl; i++)
+	{
+		int f = 0;
+		datei->lese((char*)&f, 4);
+	}
+	Array< int >* result = new Array< int >();
+	for (int i = 0; i < teamAnzahl; i++)
+	{
+		int f = 0;
+		datei->lese((char*)&f, 4);
+		result->add(f);
+	}
+	datei->close();
+	datei->release();
+	return result;
 }
 
-Aktion* MapReader::readAktion( StreamReader& dat )
+Aktion* MapReader::readAktion(StreamReader& dat)
 {
-    int id;
-    dat.lese( (char*)&id, 4 );
-    char pAnz = 0;
-    dat.lese( &pAnz, 1 );
-    RCArray< Aktion >* params = new RCArray< Aktion >();
-    for( int i = 0; i < pAnz; i++ )
-        params->add( readAktion( dat ) );
-    switch( id )
-    {
-    case BARIERE_BEWEGUNG:
-        return new BariereBewegung( params );
-    case BARIERE_SET_EINGESCHALTET:
-        return new BariereSetEingeschaltet( params );
-    case GAME_OBJEKT_SET_POSITION:
-        return new GameObjektSetPosition( params );
-    case GAME_OBJEKT_SET_SIZE:
-        return new GameObjektSetSize( params );
-    case BARIERE_SET_TEAM:
-        return new BariereSetTeam( params );
-    case BARIERE_ZUFALL:
-        params->release();
-        return new BariereZufall();
-    case BARIERE_ZULETZT_AUSGESCHALTET:
-        params->release();
-        return new BariereZuletztAusgeschaltet();
-    case BARIERE_ZULETZT_BEWEGT:
-        params->release();
-        return new BariereZuletztBewegt();
-    case BARIERE_ZULETZT_EINGESCHALTET:
-        params->release();
-        return new BariereZuletztEingeschaltet();
-    case BASE_SET_TEAM:
-        return new BaseSetTeam( params );
-    case BASE_START_TEAM_CHANGE:
-        return new BaseStartTeamChange( params );
-    case BASE_ZUFALL:
-        params->release();
-        return new BaseZufall();
-    case BASE_ZULETZT_BESITZER_GEWECHSELT:
-        params->release();
-        return new BaseZuletztBesitzerGewechselt();
-    case BOOLEAN_AUS_TEXT:
-        return new BooleanAusText( params );
-    case BOOLEAN_BARIERE_BEWEGT_SICH:
-        return new BooleanBariereBewegtSich( params );
-    case BOOLEAN_BARIERE_IST_AKTIV:
-        return new BooleanBariereIstAktiv( params );
-    case BOOLEAN_BARIERE_IST_SCHALTEND:
-        return new BooleanBariereIstSchaltend( params );
-    case BOOLEAN_BASE_IST_NEUTRAL:
-        return new BooleanBaseIstNeutral( params );
-    case BOOLEAN_RECHNUNG:
-    {
-        char op;
-        dat.lese( &op, 1 );
-        return new BooleanRechnung( params, (Operator)op );
-    }
-    case BOOLEAN_SCHALTER_IST_AKTIV:
-        return new BooleanSchalterIstAktiv( params );
-    case BOOLEAN_SPIELER_AM_LEBEN:
-        return new BooleanSpielerAmLeben( params );
-    case BOOLEAN_SPIELER_HAT_GEGENSTAND:
-        return new BooleanSpielerHatGegenstand( params );
-    case BOOLEAN_SPIELER_IST_VERWUNDBAR:
-        return new BooleanSpielerIstVerwundbar( params );
-    case BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN:
-        return new BooleanSpielerKannItemBenutzen( params );
-    case BOOLEAN_SPIEL_PAUSIERT:
-        params->release();
-        return new BooleanSpielPausiert();
-    case BOOLEAN_TIMER_IS_RUNNING:
-        return new BooleanTimerIsRunning( params );
-    case BOOLEAN_TIMER_IST_SICHTBAR:
-        return new BooleanTimerIstSichtbar( params );
-    case BOOLEAN_TRIGGER_IST_AKTIV:
-        return new BooleanTriggerIstAktiv( params );
-    case BOOLEAN_TUNNEL_IST_AKTIV:
-        return new BooleanTunnelIstAktiv( params );
-    case BOOLEAN_UMLENKUNG_HAT_ABK:
-        return new BooleanUmlenkungHatAbk( params );
-    case BOOLEAN_UMLENKUNG_IST_DREHEND:
-        return new BooleanUmlenkungIstDrehend( params );
-    case BOOLEAN_ZUFALL:
-        params->release();
-        return new BooleanZufall();
-    case DISPLAY_TEXT:
-        return new DisplayText( params );
-    case DROP_DO_DROP:
-        return new DropDoDrop( params );
-    case DROP_SET_AREA:
-        return new DropSetArea( params );
-    case DROP_SET_MAX_TIME:
-        return new DropSetMaxTime( params );
-    case DROP_SET_TIME:
-        return new DropSetTime( params );
-    case DROP_ZUFALL:
-        params->release();
-        return new DropZufall();
-    case DROP_ZULETZT_GEDROPT:
-        params->release();
-        return new DropZuletztGedropt();
-    case GESCHOSS_NEU:
-        return new GeschossNeu( params );
-    case GESCHOSS_SET_PLAYER:
-        return new GeschossSetPlayer( params );
-    case GESCHOSS_SET_RICHTUNG:
-        return new GeschossSetRichtung( params );
-    case GESCHOSS_SET_SPEED:
-        return new GeschossSetSpeed( params );
-    case GESCHOSS_SET_TYPE:
-        return new GeschossSetType( params );
-    case GESCHOSS_ZUFALL:
-        params->release();
-        return new GeschossZufall();
-    case GESCHOSS_ZULETZT_ABGEFEUERT:
-        params->release();
-        return new GeschossZuletztAbgefeuert();
-    case GESCHOSS_ZULETZT_BARIERE_GETROFFEN:
-        params->release();
-        return new GeschossZuletztBarjereGetroffen();
-    case GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN:
-        params->release();
-        return new GeschossZuletztGeschossGetroffen();
-    case GESCHOSS_ZULETZT_TUNNEL_BENUTZT:
-        params->release();
-        return new GeschossZuletztTunnelBenutzt();
-    case GESCHOSS_ZULETZT_UMGELENKT:
-        params->release();
-        return new GeschossZuletztUmgelenkt();
-    case INTEGER_AUS_TEXT:
-        return new IntegerAusText( params );
-    case FLOAT_GAME_OBJEKT_BREITE:
-        return new FloatGameObjektBreite( params );
-    case FLOAT_GAME_OBJEKT_HEIGHT:
-        return new FloatGameObjektHeight( params );
-    case INTEGER_BARIERE_SCHALTUNGEN:
-        return new IntegerBariereSchaltungen( params );
-    case INTEGER_BARIERE_VERSCHIEBUNGEN:
-        return new IntegerBariereVerschiebungen( params );
-    case INTEGER_DROP_MAX_ZEIT:
-        return new IntegerDropMaxZeit( params );
-    case FLOAT_DROP_ZEIT:
-        return new FloatDropZeit( params );
-    case INTEGER_MAX_X_VON_DROP:
-        return new IntegerMaxXVonDrop( params );
-    case INTEGER_MAX_Y_VON_DROP:
-        return new IntegerMaxYVonDrop( params );
-    case INTEGER_MIN_X_VON_DROP:
-        return new IntegerMinXVonDrop( params );
-    case INTEGER_MIN_Y_VON_DROP:
-        return new IntegerMinYVonDrop( params );
-    case INTEGER_RECHNEN:
-    {
-        char op;
-        dat.lese( &op, 1 );
-        return new IntegerRechnen( params, (Operator)op );
-    }
-    case INTEGER_SCHALTER_AKTIVIERUNGEN:
-        return new IntegerSchalterAktivierungen( params );
-    case FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG:
-        return new FloatSpielerAbklingzeitVerringerung( params );
-    case FLOAT_SPIELER_ARMOR:
-        return new FloatSpielerArmor( params );
-    case FLOAT_SPIELER_ERFAHRUNG:
-        return new FloatSpielerErfahrung( params );
-    case FLOAT_SPIELER_ERLITTENER_SCHADEN:
-        return new FloatSpielerErlittenerSchaden( params );
-    case FLOAT_SPIELER_GEHEILTES_LEBEN:
-        return new FloatSpielerGeheiltesLeben( params );
-    case INTEGER_SPIELER_GESCHOSSEN:
-        return new IntegerSpielerGeschossen( params );
-    case FLOAT_SPIELER_GESCHOSS_TEMPO:
-        return new FloatSpielerGeschossTempo( params );
-    case INTEGER_SPIELER_GETROFFEN:
-        return new IntegerSpielerGetroffen( params );
-    case INTEGER_SPIELER_ITEMS_AUFGEHOBEN:
-        return new IntegerSpielerItemsAufgehoben( params );
-    case INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR:
-        return new IntegerSpielerItemsInInventar( params );
-    case INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP:
-        return new IntegerSpielerItemsTypeInInventar( params );
-    case INTEGER_SPIELER_ITEMS_VERWENDET:
-        return new IntegerSpielerItemsVerwendet( params );
-    case INTEGER_SPIELER_KILLS:
-        return new IntegerSpielerKills( params );
-    case FLOAT_SPIELER_LEBEN:
-        return new FloatSpielerLeben( params );
-    case FLOAT_SPIELER_LEBENSRAUB:
-        return new FloatSpielerLebensraub( params );
-    case FLOAT_SPIELER_LEBENSREGENERATION:
-        return new FloatSpielerLebensregeneration( params );
-    case INTEGER_SPIELER_LEVEL:
-        return new IntegerSpielerLevel( params );
-    case INTEGER_SPIELER_MAX_ERFAHRUNG:
-        return new IntegerSpielerMaxErfahrung( params );
-    case INTEGER_SPIELER_MAX_LEBEN:
-        return new IntegerSpielerMaxLeben( params );
-    case FLOAT_SPIELER_SCHADEN:
-        return new FloatSpielerSchaden( params );
-    case FLOAT_SPIELER_SCHADEN_BONUS:
-        return new FloatSpielerSchadenBonus( params );
-    case INTEGER_SPIELER_SCHALTER_AKTIVIERT:
-        return new IntegerSpielerSchalterAktiviert( params );
-    case FLOAT_SPIELER_TEMPO:
-        return new FloatSpielerTempo( params );
-    case INTEGER_SPIELER_TODE:
-        return new IntegerSpielerTode( params );
-    case INTEGER_SPIELER_TREFFER:
-        return new IntegerSpielerTreffer( params );
-    case INTEGER_SPIELER_TUNNEL_BENUTZT:
-        return new IntegerSpielerTunnelBenutzt( params );
-    case INTEGER_TEAM_KILLS:
-        return new IntegerTeamKills( params );
-    case INTEGER_TEAM_PUNKTE:
-        return new IntegerTeamPunkte( params );
-    case INTEGER_TEAM_SPIELERANZAHL:
-        return new IntegerTeamSpieleranzahl( params );
-    case INTEGER_TEAM_TODE:
-        return new IntegerTeamTode( params );
-    case FLOAT_TEAM_WIEDERBELEBUNGSZEIT:
-        return new FloatTeamWiederbelegungszeit( params );
-    case FLOAT_TIMER_AKTUELLE_ZEIT:
-        return new FloatTimerAktuelleZeit( params );
-    case INTEGER_TIMER_MAX_ZEIT:
-        return new IntegerTimerMaxZeit( params );
-    case INTEGER_TRIGGER_RUNNS:
-        return new IntegerTriggerRunns( params );
-    case INTEGER_TUNNEL_BENUTZUNGEN:
-        return new IntegerTunnelBenutzungen( params );
-    case INTEGER_UMLENKUNG_BENUTZUNGEN:
-        return new IntegerUmlenkungBenutzungen( params );
-    case FLOAT_X_VON_GAME_OBJEKT:
-        return new FloatXVonGameObjekt( params );
-    case FLOAT_Y_VON_GAME_OBJEKT:
-        return new FloatYVonGameObjekt( params );
-    case INTEGER_X_VON_TUNNEL_ZIEL:
-        return new IntegerXVonTunnelZiel( params );
-    case INTEGER_Y_VON_TUNNEL_ZIEL:
-        return new IntegerYVonTunnelZiel( params );
-    case INTEGER_ZUFALL:
-        return new IntegerZufall( params );
-    case ITEM_SPIELER_INVENTAR:
-        return new ItemSpielerInventar( params );
-    case ITEM_ZULETZT_AUFGEHOBEN:
-        params->release();
-        return new ItemZuletztAufgehoben();
-    case ITEM_ZULETZT_AKTIVIERT:
-        params->release();
-        return new ItemZuletztAktiviert();
-    case ITEM_ZULETZT_GEDROPT:
-        params->release();
-        return new ItemZuletztGedropt();
-    case ITEM_ZUFALL:
-        params->release();
-        return new ItemZufall();
-    case KONSTANT_BOOLEAN:
-    {
-        params->release();
-        bool b;
-        dat.lese( (char*)&b, 1 );
-        return new KonstantBoolean( b );
-    }
-    case KONSTANT_FLOAT:
-    {
-        params->release();
-        float f;
-        dat.lese( (char*)&f, 4 );
-        return new KonstantFloat( f );
-    }
-    case KONSTANT_INTEGER:
-    {
-        params->release();
-        int i;
-        dat.lese( (char*)&i, 4 );
-        return new KonstantInteger( i );
-    }
-    case KONSTANT_GEGENSTAND_TYP:
-    {
-        params->release();
-        int i;
-        dat.lese( (char*)&i, 4 );
-        return new KonstantGegenstandTyp( (GegenstandTyp)i );
-    }
-    case KONSTANT_TASTE:
-    {
-        params->release();
-        unsigned char i;
-        dat.lese( (char*)&i, 1 );
-        return new KonstantTaste( i );
-    }
-    case KONSTANT_NICHTS:
-        params->release();
-        return new KonstantNichts();
-    case KONSTANT_STRING:
-    {
-        params->release();
-        char len;
-        dat.lese( &len, 1 );
-        char* txt = new char[ (__int64)len + 1 ];
-        dat.lese( txt, len );
-        txt[ (int)len ] = 0;
-        Aktion* ret = new KonstantString( txt );
-        delete[] txt;
-        return ret;
-    }
-    case KONSTANT_VARIABLE:
-    {
-        params->release();
-        char len;
-        dat.lese( &len, 1 );
-        char* txt = new char[ (__int64)len + 1 ];
-        dat.lese( txt, len );
-        txt[ (int)len ] = 0;
-        Aktion* ret = new KonstantVariable( txt );
-        delete[] txt;
-        return ret;
-    }
-    case RICHTUNG_VON_GESCHOSS:
-        return new RichtungVonGeschoss( params );
-    case RICHTUNG_VON_UMLENKUNG:
-        return new RichtungVonUmlenkung( params );
-    case RICHTUNG_ZUFALL:
-        params->release();
-        return new RichtungZufall();
-    case SCHALTER_AKTIVIEREN:
-        return new SchalterAktivieren( params );
-    case SCHALTER_SET_ERLAUBT:
-        return new SchalterSetErlaubt( params );
-    case SCHALTER_ZUFALL:
-        params->release();
-        return new SchalterZufall();
-    case SCHALTER_ZULETZT_AKTIVIERT:
-        params->release();
-        return new SchalterZuletztAktiviert();
-    case SET_VARIABLE:
-    {
-        char len;
-        dat.lese( &len, 1 );
-        char* txt = new char[ (__int64)len + 1 ];
-        dat.lese( txt, len );
-        txt[ (int)len ] = 0;
-        Aktion* ret = new SetVariable( txt, params );
-        delete[] txt;
-        return ret;
-    }
-    case SPIEL_ENDE:
-        return new SpielEnde( params );
-    case SPIELER_GIVE_ITEM:
-        return new SpielerGiveItem( params );
-    case SPIELER_NACHRICHT:
-        return new SpielerNachricht( params );
-    case SPIELER_REMOVE_ITEM:
-        return new SpielerRemoveItem( params );
-    case SPIELER_SET_ABKLINGZEITVERRINGERUNG:
-        return new SpielerSetAbklingzeitverringerung( params );
-    case SPIELER_SET_ARMOR:
-        return new SpielerSetArmor( params );
-    case SPIELER_SET_ERFAHRUNG:
-        return new SpielerSetErfahrung( params );
-    case SPIELER_SET_LEBEN:
-        return new SpielerSetLeben( params );
-    case SPIELER_SET_LEBENSRAUB:
-        return new SpielerSetLebensraub( params );
-    case SPIELER_SET_LEBENSREGENERATION:
-        return new SpielerSetLebensraub( params );
-    case SPIELER_SET_LEVEL:
-        return new SpielerSetLevel( params );
-    case SPIELER_SET_MAX_ERFAHRUNG:
-        return new SpielerSetMaxErfahrung( params );
-    case SPIELER_SET_SCHADEN_BONUS:
-        return new SpielerSetSchadenBonus( params );
-    case SPIELER_SET_TEMPO:
-        return new SpielerSetTempo( params );
-    case SPIELER_SET_GESCHOSS_TEMPO:
-        return new SpielerSetWaffenTempo( params );
-    case SPIELER_ZUFALL:
-        params->release();
-        return new SpielerZufall();
-    case SPIELER_ZUFALL_AUS_TEAM:
-        return new SpielerZufallAusTeam( params );
-    case SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN:
-        return new SpielerZuletztErfahrungBekommen();
-    case SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT:
-        params->release();
-        return new SpielerZuletztGegenstandAktiviert();
-    case SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN:
-        params->release();
-        return new SpielerZuletztGegenstandAufgehoben();
-    case SPIELER_ZULETZT_GEHEILT:
-        params->release();
-        return new SpielerZuletztGeheilt();
-    case SPIELER_ZULETZT_GESCHOSSEN:
-        params->release();
-        return new SpielerZuletztGeschossGeschossen();
-    case SPIELER_ZULETZT_GESTORBEN:
-        params->release();
-        return new SpielerZuletztGestorben();
-    case SPIELER_ZULETZT_LEVEL_UP:
-        params->release();
-        return new SpielerZuletztLevelUp();
-    case SPIELER_ZULETZT_SCHADEN_GEMACHT:
-        params->release();
-        return new SpielerZuletztSchadenGemacht();
-    case SPIELER_ZULETZT_SCHADEN_GENOMMEN:
-        params->release();
-        return new SpielerZuletztSchadenGenommen();
-    case SPIELER_ZULETZT_SCHALTER_AKTIVIERT:
-        params->release();
-        return new SpielerZuletztSchalterAktiviert();
-    case SPIELER_ZULETZT_TUNNEL_BENUTZT:
-        params->release();
-        return new SpielerZuletztTunnelBenutzt();
-    case SPIELER_ZULETZT_WIEDERBELEBT:
-        params->release();
-        return new SpielerZuletztWiederbelebent();
-    case SPIEL_PAUSE:
-        return new SpielPause( params );
-    case TEAM_SET_PUNKTE:
-        return new TeamSetPunkte( params );
-    case TEAM_VON_BARIERE:
-        return new TeamVonBariere( params );
-    case TEAM_VON_SPIELER:
-        return new TeamVonSpieler( params );
-    case TEAM_ZUFALL:
-        params->release();
-        return new TeamZufall();
-    case TEXT_AUS_BOOLEAN:
-        return new TextAusBoolean( params );
-    case TEXT_AUS_RICHTUNG:
-        return new TextAusRichtung( params );
-    case TEXT_AUS_INTEGER:
-        return new TextAusInteger( params );
-    case TEXT_CONCAT:
-        return new TextConcat( params );
-    case TEXT_ITEM_NAME:
-        return new TextItemName( params );
-    case TEXT_SPIELER_NAME:
-        return new TextSpielerName( params );
-    case TEXT_TEIL_VON_TEXT:
-        return new TextTeilVonText( params );
-    case TEXT_TRIGGER_NAME:
-        return new TextTriggerName( params );
-    case TIMER_SET_PAUSE:
-        return new TimerSetPause( params );
-    case TIMER_SET_SICHTBAR:
-        return new TimerSetSichtbar( params );
-    case TIMER_SET_ZEIT:
-        return new TimerSetZeit( params );
-    case TIMER_START:
-        return new TimerStart( params );
-    case TIMER_ZUFALL:
-        params->release();
-        return new TimerZufall();
-    case TIMER_ZULETZT_ABGELAUFEN:
-        params->release();
-        return new TimerZuletztAbgelaufen();
-    case TIMER_ZULETZT_FOTOGRAFIERT:
-        params->release();
-        return new TimerZuletztFortgesetzt();
-    case TIMER_ZULETZT_GESTARTET:
-        params->release();
-        return new TimerZuletztGestartet();
-    case TIMER_ZULETZT_PAUSIERT:
-        params->release();
-        return new TimerZuletztPausiert();
-    case TRIGGER_AKTION:
-        return new TriggerAktion( params );
-    case TRIGGER_LAST_RUNNED:
-        params->release();
-        return new TriggerLastRunned();
-    case TRIGGER_RUN_START:
-        return new TriggerRunStart( params );
-    case TRIGGER_SET_ENABLED:
-        return new TriggerSetEnabled( params );
-    case TRIGGER_ZUFALL:
-        params->release();
-        return new TriggerZufall();
-    case TUNNEL_SET_ERLAUBT:
-        return new TunnelSetErlaubt( params );
-    case TUNNEL_SET_ZIEL_POSITION:
-        return new TunnelSetZielPosition( params );
-    case TUNNEL_ZUFALL:
-        params->release();
-        return new TunnelZufall();
-    case TUNNEL_ZULETZT_BENUTZT:
-        params->release();
-        return new TunnelZuletztBenutzt();
-    case UMLENKUNG_SET_ERLAUBT:
-        return new UmlenkungSetEnabled( params );
-    case UMLENKUNG_SET_MAX_ABK:
-        return new UmlenkungSetMaxAbk( params );
-    case UMLENKUNG_SET_RICHTUNG:
-        return new UmlenkungSetRichtung( params );
-    case UMLENKUNG_ZUFALL:
-        params->release();
-        return new UmlenkungZufall();
-    case UMLENKUNG_ZULETZT_BENUTZT:
-        params->release();
-        return new UmlenkungZuletztBenutzt();
-    case WARTEN:
-        return new Warten( params );
-    case WENN_DANN_SONST:
-        return new WennDannSonst( params );
-    case SEQUENZ:
-        return new Sequenz( params );
-    case FLOAT_RECHNUNG:
-    {
-        char op;
-        dat.lese( &op, 1 );
-        return new FloatRechnung( params, (Operator)op );
-    }
-    case FLOAT_AUS_INTEGER:
-        return new FloatAusInteger( params );
-    case FLOAT_AUS_TEXT:
-        return new FloatAusText( params );
-    case TEXT_AUS_FLOAT:
-        return new TextAusFloat( params );
-    case FLOAT_ZUFALL:
-        return new FloatZufall( params );
-    case INTEGER_AUS_FLOAT:
-        return new IntegerAusFloat( params );
-    case BESTENLISTE_NEU:
-        return new BestenlisteNeu( params );
-    case BESTENLISTE_ADD_SPALTE:
-        return new BestenlisteAddSpalte( params );
-    case BESTENLISTE_ADD_ZEILE:
-        return new BestenlisteAddZeile( params );
-    case BESTENLISTE_SET_WERT:
-        return new BestenlisteSetWert( params );
-    case BESTENLISTE_GET_WERT:
-        return new BestenlisteGetWert( params );
-    case SCHALTER_MIT_NUMMER:
-        return new SchalterMitNummer( params );
-    case BASE_MIT_NUMMER:
-        return new BaseMitNummer( params );
-    case TEAM_MIT_NUMMER:
-        return new TeamMitNummer( params );
-    case TEAM_VON_BASE:
-        return new TeamVonBase( params );
-    case SPIELER_MIT_NUMMER:
-        return new SpielerMitNummer( params );
-    }
-    params->release();
-    return new KonstantNichts();
+	int id;
+	dat.lese((char*)&id, 4);
+	char pAnz = 0;
+	dat.lese(&pAnz, 1);
+	RCArray< Aktion >* params = new RCArray< Aktion >();
+	for (int i = 0; i < pAnz; i++)
+		params->add(readAktion(dat));
+	switch (id)
+	{
+	case BARIERE_BEWEGUNG:
+		return new BariereBewegung(params);
+	case BARIERE_SET_EINGESCHALTET:
+		return new BariereSetEingeschaltet(params);
+	case GAME_OBJEKT_SET_POSITION:
+		return new GameObjektSetPosition(params);
+	case GAME_OBJEKT_SET_SIZE:
+		return new GameObjektSetSize(params);
+	case BARIERE_SET_TEAM:
+		return new BariereSetTeam(params);
+	case BARIERE_ZUFALL:
+		params->release();
+		return new BariereZufall();
+	case BARIERE_ZULETZT_AUSGESCHALTET:
+		params->release();
+		return new BariereZuletztAusgeschaltet();
+	case BARIERE_ZULETZT_BEWEGT:
+		params->release();
+		return new BariereZuletztBewegt();
+	case BARIERE_ZULETZT_EINGESCHALTET:
+		params->release();
+		return new BariereZuletztEingeschaltet();
+	case BASE_SET_TEAM:
+		return new BaseSetTeam(params);
+	case BASE_START_TEAM_CHANGE:
+		return new BaseStartTeamChange(params);
+	case BASE_ZUFALL:
+		params->release();
+		return new BaseZufall();
+	case BASE_ZULETZT_BESITZER_GEWECHSELT:
+		params->release();
+		return new BaseZuletztBesitzerGewechselt();
+	case BOOLEAN_AUS_TEXT:
+		return new BooleanAusText(params);
+	case BOOLEAN_BARIERE_BEWEGT_SICH:
+		return new BooleanBariereBewegtSich(params);
+	case BOOLEAN_BARIERE_IST_AKTIV:
+		return new BooleanBariereIstAktiv(params);
+	case BOOLEAN_BARIERE_IST_SCHALTEND:
+		return new BooleanBariereIstSchaltend(params);
+	case BOOLEAN_BASE_IST_NEUTRAL:
+		return new BooleanBaseIstNeutral(params);
+	case BOOLEAN_RECHNUNG:
+	{
+		char op;
+		dat.lese(&op, 1);
+		return new BooleanRechnung(params, (Operator)op);
+	}
+	case BOOLEAN_SCHALTER_IST_AKTIV:
+		return new BooleanSchalterIstAktiv(params);
+	case BOOLEAN_SPIELER_AM_LEBEN:
+		return new BooleanSpielerAmLeben(params);
+	case BOOLEAN_SPIELER_HAT_GEGENSTAND:
+		return new BooleanSpielerHatGegenstand(params);
+	case BOOLEAN_SPIELER_IST_VERWUNDBAR:
+		return new BooleanSpielerIstVerwundbar(params);
+	case BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN:
+		return new BooleanSpielerKannItemBenutzen(params);
+	case BOOLEAN_SPIEL_PAUSIERT:
+		params->release();
+		return new BooleanSpielPausiert();
+	case BOOLEAN_TIMER_IS_RUNNING:
+		return new BooleanTimerIsRunning(params);
+	case BOOLEAN_TIMER_IST_SICHTBAR:
+		return new BooleanTimerIstSichtbar(params);
+	case BOOLEAN_TRIGGER_IST_AKTIV:
+		return new BooleanTriggerIstAktiv(params);
+	case BOOLEAN_TUNNEL_IST_AKTIV:
+		return new BooleanTunnelIstAktiv(params);
+	case BOOLEAN_UMLENKUNG_HAT_ABK:
+		return new BooleanUmlenkungHatAbk(params);
+	case BOOLEAN_UMLENKUNG_IST_DREHEND:
+		return new BooleanUmlenkungIstDrehend(params);
+	case BOOLEAN_ZUFALL:
+		params->release();
+		return new BooleanZufall();
+	case DISPLAY_TEXT:
+		return new DisplayText(params);
+	case DROP_DO_DROP:
+		return new DropDoDrop(params);
+	case DROP_SET_AREA:
+		return new DropSetArea(params);
+	case DROP_SET_MAX_TIME:
+		return new DropSetMaxTime(params);
+	case DROP_SET_TIME:
+		return new DropSetTime(params);
+	case DROP_ZUFALL:
+		params->release();
+		return new DropZufall();
+	case DROP_ZULETZT_GEDROPT:
+		params->release();
+		return new DropZuletztGedropt();
+	case GESCHOSS_NEU:
+		return new GeschossNeu(params);
+	case GESCHOSS_SET_PLAYER:
+		return new GeschossSetPlayer(params);
+	case GESCHOSS_SET_RICHTUNG:
+		return new GeschossSetRichtung(params);
+	case GESCHOSS_SET_SPEED:
+		return new GeschossSetSpeed(params);
+	case GESCHOSS_SET_TYPE:
+		return new GeschossSetType(params);
+	case GESCHOSS_ZUFALL:
+		params->release();
+		return new GeschossZufall();
+	case GESCHOSS_ZULETZT_ABGEFEUERT:
+		params->release();
+		return new GeschossZuletztAbgefeuert();
+	case GESCHOSS_ZULETZT_BARIERE_GETROFFEN:
+		params->release();
+		return new GeschossZuletztBarjereGetroffen();
+	case GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN:
+		params->release();
+		return new GeschossZuletztGeschossGetroffen();
+	case GESCHOSS_ZULETZT_TUNNEL_BENUTZT:
+		params->release();
+		return new GeschossZuletztTunnelBenutzt();
+	case GESCHOSS_ZULETZT_UMGELENKT:
+		params->release();
+		return new GeschossZuletztUmgelenkt();
+	case INTEGER_AUS_TEXT:
+		return new IntegerAusText(params);
+	case FLOAT_GAME_OBJEKT_BREITE:
+		return new FloatGameObjektBreite(params);
+	case FLOAT_GAME_OBJEKT_HEIGHT:
+		return new FloatGameObjektHeight(params);
+	case INTEGER_BARIERE_SCHALTUNGEN:
+		return new IntegerBariereSchaltungen(params);
+	case INTEGER_BARIERE_VERSCHIEBUNGEN:
+		return new IntegerBariereVerschiebungen(params);
+	case INTEGER_DROP_MAX_ZEIT:
+		return new IntegerDropMaxZeit(params);
+	case FLOAT_DROP_ZEIT:
+		return new FloatDropZeit(params);
+	case INTEGER_MAX_X_VON_DROP:
+		return new IntegerMaxXVonDrop(params);
+	case INTEGER_MAX_Y_VON_DROP:
+		return new IntegerMaxYVonDrop(params);
+	case INTEGER_MIN_X_VON_DROP:
+		return new IntegerMinXVonDrop(params);
+	case INTEGER_MIN_Y_VON_DROP:
+		return new IntegerMinYVonDrop(params);
+	case INTEGER_RECHNEN:
+	{
+		char op;
+		dat.lese(&op, 1);
+		return new IntegerRechnen(params, (Operator)op);
+	}
+	case INTEGER_SCHALTER_AKTIVIERUNGEN:
+		return new IntegerSchalterAktivierungen(params);
+	case FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG:
+		return new FloatSpielerAbklingzeitVerringerung(params);
+	case FLOAT_SPIELER_ARMOR:
+		return new FloatSpielerArmor(params);
+	case FLOAT_SPIELER_ERFAHRUNG:
+		return new FloatSpielerErfahrung(params);
+	case FLOAT_SPIELER_ERLITTENER_SCHADEN:
+		return new FloatSpielerErlittenerSchaden(params);
+	case FLOAT_SPIELER_GEHEILTES_LEBEN:
+		return new FloatSpielerGeheiltesLeben(params);
+	case INTEGER_SPIELER_GESCHOSSEN:
+		return new IntegerSpielerGeschossen(params);
+	case FLOAT_SPIELER_GESCHOSS_TEMPO:
+		return new FloatSpielerGeschossTempo(params);
+	case INTEGER_SPIELER_GETROFFEN:
+		return new IntegerSpielerGetroffen(params);
+	case INTEGER_SPIELER_ITEMS_AUFGEHOBEN:
+		return new IntegerSpielerItemsAufgehoben(params);
+	case INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR:
+		return new IntegerSpielerItemsInInventar(params);
+	case INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP:
+		return new IntegerSpielerItemsTypeInInventar(params);
+	case INTEGER_SPIELER_ITEMS_VERWENDET:
+		return new IntegerSpielerItemsVerwendet(params);
+	case INTEGER_SPIELER_KILLS:
+		return new IntegerSpielerKills(params);
+	case FLOAT_SPIELER_LEBEN:
+		return new FloatSpielerLeben(params);
+	case FLOAT_SPIELER_LEBENSRAUB:
+		return new FloatSpielerLebensraub(params);
+	case FLOAT_SPIELER_LEBENSREGENERATION:
+		return new FloatSpielerLebensregeneration(params);
+	case INTEGER_SPIELER_LEVEL:
+		return new IntegerSpielerLevel(params);
+	case INTEGER_SPIELER_MAX_ERFAHRUNG:
+		return new IntegerSpielerMaxErfahrung(params);
+	case INTEGER_SPIELER_MAX_LEBEN:
+		return new IntegerSpielerMaxLeben(params);
+	case FLOAT_SPIELER_SCHADEN:
+		return new FloatSpielerSchaden(params);
+	case FLOAT_SPIELER_SCHADEN_BONUS:
+		return new FloatSpielerSchadenBonus(params);
+	case INTEGER_SPIELER_SCHALTER_AKTIVIERT:
+		return new IntegerSpielerSchalterAktiviert(params);
+	case FLOAT_SPIELER_TEMPO:
+		return new FloatSpielerTempo(params);
+	case INTEGER_SPIELER_TODE:
+		return new IntegerSpielerTode(params);
+	case INTEGER_SPIELER_TREFFER:
+		return new IntegerSpielerTreffer(params);
+	case INTEGER_SPIELER_TUNNEL_BENUTZT:
+		return new IntegerSpielerTunnelBenutzt(params);
+	case INTEGER_TEAM_KILLS:
+		return new IntegerTeamKills(params);
+	case INTEGER_TEAM_PUNKTE:
+		return new IntegerTeamPunkte(params);
+	case INTEGER_TEAM_SPIELERANZAHL:
+		return new IntegerTeamSpieleranzahl(params);
+	case INTEGER_TEAM_TODE:
+		return new IntegerTeamTode(params);
+	case FLOAT_TEAM_WIEDERBELEBUNGSZEIT:
+		return new FloatTeamWiederbelegungszeit(params);
+	case FLOAT_TIMER_AKTUELLE_ZEIT:
+		return new FloatTimerAktuelleZeit(params);
+	case INTEGER_TIMER_MAX_ZEIT:
+		return new IntegerTimerMaxZeit(params);
+	case INTEGER_TRIGGER_RUNNS:
+		return new IntegerTriggerRunns(params);
+	case INTEGER_TUNNEL_BENUTZUNGEN:
+		return new IntegerTunnelBenutzungen(params);
+	case INTEGER_UMLENKUNG_BENUTZUNGEN:
+		return new IntegerUmlenkungBenutzungen(params);
+	case FLOAT_X_VON_GAME_OBJEKT:
+		return new FloatXVonGameObjekt(params);
+	case FLOAT_Y_VON_GAME_OBJEKT:
+		return new FloatYVonGameObjekt(params);
+	case INTEGER_X_VON_TUNNEL_ZIEL:
+		return new IntegerXVonTunnelZiel(params);
+	case INTEGER_Y_VON_TUNNEL_ZIEL:
+		return new IntegerYVonTunnelZiel(params);
+	case INTEGER_ZUFALL:
+		return new IntegerZufall(params);
+	case ITEM_SPIELER_INVENTAR:
+		return new ItemSpielerInventar(params);
+	case ITEM_ZULETZT_AUFGEHOBEN:
+		params->release();
+		return new ItemZuletztAufgehoben();
+	case ITEM_ZULETZT_AKTIVIERT:
+		params->release();
+		return new ItemZuletztAktiviert();
+	case ITEM_ZULETZT_GEDROPT:
+		params->release();
+		return new ItemZuletztGedropt();
+	case ITEM_ZUFALL:
+		params->release();
+		return new ItemZufall();
+	case KONSTANT_BOOLEAN:
+	{
+		params->release();
+		bool b;
+		dat.lese((char*)&b, 1);
+		return new KonstantBoolean(b);
+	}
+	case KONSTANT_FLOAT:
+	{
+		params->release();
+		float f;
+		dat.lese((char*)&f, 4);
+		return new KonstantFloat(f);
+	}
+	case KONSTANT_INTEGER:
+	{
+		params->release();
+		int i;
+		dat.lese((char*)&i, 4);
+		return new KonstantInteger(i);
+	}
+	case KONSTANT_GEGENSTAND_TYP:
+	{
+		params->release();
+		int i;
+		dat.lese((char*)&i, 4);
+		return new KonstantGegenstandTyp((GegenstandTyp)i);
+	}
+	case KONSTANT_TASTE:
+	{
+		params->release();
+		unsigned char i;
+		dat.lese((char*)&i, 1);
+		return new KonstantTaste(i);
+	}
+	case KONSTANT_NICHTS:
+		params->release();
+		return new KonstantNichts();
+	case KONSTANT_STRING:
+	{
+		params->release();
+		char len;
+		dat.lese(&len, 1);
+		char* txt = new char[(__int64)len + 1];
+		dat.lese(txt, len);
+		txt[(int)len] = 0;
+		Aktion* ret = new KonstantString(txt);
+		delete[] txt;
+		return ret;
+	}
+	case KONSTANT_VARIABLE:
+	{
+		params->release();
+		char len;
+		dat.lese(&len, 1);
+		char* txt = new char[(__int64)len + 1];
+		dat.lese(txt, len);
+		txt[(int)len] = 0;
+		Aktion* ret = new KonstantVariable(txt);
+		delete[] txt;
+		return ret;
+	}
+	case RICHTUNG_VON_GESCHOSS:
+		return new RichtungVonGeschoss(params);
+	case RICHTUNG_VON_UMLENKUNG:
+		return new RichtungVonUmlenkung(params);
+	case RICHTUNG_ZUFALL:
+		params->release();
+		return new RichtungZufall();
+	case SCHALTER_AKTIVIEREN:
+		return new SchalterAktivieren(params);
+	case SCHALTER_SET_ERLAUBT:
+		return new SchalterSetErlaubt(params);
+	case SCHALTER_ZUFALL:
+		params->release();
+		return new SchalterZufall();
+	case SCHALTER_ZULETZT_AKTIVIERT:
+		params->release();
+		return new SchalterZuletztAktiviert();
+	case SET_VARIABLE:
+	{
+		char len;
+		dat.lese(&len, 1);
+		char* txt = new char[(__int64)len + 1];
+		dat.lese(txt, len);
+		txt[(int)len] = 0;
+		Aktion* ret = new SetVariable(txt, params);
+		delete[] txt;
+		return ret;
+	}
+	case SPIEL_ENDE:
+		return new SpielEnde(params);
+	case SPIELER_GIVE_ITEM:
+		return new SpielerGiveItem(params);
+	case SPIELER_NACHRICHT:
+		return new SpielerNachricht(params);
+	case SPIELER_REMOVE_ITEM:
+		return new SpielerRemoveItem(params);
+	case SPIELER_SET_ABKLINGZEITVERRINGERUNG:
+		return new SpielerSetAbklingzeitverringerung(params);
+	case SPIELER_SET_ARMOR:
+		return new SpielerSetArmor(params);
+	case SPIELER_SET_ERFAHRUNG:
+		return new SpielerSetErfahrung(params);
+	case SPIELER_SET_LEBEN:
+		return new SpielerSetLeben(params);
+	case SPIELER_SET_LEBENSRAUB:
+		return new SpielerSetLebensraub(params);
+	case SPIELER_SET_LEBENSREGENERATION:
+		return new SpielerSetLebensraub(params);
+	case SPIELER_SET_LEVEL:
+		return new SpielerSetLevel(params);
+	case SPIELER_SET_MAX_ERFAHRUNG:
+		return new SpielerSetMaxErfahrung(params);
+	case SPIELER_SET_SCHADEN_BONUS:
+		return new SpielerSetSchadenBonus(params);
+	case SPIELER_SET_TEMPO:
+		return new SpielerSetTempo(params);
+	case SPIELER_SET_GESCHOSS_TEMPO:
+		return new SpielerSetWaffenTempo(params);
+	case SPIELER_ZUFALL:
+		params->release();
+		return new SpielerZufall();
+	case SPIELER_ZUFALL_AUS_TEAM:
+		return new SpielerZufallAusTeam(params);
+	case SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN:
+		return new SpielerZuletztErfahrungBekommen();
+	case SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT:
+		params->release();
+		return new SpielerZuletztGegenstandAktiviert();
+	case SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN:
+		params->release();
+		return new SpielerZuletztGegenstandAufgehoben();
+	case SPIELER_ZULETZT_GEHEILT:
+		params->release();
+		return new SpielerZuletztGeheilt();
+	case SPIELER_ZULETZT_GESCHOSSEN:
+		params->release();
+		return new SpielerZuletztGeschossGeschossen();
+	case SPIELER_ZULETZT_GESTORBEN:
+		params->release();
+		return new SpielerZuletztGestorben();
+	case SPIELER_ZULETZT_LEVEL_UP:
+		params->release();
+		return new SpielerZuletztLevelUp();
+	case SPIELER_ZULETZT_SCHADEN_GEMACHT:
+		params->release();
+		return new SpielerZuletztSchadenGemacht();
+	case SPIELER_ZULETZT_SCHADEN_GENOMMEN:
+		params->release();
+		return new SpielerZuletztSchadenGenommen();
+	case SPIELER_ZULETZT_SCHALTER_AKTIVIERT:
+		params->release();
+		return new SpielerZuletztSchalterAktiviert();
+	case SPIELER_ZULETZT_TUNNEL_BENUTZT:
+		params->release();
+		return new SpielerZuletztTunnelBenutzt();
+	case SPIELER_ZULETZT_WIEDERBELEBT:
+		params->release();
+		return new SpielerZuletztWiederbelebent();
+	case SPIEL_PAUSE:
+		return new SpielPause(params);
+	case TEAM_SET_PUNKTE:
+		return new TeamSetPunkte(params);
+	case TEAM_VON_BARIERE:
+		return new TeamVonBariere(params);
+	case TEAM_VON_SPIELER:
+		return new TeamVonSpieler(params);
+	case TEAM_ZUFALL:
+		params->release();
+		return new TeamZufall();
+	case TEXT_AUS_BOOLEAN:
+		return new TextAusBoolean(params);
+	case TEXT_AUS_RICHTUNG:
+		return new TextAusRichtung(params);
+	case TEXT_AUS_INTEGER:
+		return new TextAusInteger(params);
+	case TEXT_CONCAT:
+		return new TextConcat(params);
+	case TEXT_ITEM_NAME:
+		return new TextItemName(params);
+	case TEXT_SPIELER_NAME:
+		return new TextSpielerName(params);
+	case TEXT_TEIL_VON_TEXT:
+		return new TextTeilVonText(params);
+	case TEXT_TRIGGER_NAME:
+		return new TextTriggerName(params);
+	case TIMER_SET_PAUSE:
+		return new TimerSetPause(params);
+	case TIMER_SET_SICHTBAR:
+		return new TimerSetSichtbar(params);
+	case TIMER_SET_ZEIT:
+		return new TimerSetZeit(params);
+	case TIMER_START:
+		return new TimerStart(params);
+	case TIMER_ZUFALL:
+		params->release();
+		return new TimerZufall();
+	case TIMER_ZULETZT_ABGELAUFEN:
+		params->release();
+		return new TimerZuletztAbgelaufen();
+	case TIMER_ZULETZT_FOTOGRAFIERT:
+		params->release();
+		return new TimerZuletztFortgesetzt();
+	case TIMER_ZULETZT_GESTARTET:
+		params->release();
+		return new TimerZuletztGestartet();
+	case TIMER_ZULETZT_PAUSIERT:
+		params->release();
+		return new TimerZuletztPausiert();
+	case TRIGGER_AKTION:
+		return new TriggerAktion(params);
+	case TRIGGER_LAST_RUNNED:
+		params->release();
+		return new TriggerLastRunned();
+	case TRIGGER_RUN_START:
+		return new TriggerRunStart(params);
+	case TRIGGER_SET_ENABLED:
+		return new TriggerSetEnabled(params);
+	case TRIGGER_ZUFALL:
+		params->release();
+		return new TriggerZufall();
+	case TUNNEL_SET_ERLAUBT:
+		return new TunnelSetErlaubt(params);
+	case TUNNEL_SET_ZIEL_POSITION:
+		return new TunnelSetZielPosition(params);
+	case TUNNEL_ZUFALL:
+		params->release();
+		return new TunnelZufall();
+	case TUNNEL_ZULETZT_BENUTZT:
+		params->release();
+		return new TunnelZuletztBenutzt();
+	case UMLENKUNG_SET_ERLAUBT:
+		return new UmlenkungSetEnabled(params);
+	case UMLENKUNG_SET_MAX_ABK:
+		return new UmlenkungSetMaxAbk(params);
+	case UMLENKUNG_SET_RICHTUNG:
+		return new UmlenkungSetRichtung(params);
+	case UMLENKUNG_ZUFALL:
+		params->release();
+		return new UmlenkungZufall();
+	case UMLENKUNG_ZULETZT_BENUTZT:
+		params->release();
+		return new UmlenkungZuletztBenutzt();
+	case WARTEN:
+		return new Warten(params);
+	case WENN_DANN_SONST:
+		return new WennDannSonst(params);
+	case SEQUENZ:
+		return new Sequenz(params);
+	case FLOAT_RECHNUNG:
+	{
+		char op;
+		dat.lese(&op, 1);
+		return new FloatRechnung(params, (Operator)op);
+	}
+	case FLOAT_AUS_INTEGER:
+		return new FloatAusInteger(params);
+	case FLOAT_AUS_TEXT:
+		return new FloatAusText(params);
+	case TEXT_AUS_FLOAT:
+		return new TextAusFloat(params);
+	case FLOAT_ZUFALL:
+		return new FloatZufall(params);
+	case INTEGER_AUS_FLOAT:
+		return new IntegerAusFloat(params);
+	case BESTENLISTE_NEU:
+		return new BestenlisteNeu(params);
+	case BESTENLISTE_ADD_SPALTE:
+		return new BestenlisteAddSpalte(params);
+	case BESTENLISTE_ADD_ZEILE:
+		return new BestenlisteAddZeile(params);
+	case BESTENLISTE_SET_WERT:
+		return new BestenlisteSetWert(params);
+	case BESTENLISTE_GET_WERT:
+		return new BestenlisteGetWert(params);
+	case SCHALTER_MIT_NUMMER:
+		return new SchalterMitNummer(params);
+	case BASE_MIT_NUMMER:
+		return new BaseMitNummer(params);
+	case TEAM_MIT_NUMMER:
+		return new TeamMitNummer(params);
+	case TEAM_VON_BASE:
+		return new TeamVonBase(params);
+	case SPIELER_MIT_NUMMER:
+		return new SpielerMitNummer(params);
+	}
+	params->release();
+	return new KonstantNichts();
 }
 
-void MapReader::writeAktion( Aktion* zAk, StreamWriter& dat )
+void MapReader::writeAktion(Aktion* zAk, StreamWriter& dat)
 {
-    int id = zAk->getTyp();
-    dat.schreibe( (char*)&id, 4 );
-    unsigned char pAnz = (unsigned char)zAk->zSubActions()->getEintragAnzahl();
-    dat.schreibe( (char*)&pAnz, 1 );
-    for( auto e : *zAk->zSubActions() )
-    {
-        writeAktion( e, dat );
-        e->writeOptions( dat );
-    }
+	int id = zAk->getTyp();
+	dat.schreibe((char*)&id, 4);
+	unsigned char pAnz = (unsigned char)zAk->zSubActions()->getEintragAnzahl();
+	dat.schreibe((char*)&pAnz, 1);
+	for (auto e : *zAk->zSubActions())
+	{
+		writeAktion(e, dat);
+		e->writeOptions(dat);
+	}
 }
 
 // nicht constant
-void MapReader::ladeKarte( Spiel* zSpiel )
+void MapReader::ladeKarte(Spiel* zSpiel)
 {
-    if( !pfad )
-        return;
-    SpielerTeamStruktur sts;
-    Text* pf = new Text( pfad->getText() );
-    pf->append( "data.sts" );
-    Datei* datei = new Datei();
-    datei->setDatei( pf );
-    if( !datei->existiert() || datei->istOrdner() )
-    {
-        datei->release();
-        return;
-    }
-    datei->open( Datei::Style::lesen );
-    datei->lese( (char*)&sts.spielerAnzahl, 4 );
-    datei->lese( (char*)&sts.teamAnzahl, 4 );
-    for( int i = 0; i < sts.spielerAnzahl; i++ )
-    {
-        int farbe = 0;
-        datei->lese( (char*)&farbe, 4 );
-        sts.spielerFarbe.set( farbe, i );
-    }
-    for( int i = 0; i < sts.teamAnzahl; i++ )
-    {
-        int farbe = 0;
-        datei->lese( (char*)&farbe, 4 );
-        sts.teamFarbe.set( farbe, i );
-    }
-    for( int i = 0; i < sts.teamAnzahl; i++ )
-    {
-        char len = 0;
-        datei->lese( &len, 1 );
-        char* txt = new char[ (__int64)len + 1 ];
-        txt[ (int)len ] = 0;
-        datei->lese( txt, len );
-        Text* name = new Text( txt );
-        delete[] txt;
-        sts.teamName.set( name, i );
-    }
-    for( int i = 0; i < sts.teamAnzahl; i++ )
-    {
-        int size = 0;
-        datei->lese( (char*)&size, 4 );
-        sts.teamSize.set( size, i );
-    }
-    datei->close();
-    datei->release();
-    pf = new Text( pfad->getText() );
-    pf->append( "data.map" );
-    Datei mapFile;
-    mapFile.setDatei( pf );
-    if( !mapFile.existiert() || mapFile.istOrdner() )
-        return;
-    mapFile.open( Datei::Style::lesen );
-    // map Size
-    int width;
-    int height;
-    mapFile.lese( (char*)&width, 4 );
-    mapFile.lese( (char*)&height, 4 );
-    zSpiel->setMapSize( width, height );
-    // teams
-    for( int i = 0; i < sts.teamAnzahl; i++ )
-    {
-        int maxWbZeit;
-        int punkte;
-        mapFile.lese( (char*)&maxWbZeit, 4 );
-        mapFile.lese( (char*)&punkte, 4 );
-        zSpiel->addTeam( new Team( i, sts.teamSize.get( i ), punkte, maxWbZeit, sts.teamFarbe.get( i ), sts.teamName.z( i )->getText() ) );
-    }
-    // spieler
-    int team = 0;
-    int maxT = sts.teamSize.get( team );
-    for( int i = 0; i < sts.spielerAnzahl; i++ )
-    {
-        int spawnX;
-        int spawnY;
-        mapFile.lese( (char*)&spawnX, 4 );
-        mapFile.lese( (char*)&spawnY, 4 );
-        if( i >= maxT )
-        {
-            team++;
-            if( sts.teamSize.hat( team ) )
-                maxT += sts.teamSize.get( team );
-        }
-        zSpiel->addSpieler( new Spieler( zSpiel->zResources(), i, zSpiel->getTeam( team ), spawnX, spawnY, sts.spielerFarbe.get( i ) ) );
-    }
-    // Barieren
-    int anz = 0;
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        int style;
-        int verschiebungWeite;
-        int autoSchaltungMaxTime;
-        int team;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        mapFile.lese( (char*)&style, 4 );
-        mapFile.lese( (char*)&verschiebungWeite, 4 );
-        mapFile.lese( (char*)&autoSchaltungMaxTime, 4 );
-        mapFile.lese( (char*)&team, 4 );
-        zSpiel->addBariere( new Bariere( zSpiel->zResources(), id, x, y, breite, height, style, verschiebungWeite, autoSchaltungMaxTime, zSpiel->getTeam( team ) ) );
-    }
-    // Basen
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        int maxTime;
-        int team;
-        int id;
-        bool showTimer;
-        int timerX;
-        int timerY;
-        int timerFarbe;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        mapFile.lese( (char*)&maxTime, 4 );
-        mapFile.lese( (char*)&team, 4 );
-        mapFile.lese( (char*)&showTimer, 1 );
-        mapFile.lese( (char*)&timerX, 4 );
-        mapFile.lese( (char*)&timerY, 4 );
-        mapFile.lese( (char*)&timerFarbe, 4 );
-        zSpiel->addBase( new Base( zSpiel->zResources(), id, x, y, breite, height, showTimer, Punkt( timerX, timerY ), timerFarbe, new TextRenderer( dynamic_cast<Schrift*>(zSpiel->zResources()->getUIFactory().initParam.schrift->getThis()) ), maxTime, zSpiel->getTeam( team ) ) );
-    }
-    // Drops
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int minX;
-        int minY;
-        int maxX;
-        int maxY;
-        int maxTime;
-        int numDrops;
-        float wahrscheinlichkeit[ ITEMANZAHL ];
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&minX, 4 );
-        mapFile.lese( (char*)&minY, 4 );
-        mapFile.lese( (char*)&maxX, 4 );
-        mapFile.lese( (char*)&maxY, 4 );
-        mapFile.lese( (char*)&maxTime, 4 );
-        mapFile.lese( (char*)&numDrops, 4 );
-        for( int j = KEIN_GEGENSTAND; j < ITEMANZAHL; j++ )
-            mapFile.lese( (char*)&wahrscheinlichkeit[ j ], 4 );
-        char len;
-        mapFile.lese( (char*)&len, 1 );
-        char* name = new char[ (__int64)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        zSpiel->addDrop( new Drop( id, minX, maxX, minY, maxY, maxTime, numDrops, name, wahrscheinlichkeit ) );
-        delete[] name;
-    }
-    // Schalter
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        bool aktive;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        mapFile.lese( (char*)&aktive, 1 );
-        zSpiel->addSchalter( new Schalter( zSpiel->zResources(), id, x, y, breite, height, aktive ) );
-    }
-    // Schiene
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        zSpiel->addSchiene( new Schiene( zSpiel->zResources(), id, x, y, breite, height ) );
-    }
-    // Timer
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int maxZeit;
-        bool sichtbar;
-        bool autoWiederhohlung;
-        bool runns;
-        int farbe;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&maxZeit, 4 );
-        mapFile.lese( (char*)&sichtbar, 1 );
-        mapFile.lese( (char*)&autoWiederhohlung, 1 );
-        mapFile.lese( (char*)&runns, 1 );
-        mapFile.lese( (char*)&farbe, 4 );
-        char len;
-        mapFile.lese( (char*)&len, 1 );
-        char* name = new char[ (__int64)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        zSpiel->addTimer( new Timer( zSpiel->zResources()->getUIFactory().initParam.schrift, id, name, maxZeit, x, y, sichtbar, autoWiederhohlung, runns, farbe ) );
-        delete[] name;
-    }
-    // Tunnel
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        int zielX;
-        int zielY;
-        bool aktiv;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        mapFile.lese( (char*)&zielX, 4 );
-        mapFile.lese( (char*)&zielY, 4 );
-        mapFile.lese( (char*)&aktiv, 1 );
-        zSpiel->addTunnel( new Tunnel( zSpiel->zResources(), id, x, y, breite, height, zielX, zielY, aktiv ) );
-    }
-    // Umlenkungen
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int x;
-        int y;
-        int breite;
-        int height;
-        char richtung;
-        int maxAbklingzeit;
-        bool drehend;
-        bool aktiv;
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        mapFile.lese( (char*)&x, 4 );
-        mapFile.lese( (char*)&y, 4 );
-        mapFile.lese( (char*)&breite, 4 );
-        mapFile.lese( (char*)&height, 4 );
-        mapFile.lese( (char*)&richtung, 1 );
-        mapFile.lese( (char*)&maxAbklingzeit, 4 );
-        mapFile.lese( (char*)&drehend, 1 );
-        mapFile.lese( (char*)&aktiv, 1 );
-        zSpiel->addUmlenkung( new Umlenkung( zSpiel->zResources(), id, x, y, breite, height, (Richtung)richtung, maxAbklingzeit, drehend, aktiv ) );
-    }
-    // Trigger
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        int id;
-        mapFile.lese( (char*)&id, 4 );
-        char len;
-        mapFile.lese( (char*)&len, 1 );
-        char* name = new char[ (__int64)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        int ereignisAnzahl;
-        int bedingungAnzahl;
-        int aktionAnzahl;
-        mapFile.lese( (char*)&ereignisAnzahl, 4 );
-        mapFile.lese( (char*)&bedingungAnzahl, 4 );
-        mapFile.lese( (char*)&aktionAnzahl, 4 );
-        EreignisTyp* ereignisse = new EreignisTyp[ ereignisAnzahl ];
-        for( int j = 0; j < ereignisAnzahl; j++ )
-            mapFile.lese( (char*)&ereignisse[ j ], 4 );
-        RCArray< Bedingung >* bedingungen = new RCArray< Bedingung >();
-        for( int j = 0; j < bedingungAnzahl; j++ )
-            bedingungen->add( new Bedingung( readAktion( mapFile ) ) );
-        RCArray< Aktion >* aktionen = new RCArray< Aktion >();
-        for( int j = 0; j < aktionAnzahl; j++ )
-            aktionen->add( readAktion( mapFile ) );
-        zSpiel->addTrigger( new Trigger( id, name, ereignisAnzahl, ereignisse, bedingungen, aktionen ) );
-        delete[] name;
-    }
-    // Variablen
-    mapFile.lese( (char*)&anz, 4 );
-    for( int i = 0; i < anz; i++ )
-    {
-        char len;
-        mapFile.lese( (char*)&len, 1 );
-        char* name = new char[ (__int64)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        char typ;
-        mapFile.lese( &typ, 1 );
-        char def;
-        mapFile.lese( &def, 1 );
-        Variable* var = 0;
-        if( !def )
-            var = new Variable( NICHTS );
-        else
-        {
-            switch( typ )
-            {
-            case NICHTS:
-                var = new Variable( NICHTS );
-                break;
-            case INTEGER:
-            {
-                int val;
-                mapFile.lese( (char*)&val, 4 );
-                var = new Integer( val );
-                break;
-            }
-            case BOOLEAN:
-            {
-                bool val;
-                mapFile.lese( (char*)&val, 1 );
-                var = new Boolean( val );
-                break;
-            }
-            case STRING:
-            {
-                char len;
-                mapFile.lese( (char*)&len, 1 );
-                char* value = new char[ (__int64)len + 1 ];
-                mapFile.lese( value, len );
-                value[ (int)len ] = 0;
-                var = new String( value );
-                delete[] value;
-                break;
-            }
-            case RICHTUNG:
-            {
-                char len;
-                mapFile.lese( (char*)&len, 1 );
-                char* value = new char[ (__int64)len + 1 ];
-                mapFile.lese( value, len );
-                value[ (int)len ] = 0;
-                var = new String( getRichtungFromString( Text( value ) ) );
-                delete[] value;
-                break;
-            }
-            case FLOAT:
-            {
-                float val;
-                mapFile.lese( (char*)&val, 4 );
-                var = new Float( val );
-                break;
-            }
-            case TASTE:
-            {
-                char val;
-                mapFile.lese( &val, 1 );
-                var = new Integer( val, 1 );
-                break;
-            }
-            case SPIELER:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getSpieler( id );
-                break;
-            }
-            case TIMER:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getTimer( id );
-                break;
-            }
-            case TEAM:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getTeam( id );
-                break;
-            }
-            case BARIERE:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getBariere( id );
-                break;
-            }
-            case SCHALTER:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getSchalter( id );
-                break;
-            }
-            case BASE:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getBase( id );
-                break;
-            }
-            case GEGENSTAND:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = new GegenstandTypVar( (GegenstandTyp)id );
-                break;
-            }
-            case SCHIENE:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getSchiene( id );
-                break;
-            }
-            case TUNNEL:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getTunnel( id );
-                break;
-            }
-            case UMLENKUNG:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getUmlenkung( id );
-                break;
-            }
-            case TRIGGER:
-            {
-                int id;
-                mapFile.lese( (char*)&id, 4 );
-                var = zSpiel->getTrigger( id );
-                break;
-            }
-            default:
-                var = new Variable( NICHTS );
-            }
-        }
-        zSpiel->addVariable( name, var );
-        delete[] name;
-    }
-    mapFile.close();
+	if (!pfad)
+		return;
+	SpielerTeamStruktur sts;
+	Text* pf = new Text(pfad->getText());
+	pf->append("data.sts");
+	Datei* datei = new Datei();
+	datei->setDatei(pf);
+	if (!datei->existiert() || datei->istOrdner())
+	{
+		datei->release();
+		return;
+	}
+	datei->open(Datei::Style::lesen);
+	datei->lese((char*)&sts.spielerAnzahl, 4);
+	datei->lese((char*)&sts.teamAnzahl, 4);
+	for (int i = 0; i < sts.spielerAnzahl; i++)
+	{
+		int farbe = 0;
+		datei->lese((char*)&farbe, 4);
+		sts.spielerFarbe.set(farbe, i);
+	}
+	for (int i = 0; i < sts.teamAnzahl; i++)
+	{
+		int farbe = 0;
+		datei->lese((char*)&farbe, 4);
+		sts.teamFarbe.set(farbe, i);
+	}
+	for (int i = 0; i < sts.teamAnzahl; i++)
+	{
+		char len = 0;
+		datei->lese(&len, 1);
+		char* txt = new char[(__int64)len + 1];
+		txt[(int)len] = 0;
+		datei->lese(txt, len);
+		Text* name = new Text(txt);
+		delete[] txt;
+		sts.teamName.set(name, i);
+	}
+	for (int i = 0; i < sts.teamAnzahl; i++)
+	{
+		int size = 0;
+		datei->lese((char*)&size, 4);
+		sts.teamSize.set(size, i);
+	}
+	datei->close();
+	datei->release();
+	pf = new Text(pfad->getText());
+	pf->append("data.map");
+	Datei mapFile;
+	mapFile.setDatei(pf);
+	if (!mapFile.existiert() || mapFile.istOrdner())
+		return;
+	mapFile.open(Datei::Style::lesen);
+	// map Size
+	int width;
+	int height;
+	mapFile.lese((char*)&width, 4);
+	mapFile.lese((char*)&height, 4);
+	zSpiel->setMapSize(width, height);
+	// teams
+	for (int i = 0; i < sts.teamAnzahl; i++)
+	{
+		int maxWbZeit;
+		int punkte;
+		mapFile.lese((char*)&maxWbZeit, 4);
+		mapFile.lese((char*)&punkte, 4);
+		zSpiel->addTeam(new Team(i, sts.teamSize.get(i), punkte, maxWbZeit, sts.teamFarbe.get(i), sts.teamName.z(i)->getText()));
+	}
+	// spieler
+	int team = 0;
+	int maxT = sts.teamSize.get(team);
+	for (int i = 0; i < sts.spielerAnzahl; i++)
+	{
+		int spawnX;
+		int spawnY;
+		mapFile.lese((char*)&spawnX, 4);
+		mapFile.lese((char*)&spawnY, 4);
+		if (i >= maxT)
+		{
+			team++;
+			if (sts.teamSize.hat(team))
+				maxT += sts.teamSize.get(team);
+		}
+		zSpiel->addSpieler(new Spieler(zSpiel->zResources(), i, zSpiel->getTeam(team), spawnX, spawnY, sts.spielerFarbe.get(i)));
+	}
+	// Barieren
+	int anz = 0;
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		int style;
+		int verschiebungWeite;
+		int autoSchaltungMaxTime;
+		int team;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		mapFile.lese((char*)&style, 4);
+		mapFile.lese((char*)&verschiebungWeite, 4);
+		mapFile.lese((char*)&autoSchaltungMaxTime, 4);
+		mapFile.lese((char*)&team, 4);
+		zSpiel->addBariere(new Bariere(zSpiel->zResources(), id, x, y, breite, height, style, verschiebungWeite, autoSchaltungMaxTime, zSpiel->getTeam(team)));
+	}
+	// Basen
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		int maxTime;
+		int team;
+		int id;
+		bool showTimer;
+		int timerX;
+		int timerY;
+		int timerFarbe;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		mapFile.lese((char*)&maxTime, 4);
+		mapFile.lese((char*)&team, 4);
+		mapFile.lese((char*)&showTimer, 1);
+		mapFile.lese((char*)&timerX, 4);
+		mapFile.lese((char*)&timerY, 4);
+		mapFile.lese((char*)&timerFarbe, 4);
+		zSpiel->addBase(new Base(zSpiel->zResources(), id, x, y, breite, height, showTimer, Punkt(timerX, timerY), timerFarbe, new TextRenderer(dynamic_cast<Schrift*>(zSpiel->zResources()->getUIFactory().initParam.schrift->getThis())), maxTime, zSpiel->getTeam(team)));
+	}
+	// Drops
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int minX;
+		int minY;
+		int maxX;
+		int maxY;
+		int maxTime;
+		int numDrops;
+		float wahrscheinlichkeit[ITEMANZAHL];
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&minX, 4);
+		mapFile.lese((char*)&minY, 4);
+		mapFile.lese((char*)&maxX, 4);
+		mapFile.lese((char*)&maxY, 4);
+		mapFile.lese((char*)&maxTime, 4);
+		mapFile.lese((char*)&numDrops, 4);
+		for (int j = KEIN_GEGENSTAND; j < ITEMANZAHL; j++)
+			mapFile.lese((char*)&wahrscheinlichkeit[j], 4);
+		char len;
+		mapFile.lese((char*)&len, 1);
+		char* name = new char[(__int64)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		zSpiel->addDrop(new Drop(id, minX, maxX, minY, maxY, maxTime, numDrops, name, wahrscheinlichkeit));
+		delete[] name;
+	}
+	// Schalter
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		bool aktive;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		mapFile.lese((char*)&aktive, 1);
+		zSpiel->addSchalter(new Schalter(zSpiel->zResources(), id, x, y, breite, height, aktive));
+	}
+	// Schiene
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		zSpiel->addSchiene(new Schiene(zSpiel->zResources(), id, x, y, breite, height));
+	}
+	// Timer
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int maxZeit;
+		bool sichtbar;
+		bool autoWiederhohlung;
+		bool runns;
+		int farbe;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&maxZeit, 4);
+		mapFile.lese((char*)&sichtbar, 1);
+		mapFile.lese((char*)&autoWiederhohlung, 1);
+		mapFile.lese((char*)&runns, 1);
+		mapFile.lese((char*)&farbe, 4);
+		char len;
+		mapFile.lese((char*)&len, 1);
+		char* name = new char[(__int64)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		zSpiel->addTimer(new Timer(zSpiel->zResources()->getUIFactory().initParam.schrift, id, name, maxZeit, x, y, sichtbar, autoWiederhohlung, runns, farbe));
+		delete[] name;
+	}
+	// Tunnel
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		int zielX;
+		int zielY;
+		bool aktiv;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		mapFile.lese((char*)&zielX, 4);
+		mapFile.lese((char*)&zielY, 4);
+		mapFile.lese((char*)&aktiv, 1);
+		zSpiel->addTunnel(new Tunnel(zSpiel->zResources(), id, x, y, breite, height, zielX, zielY, aktiv));
+	}
+	// Umlenkungen
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int x;
+		int y;
+		int breite;
+		int height;
+		char richtung;
+		int maxAbklingzeit;
+		bool drehend;
+		bool aktiv;
+		int id;
+		mapFile.lese((char*)&id, 4);
+		mapFile.lese((char*)&x, 4);
+		mapFile.lese((char*)&y, 4);
+		mapFile.lese((char*)&breite, 4);
+		mapFile.lese((char*)&height, 4);
+		mapFile.lese((char*)&richtung, 1);
+		mapFile.lese((char*)&maxAbklingzeit, 4);
+		mapFile.lese((char*)&drehend, 1);
+		mapFile.lese((char*)&aktiv, 1);
+		zSpiel->addUmlenkung(new Umlenkung(zSpiel->zResources(), id, x, y, breite, height, (Richtung)richtung, maxAbklingzeit, drehend, aktiv));
+	}
+	// Trigger
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		int id;
+		mapFile.lese((char*)&id, 4);
+		char len;
+		mapFile.lese((char*)&len, 1);
+		char* name = new char[(__int64)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		int ereignisAnzahl;
+		int bedingungAnzahl;
+		int aktionAnzahl;
+		mapFile.lese((char*)&ereignisAnzahl, 4);
+		mapFile.lese((char*)&bedingungAnzahl, 4);
+		mapFile.lese((char*)&aktionAnzahl, 4);
+		EreignisTyp* ereignisse = new EreignisTyp[ereignisAnzahl];
+		for (int j = 0; j < ereignisAnzahl; j++)
+			mapFile.lese((char*)&ereignisse[j], 4);
+		RCArray< Bedingung >* bedingungen = new RCArray< Bedingung >();
+		for (int j = 0; j < bedingungAnzahl; j++)
+			bedingungen->add(new Bedingung(readAktion(mapFile)));
+		RCArray< Aktion >* aktionen = new RCArray< Aktion >();
+		for (int j = 0; j < aktionAnzahl; j++)
+			aktionen->add(readAktion(mapFile));
+		zSpiel->addTrigger(new Trigger(id, name, ereignisAnzahl, ereignisse, bedingungen, aktionen));
+		delete[] name;
+	}
+	// Variablen
+	mapFile.lese((char*)&anz, 4);
+	for (int i = 0; i < anz; i++)
+	{
+		char len;
+		mapFile.lese((char*)&len, 1);
+		char* name = new char[(__int64)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		char typ;
+		mapFile.lese(&typ, 1);
+		char def;
+		mapFile.lese(&def, 1);
+		Variable* var = 0;
+		if (!def)
+			var = new Variable(NICHTS);
+		else
+		{
+			switch (typ)
+			{
+			case NICHTS:
+				var = new Variable(NICHTS);
+				break;
+			case INTEGER:
+			{
+				int val;
+				mapFile.lese((char*)&val, 4);
+				var = new Integer(val);
+				break;
+			}
+			case BOOLEAN:
+			{
+				bool val;
+				mapFile.lese((char*)&val, 1);
+				var = new Boolean(val);
+				break;
+			}
+			case STRING:
+			{
+				char len;
+				mapFile.lese((char*)&len, 1);
+				char* value = new char[(__int64)len + 1];
+				mapFile.lese(value, len);
+				value[(int)len] = 0;
+				var = new String(value);
+				delete[] value;
+				break;
+			}
+			case RICHTUNG:
+			{
+				char len;
+				mapFile.lese((char*)&len, 1);
+				char* value = new char[(__int64)len + 1];
+				mapFile.lese(value, len);
+				value[(int)len] = 0;
+				var = new String(getRichtungFromString(Text(value)));
+				delete[] value;
+				break;
+			}
+			case FLOAT:
+			{
+				float val;
+				mapFile.lese((char*)&val, 4);
+				var = new Float(val);
+				break;
+			}
+			case TASTE:
+			{
+				char val;
+				mapFile.lese(&val, 1);
+				var = new Integer(val, 1);
+				break;
+			}
+			case SPIELER:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getSpieler(id);
+				break;
+			}
+			case TIMER:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getTimer(id);
+				break;
+			}
+			case TEAM:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getTeam(id);
+				break;
+			}
+			case BARIERE:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getBariere(id);
+				break;
+			}
+			case SCHALTER:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getSchalter(id);
+				break;
+			}
+			case BASE:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getBase(id);
+				break;
+			}
+			case GEGENSTAND:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = new GegenstandTypVar((GegenstandTyp)id);
+				break;
+			}
+			case SCHIENE:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getSchiene(id);
+				break;
+			}
+			case TUNNEL:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getTunnel(id);
+				break;
+			}
+			case UMLENKUNG:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getUmlenkung(id);
+				break;
+			}
+			case TRIGGER:
+			{
+				int id;
+				mapFile.lese((char*)&id, 4);
+				var = zSpiel->getTrigger(id);
+				break;
+			}
+			default:
+				var = new Variable(NICHTS);
+			}
+		}
+		zSpiel->addVariable(name, var);
+		delete[] name;
+	}
+	mapFile.close();
 }

StickmanWorldOnline/Reader.h

@@ -12,19 +12,19 @@ class Aktion;
 class MapReader : public virtual ReferenceCounter
 {
 private:
-    Text *pfad;
-    int karteId;
+	Text* pfad;
+	int karteId;
 
 public:
-    // Konstruktor
-    MapReader( int karteId, char *tmpPfad );
-    // Destruktor
-    ~MapReader();
-    Array< int > *getSpielerFarben();
-    Array< int > *getTeamFarben();
-    // nicht constant
-    void ladeKarte( Spiel *zSpiel );
+	// Konstruktor
+	MapReader(int karteId, const char* tmpPfad);
+	// Destruktor
+	~MapReader();
+	Array< int >* getSpielerFarben();
+	Array< int >* getTeamFarben();
+	// nicht constant
+	void ladeKarte(Spiel* zSpiel);
 
-    static Aktion *readAktion( StreamReader &dat );
-    static void writeAktion( Aktion *zAk, StreamWriter &dat );
+	static Aktion* readAktion(StreamReader& dat);
+	static void writeAktion(Aktion* zAk, StreamWriter& dat);
 };