framework changes

StickmanWorldOnline/Aktionen.cpp

@@ -11,3035 +11,3035 @@
 #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( Datei &dat )
+void Aktion::writeOptions(Datei& 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( Datei &dat )
+void KonstantInteger::writeOptions(Datei& dat)
 {
-    dat.schreibe( (char *)&value, 4 );
+	dat.schreibe((char*)&value, 4);
 }
 
 
-KonstantGegenstandTyp::KonstantGegenstandTyp( GegenstandTyp val )
-    : Aktion( KONSTANT_INTEGER, new RCArray< Aktion >() )
+KonstantGegenstandTyp::KonstantGegenstandTyp(GegenstandTyp val)
+	: Aktion(KONSTANT_INTEGER, 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( Datei &dat )
+void KonstantGegenstandTyp::writeOptions(Datei& 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( Datei &dat )
+void KonstantTaste::writeOptions(Datei& 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( Datei &dat )
+void KonstantBoolean::writeOptions(Datei& 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( Datei &dat )
+void KonstantString::writeOptions(Datei& 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( Datei &dat )
+void KonstantFloat::writeOptions(Datei& 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( Datei &dat )
+void KonstantVariable::writeOptions(Datei& 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( Datei &dat )
-{
-    char len = (char)name.getLength();
-    dat.schreibe( (char *)&len, 1 );
-    dat.schreibe( name, len );
-}
-
-
-TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
-    : Aktion( TRIGGER_AKTION, subActions )
+bool WennDannSonst::runNext(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	zPC->stepIn();
+	if (zPC->currentPosition() == 0)
+	{
+		bool finished = subActions->z(0)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			Variable* ret = zReturn;
+			zPC->count();
+			if (!isTrue(ret))
+			{
+				zPC->count();
+				if (!subActions->z(2))
+				{
+					zPC->stepOut();
+					return 1;
+				}
+			}
+			else
+			{
+				if (!subActions->z(1))
+				{
+					zPC->stepOut();
+					return 1;
+				}
+			}
+		}
+	}
+	if (zPC->currentPosition() == 1 && waitCount <= 0)
+	{
+		bool finished = subActions->z(1)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			zPC->stepOut();
+			return 1;
+		}
+	}
+	if (zPC->currentPosition() == 2 && waitCount <= 0)
+	{
+		bool finished = subActions->z(2)->runNext(zSpiel, zEreignis, zMemory, zPC, waitCount);
+		if (finished)
+		{
+			zPC->stepOut();
+			return 1;
+		}
+	}
+	zPC->stepOut();
+	return 0;
+}
+
+
+SetVariable::SetVariable(Text name, RCArray< Aktion >* subActions)
+	: Aktion(SET_VARIABLE, subActions)
+{
+	this->name = name;
+}
+
+void SetVariable::run(Spiel* zSpiel, Ereignis* zEreignis, LocalMemory* zMemory, ProgramCounter* zPC, double& waitCount)
+{
+	if (zMemory->zVariable(name) || zEreignis->zParameter(name) || !zSpiel->zVariable(name))
+		zMemory->setVar(name, getParam(0));
+	else
+		zSpiel->setVariable(name, getParam(0));
+}
+
+void SetVariable::writeOptions(Datei& dat)
+{
+	char len = (char)name.getLength();
+	dat.schreibe((char*)&len, 1);
+	dat.schreibe(name, len);
+}
+
+
+TriggerAktion::TriggerAktion(RCArray< Aktion >* subActions)
+	: Aktion(TRIGGER_AKTION, subActions)
 {}
 
-bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+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->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->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 *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
+	((Geschoss*)zParam(1))->setBesitzer(((Spieler*)zMemory->getVariable(zPC->getUniqueString() + "R0__")));
 }
 
 
-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( Datei &dat )
+void IntegerRechnen::writeOptions(Datei& 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( Datei &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(Datei& dat)
+{
+	dat.schreibe((char*)&this->op, 1);
+}
+
+
+Sequenz::Sequenz(RCArray< Aktion >* subActions)
+	: Aktion(SEQUENZ, subActions)
 {}
 
-void Sequenz::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+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( Datei &dat )
+void FloatRechnung::writeOptions(Datei& 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)
 {
-    setReturn( new Bestenliste( zSpiel->getNextId() ) );
+	setReturn(new Bestenliste(zSpiel->getNextId()));
 }
 
 
-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/ESEditorV.h

@@ -11,12 +11,12 @@ class ESEditorV : public virtual ReferenceCounter
 private:
 
 public:
-    virtual ~ESEditorV()
-    {}
-    // nicht constant
-    virtual void setPfad( char *pfad ) = 0;
-    virtual void open() = 0;
-    virtual bool nachricht( SKlient *k ) = 0;
-    // constant
-    virtual char *getLetzterFehler() const = 0;
+	virtual ~ESEditorV()
+	{}
+	// nicht constant
+	virtual void setPfad(const  char* pfad) = 0;
+	virtual void open() = 0;
+	virtual bool nachricht(SKlient* k) = 0;
+	// constant
+	virtual const char* getLetzterFehler() const = 0;
 };

StickmanWorldOnline/Editor.cpp

@@ -5,7 +5,7 @@
 // Inhalt der Editor Klasse aus Editor.h
 // Konstruktor
 Editor::Editor()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {}
 
 // Destruktor
@@ -13,10 +13,10 @@ Editor::~Editor()
 {}
 
 // nicht constant
-void Editor::setPfad( char* pfad )
+void Editor::setPfad(const char* pfad)
 {
-    this->pfad = pfad;
-    this->pfad += "/editor";
+	this->pfad = pfad;
+	this->pfad += "/editor";
 }
 
 void Editor::open()
@@ -24,3030 +24,3030 @@ void Editor::open()
 
 }
 
-bool Editor::nachricht( SKlient* k )
+bool Editor::nachricht(SKlient* k)
 {
-    err = "";
-    char n = 0;
-    k->getNachrichtEncrypted( &n, 1 );
-    switch( n )
-    {
-    case 0: // Initialisierung
-        k->sendeEncrypted( "\1", 1 );
-        if( DateiExistiert( pfad ) )
-            k->sendeEncrypted( "\2", 1 );
-        else
-        {
-            if( createSitzung() )
-                k->sendeEncrypted( "\1", 1 );
-            else
-                return 0;
-        }
-        return 1;
-    case 1: // Sitzung verwerfen
-        if( createSitzung() )
-            k->sendeEncrypted( "\1", 1 );
-        else
-            return 0;
-        return 1;
-    case 2: // Sitzung speichern und beenden
-        if( saveSitzung() )
-            k->sendeEncrypted( "\1", 1 );
-        else
-            return 0;
-        return 1;
-    case 3: // Get Size
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/size";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::lesen ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int width;
-            int height;
-            d.lese( (char*)&width, 4 );
-            d.lese( (char*)&height, 4 );
-            k->sendeEncrypted( (char*)&width, 4 );
-            k->sendeEncrypted( (char*)&height, 4 );
-            d.close();
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 4: // Lade Team Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/team";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei team;
-                team.setDatei( pf );
-                team.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int maxWbZeit;
-                int punkte;
-                team.lese( (char*)&maxWbZeit, 4 );
-                team.lese( (char*)&punkte, 4 );
-                team.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&maxWbZeit, 4 );
-                k->sendeEncrypted( (char*)&punkte, 4 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 5: // Lade Spieler Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/player";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei player;
-                player.setDatei( pf );
-                player.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int spawnX;
-                int spawnY;
-                player.lese( (char*)&spawnX, 4 );
-                player.lese( (char*)&spawnY, 4 );
-                player.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&spawnX, 4 );
-                k->sendeEncrypted( (char*)&spawnY, 4 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 6: // Lade Bariere Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/bariere";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                int style;
-                int verschiebungWeite;
-                int autoSchaltungMaxTime;
-                int team;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.lese( (char*)&style, 4 );
-                object.lese( (char*)&verschiebungWeite, 4 );
-                object.lese( (char*)&autoSchaltungMaxTime, 4 );
-                object.lese( (char*)&team, 4 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-                k->sendeEncrypted( (char*)&style, 4 );
-                k->sendeEncrypted( (char*)&verschiebungWeite, 4 );
-                k->sendeEncrypted( (char*)&autoSchaltungMaxTime, 4 );
-                k->sendeEncrypted( (char*)&team, 4 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 7: // Lade Base Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/base";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                int maxTime;
-                int team;
-                bool showTimer;
-                int timerX;
-                int timerY;
-                int timerFarbe;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.lese( (char*)&maxTime, 4 );
-                object.lese( (char*)&team, 4 );
-                object.lese( (char*)&showTimer, 1 );
-                object.lese( (char*)&timerX, 4 );
-                object.lese( (char*)&timerY, 4 );
-                object.lese( (char*)&timerFarbe, 4 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-                k->sendeEncrypted( (char*)&maxTime, 4 );
-                k->sendeEncrypted( (char*)&team, 4 );
-                k->sendeEncrypted( (char*)&showTimer, 1 );
-                k->sendeEncrypted( (char*)&timerX, 4 );
-                k->sendeEncrypted( (char*)&timerY, 4 );
-                k->sendeEncrypted( (char*)&timerFarbe, 4 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 8: // Lade Drop Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/drop";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int minX;
-                int minY;
-                int maxX;
-                int maxY;
-                int maxTime;
-                int numDrops;
-                float wahrscheinlichkeit[ ITEMANZAHL ];
-                unsigned char len;
-                object.lese( (char*)&minX, 4 );
-                object.lese( (char*)&minY, 4 );
-                object.lese( (char*)&maxX, 4 );
-                object.lese( (char*)&maxY, 4 );
-                object.lese( (char*)&maxTime, 4 );
-                object.lese( (char*)&numDrops, 4 );
-                for( int j = 0; j < ITEMANZAHL; j++ )
-                    object.lese( (char*)&wahrscheinlichkeit[ j ], 4 );
-                object.lese( (char*)&len, 1 );
-                char* name = new char[ len ];
-                object.lese( name, len );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&minX, 4 );
-                k->sendeEncrypted( (char*)&minY, 4 );
-                k->sendeEncrypted( (char*)&maxX, 4 );
-                k->sendeEncrypted( (char*)&maxY, 4 );
-                k->sendeEncrypted( (char*)&maxTime, 4 );
-                k->sendeEncrypted( (char*)&numDrops, 4 );
-                for( int j = 0; j < ITEMANZAHL; j++ )
-                    k->sendeEncrypted( (char*)&wahrscheinlichkeit[ j ], 4 );
-                k->sendeEncrypted( (char*)&len, 1 );
-                k->sendeEncrypted( name, len );
-                delete[] name;
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 9: // Lade Schalter Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schalter";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                bool aktive;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.lese( (char*)&aktive, 1 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-                k->sendeEncrypted( (char*)&aktive, 1 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xA: // Lade Schiene Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schiene";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xB: // Lade Timer Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/timer";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int maxZeit;
-                bool sichtbar;
-                bool autoWiederhohlung;
-                bool runns;
-                int farbe;
-                unsigned char len;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&maxZeit, 4 );
-                object.lese( (char*)&sichtbar, 1 );
-                object.lese( (char*)&autoWiederhohlung, 1 );
-                object.lese( (char*)&runns, 1 );
-                object.lese( (char*)&farbe, 4 );
-                object.lese( (char*)&len, 1 );
-                char* name = new char[ len ];
-                object.lese( name, len );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&maxZeit, 4 );
-                k->sendeEncrypted( (char*)&sichtbar, 1 );
-                k->sendeEncrypted( (char*)&autoWiederhohlung, 1 );
-                k->sendeEncrypted( (char*)&runns, 1 );
-                k->sendeEncrypted( (char*)&farbe, 4 );
-                k->sendeEncrypted( (char*)&len, 1 );
-                k->sendeEncrypted( name, len );
-                delete[]name;
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xC: // Lade Tunnel Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/tunnel";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                int zielX;
-                int zielY;
-                bool aktiv;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.lese( (char*)&zielX, 4 );
-                object.lese( (char*)&zielY, 4 );
-                object.lese( (char*)&aktiv, 1 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-                k->sendeEncrypted( (char*)&zielX, 4 );
-                k->sendeEncrypted( (char*)&zielY, 4 );
-                k->sendeEncrypted( (char*)&aktiv, 1 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xD: // Lade Umlenkung Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/umlenkung";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                object.open( Datei::Style::lesen );
-                int id = *files->z( i );
-                int x;
-                int y;
-                int breite;
-                int height;
-                char richtung;
-                int maxAbklingzeit;
-                bool drehend;
-                bool aktiv;
-                object.lese( (char*)&x, 4 );
-                object.lese( (char*)&y, 4 );
-                object.lese( (char*)&breite, 4 );
-                object.lese( (char*)&height, 4 );
-                object.lese( (char*)&richtung, 1 );
-                object.lese( (char*)&maxAbklingzeit, 4 );
-                object.lese( (char*)&drehend, 1 );
-                object.lese( (char*)&aktiv, 1 );
-                object.close();
-                k->sendeEncrypted( (char*)&id, 4 );
-                k->sendeEncrypted( (char*)&x, 4 );
-                k->sendeEncrypted( (char*)&y, 4 );
-                k->sendeEncrypted( (char*)&breite, 4 );
-                k->sendeEncrypted( (char*)&height, 4 );
-                k->sendeEncrypted( (char*)&richtung, 1 );
-                k->sendeEncrypted( (char*)&maxAbklingzeit, 4 );
-                k->sendeEncrypted( (char*)&drehend, 1 );
-                k->sendeEncrypted( (char*)&aktiv, 1 );
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xE: // Lade Trigger Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/trigger";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                __int64 size = object.getSize();
-                object.open( Datei::Style::lesen );
-                char buffer[ 2048 ];
-                int id = *files->z( i );
-                k->sendeEncrypted( (char*)&id, 4 );
-                while( size > 0 )
-                {
-                    object.lese( buffer, MIN( 2048, (int)size ) );
-                    k->sendeEncrypted( buffer, MIN( 2048, (int)size ) );
-                    size -= 2048;
-                }
-                object.close();
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0xF: // Lade Variable Daten
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/variable";
-        Datei d;
-        d.setDatei( tmpPf );
-        RCArray< Text >* files = d.getDateiListe();
-        if( files )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int anz = files->getEintragAnzahl();
-            k->sendeEncrypted( (char*)&anz, 4 );
-            for( int i = 0; i < anz; i++ )
-            {
-                Text pf = tmpPf;
-                pf += "/";
-                pf += files->z( i )->getText();
-                Datei object;
-                object.setDatei( pf );
-                __int64 size = object.getSize();
-                object.open( Datei::Style::lesen );
-                char buffer[ 2048 ];
-                unsigned char len = (unsigned char)(files->z( i )->getLength() - 2);
-                k->sendeEncrypted( (char*)&len, 1 );
-                k->sendeEncrypted( *files->z( i ), len );
-                while( size > 0 )
-                {
-                    object.lese( buffer, MIN( 2048, (int)size ) );
-                    k->sendeEncrypted( buffer, MIN( 2048, (int)size ) );
-                    size -= 2048;
-                }
-                object.close();
-            }
-        }
-        else
-        {
-            err = "Fehler beim laden von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0x10: // Change Map Size
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/size";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int width;
-            int height;
-            k->getNachrichtEncrypted( (char*)&width, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            if( width <= 0 || height <= 0 )
-            {
-                err = "Illegal Argument Exception";
-                return 0;
-            }
-            k->sendeEncrypted( "\1", 1 );
-            d.schreibe( (char*)&width, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.close();
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        return 1;
-    }
-    case 0x11: // Change Team data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/team/";
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int maxWbZeit;
-            int punkte;
-            k->getNachrichtEncrypted( (char*)&maxWbZeit, 4 );
-            k->getNachrichtEncrypted( (char*)&punkte, 4 );
-            d.schreibe( (char*)&maxWbZeit, 4 );
-            d.schreibe( (char*)&punkte, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x12: // Change Player data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/player/";
-        tmpPf += id;
-        tmpPf += ".p";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int spawnX;
-            int spawnY;
-            k->getNachrichtEncrypted( (char*)&spawnX, 4 );
-            k->getNachrichtEncrypted( (char*)&spawnY, 4 );
-            d.schreibe( (char*)&spawnX, 4 );
-            d.schreibe( (char*)&spawnY, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x13: // Change Bariere data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/bariere/";
-        tmpPf += id;
-        tmpPf += ".b";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int style;
-            int verschiebungWeite;
-            int autoSchaltungMaxTime;
-            int team;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&style, 4 );
-            k->getNachrichtEncrypted( (char*)&verschiebungWeite, 4 );
-            k->getNachrichtEncrypted( (char*)&autoSchaltungMaxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&team, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&style, 4 );
-            d.schreibe( (char*)&verschiebungWeite, 4 );
-            d.schreibe( (char*)&autoSchaltungMaxTime, 4 );
-            d.schreibe( (char*)&team, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x14: // Change Base data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/base/";
-        tmpPf += id;
-        tmpPf += ".b";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int maxTime;
-            int team;
-            bool showTimer;
-            int timerX;
-            int timerY;
-            int timerFarbe;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&team, 4 );
-            k->getNachrichtEncrypted( (char*)&showTimer, 1 );
-            k->getNachrichtEncrypted( (char*)&timerX, 4 );
-            k->getNachrichtEncrypted( (char*)&timerY, 4 );
-            k->getNachrichtEncrypted( (char*)&timerFarbe, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&maxTime, 4 );
-            d.schreibe( (char*)&team, 4 );
-            d.schreibe( (char*)&showTimer, 1 );
-            d.schreibe( (char*)&timerX, 4 );
-            d.schreibe( (char*)&timerY, 4 );
-            d.schreibe( (char*)&timerFarbe, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x15: // Change Drop data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/drop/";
-        tmpPf += id;
-        tmpPf += ".d";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int minX;
-            int minY;
-            int maxX;
-            int maxY;
-            int maxTime;
-            int numDrops;
-            float wahrscheinlichkeit[ ITEMANZAHL ];
-            unsigned char len;
-            k->getNachrichtEncrypted( (char*)&minX, 4 );
-            k->getNachrichtEncrypted( (char*)&minY, 4 );
-            k->getNachrichtEncrypted( (char*)&maxX, 4 );
-            k->getNachrichtEncrypted( (char*)&maxY, 4 );
-            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&numDrops, 4 );
-            for( int i = 0; i < ITEMANZAHL; i++ )
-                k->getNachrichtEncrypted( (char*)&wahrscheinlichkeit[ i ], 4 );
-            k->getNachrichtEncrypted( (char*)&len, 1 );
-            char* name = new char[ len ];
-            k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char*)&minX, 4 );
-            d.schreibe( (char*)&minY, 4 );
-            d.schreibe( (char*)&maxX, 4 );
-            d.schreibe( (char*)&maxY, 4 );
-            d.schreibe( (char*)&maxTime, 4 );
-            d.schreibe( (char*)&numDrops, 4 );
-            for( int i = 0; i < ITEMANZAHL; i++ )
-                d.schreibe( (char*)&wahrscheinlichkeit[ i ], 4 );
-            d.schreibe( (char*)&len, 1 );
-            d.schreibe( name, len );
-            delete[]name;
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x16: // Change Schalter data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schalter/";
-        tmpPf += id;
-        tmpPf += ".s";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            bool aktive;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&aktive, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&aktive, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x17: // Change Schiene data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schiene/";
-        tmpPf += id;
-        tmpPf += ".s";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x18: // Change Timer data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/timer/";
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int maxZeit;
-            bool sichtbar;
-            bool autoWiederhohlung;
-            bool runns;
-            int farbe;
-            unsigned char len;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&maxZeit, 4 );
-            k->getNachrichtEncrypted( (char*)&sichtbar, 1 );
-            k->getNachrichtEncrypted( (char*)&autoWiederhohlung, 1 );
-            k->getNachrichtEncrypted( (char*)&runns, 1 );
-            k->getNachrichtEncrypted( (char*)&farbe, 4 );
-            k->getNachrichtEncrypted( (char*)&len, 1 );
-            char* name = new char[ len ];
-            k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&maxZeit, 4 );
-            d.schreibe( (char*)&sichtbar, 1 );
-            d.schreibe( (char*)&autoWiederhohlung, 1 );
-            d.schreibe( (char*)&runns, 1 );
-            d.schreibe( (char*)&farbe, 4 );
-            d.schreibe( (char*)&len, 1 );
-            d.schreibe( name, len );
-            delete[]name;
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x19: // Change Tunnel data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/tunnel/";
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int zielX;
-            int zielY;
-            bool aktiv;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&zielX, 4 );
-            k->getNachrichtEncrypted( (char*)&zielY, 4 );
-            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&zielX, 4 );
-            d.schreibe( (char*)&zielY, 4 );
-            d.schreibe( (char*)&aktiv, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x1A: // Change Umlenkung data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/umlenkung/";
-        tmpPf += id;
-        tmpPf += ".u";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            char richtung;
-            int maxAbklingzeit;
-            bool drehend;
-            bool aktiv;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&richtung, 1 );
-            k->getNachrichtEncrypted( (char*)&maxAbklingzeit, 4 );
-            k->getNachrichtEncrypted( (char*)&drehend, 1 );
-            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&richtung, 1 );
-            d.schreibe( (char*)&maxAbklingzeit, 4 );
-            d.schreibe( (char*)&drehend, 1 );
-            d.schreibe( (char*)&aktiv, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x1B: // Change Trigger data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/trigger/";
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            // TODO
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x1C: // Change Variable data
-    {
-        k->sendeEncrypted( "\1", 1 );
-        unsigned char len;
-        k->getNachrichtEncrypted( (char*)&len, 1 );
-        char* originalName = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char*)&originalName, len );
-        originalName[ len ] = 0;
-        Text tmpPf = pfad.getText();
-        tmpPf += "/variable/";
-        tmpPf += originalName;
-        tmpPf += ".v";
-        Datei d;
-        d.setDatei( tmpPf );
-        k->getNachrichtEncrypted( (char*)&len, 1 );
-        char* name = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char*)&name, len );
-        name[ len ] = 0;
-        if( !Text( name ).istGleich( originalName ) )
-        {
-            Text tmpPf = pfad.getText();
-            tmpPf += "/variable/";
-            tmpPf += name;
-            tmpPf += ".v";
-            if( !d.umbenennen( tmpPf ) )
-            {
-                err = "Fehler beim schreiben von ";
-                err += tmpPf.getText();
-                return 0;
-            }
-        }
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            __int64 size;
-            k->getNachrichtEncrypted( (char*)&size, 8 );
-            char buffer[ 2048 ];
-            while( size > 0 )
-            {
-                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
-                d.schreibe( buffer, MIN( 2048, (int)size ) );
-                size -= 2048;
-            }
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        delete[]name;
-        delete[]originalName;
-    }
-    case 0x1D: // Add Bariere
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/bariere/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".b" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".b";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int style;
-            int verschiebungWeite;
-            int autoSchaltungMaxTime;
-            int team;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&style, 4 );
-            k->getNachrichtEncrypted( (char*)&verschiebungWeite, 4 );
-            k->getNachrichtEncrypted( (char*)&autoSchaltungMaxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&team, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&style, 4 );
-            d.schreibe( (char*)&verschiebungWeite, 4 );
-            d.schreibe( (char*)&autoSchaltungMaxTime, 4 );
-            d.schreibe( (char*)&team, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x1E: // Add Base
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/base/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".b" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".b";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int maxTime;
-            int team;
-            bool showTimer;
-            int timerX;
-            int timerY;
-            int timerFarbe;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&team, 4 );
-            k->getNachrichtEncrypted( (char*)&showTimer, 1 );
-            k->getNachrichtEncrypted( (char*)&timerX, 4 );
-            k->getNachrichtEncrypted( (char*)&timerY, 4 );
-            k->getNachrichtEncrypted( (char*)&timerFarbe, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&maxTime, 4 );
-            d.schreibe( (char*)&team, 4 );
-            d.schreibe( (char*)&showTimer, 1 );
-            d.schreibe( (char*)&timerX, 4 );
-            d.schreibe( (char*)&timerY, 4 );
-            d.schreibe( (char*)&timerFarbe, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x1F: // Add Drop
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/drop/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".d" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".d";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int minX;
-            int minY;
-            int maxX;
-            int maxY;
-            int maxTime;
-            int numDrops;
-            float wahrscheinlichkeit[ ITEMANZAHL ];
-            unsigned char len;
-            k->getNachrichtEncrypted( (char*)&minX, 4 );
-            k->getNachrichtEncrypted( (char*)&minY, 4 );
-            k->getNachrichtEncrypted( (char*)&maxX, 4 );
-            k->getNachrichtEncrypted( (char*)&maxY, 4 );
-            k->getNachrichtEncrypted( (char*)&maxTime, 4 );
-            k->getNachrichtEncrypted( (char*)&numDrops, 4 );
-            for( int i = 0; i < ITEMANZAHL; i++ )
-                k->getNachrichtEncrypted( (char*)&wahrscheinlichkeit[ i ], 4 );
-            k->getNachrichtEncrypted( (char*)&len, 1 );
-            char* name = new char[ len ];
-            k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char*)&minX, 4 );
-            d.schreibe( (char*)&minY, 4 );
-            d.schreibe( (char*)&maxX, 4 );
-            d.schreibe( (char*)&maxY, 4 );
-            d.schreibe( (char*)&maxTime, 4 );
-            d.schreibe( (char*)&numDrops, 4 );
-            for( int i = 0; i < ITEMANZAHL; i++ )
-                d.schreibe( (char*)&wahrscheinlichkeit[ i ], 4 );
-            d.schreibe( (char*)&len, 1 );
-            d.schreibe( name, len );
-            delete[]name;
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x20: // Add Schalter
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schalter/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".s" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".s";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            bool aktive;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&aktive, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&aktive, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x21: // Add Schiene
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schiene/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".s" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".s";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x22: // Add Timer
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/timer/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".t" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int maxZeit;
-            bool sichtbar;
-            bool autoWiederhohlung;
-            bool runns;
-            int farbe;
-            unsigned char len;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&maxZeit, 4 );
-            k->getNachrichtEncrypted( (char*)&sichtbar, 1 );
-            k->getNachrichtEncrypted( (char*)&autoWiederhohlung, 1 );
-            k->getNachrichtEncrypted( (char*)&runns, 1 );
-            k->getNachrichtEncrypted( (char*)&farbe, 4 );
-            k->getNachrichtEncrypted( (char*)&len, 1 );
-            char* name = new char[ len ];
-            k->getNachrichtEncrypted( name, len );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&maxZeit, 4 );
-            d.schreibe( (char*)&sichtbar, 1 );
-            d.schreibe( (char*)&autoWiederhohlung, 1 );
-            d.schreibe( (char*)&runns, 1 );
-            d.schreibe( (char*)&farbe, 4 );
-            d.schreibe( (char*)&len, 1 );
-            d.schreibe( name, len );
-            delete[]name;
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x23: // Add Tunnel
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/tunnel/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".t" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            int zielX;
-            int zielY;
-            bool aktiv;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&zielX, 4 );
-            k->getNachrichtEncrypted( (char*)&zielY, 4 );
-            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&zielX, 4 );
-            d.schreibe( (char*)&zielY, 4 );
-            d.schreibe( (char*)&aktiv, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x24: // Add Umlenkung
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/umlenkung/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".u" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".u";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            k->sendeEncrypted( (char*)&id, 4 );
-            int x;
-            int y;
-            int breite;
-            int height;
-            char richtung;
-            int maxAbklingzeit;
-            bool drehend;
-            bool aktiv;
-            k->getNachrichtEncrypted( (char*)&x, 4 );
-            k->getNachrichtEncrypted( (char*)&y, 4 );
-            k->getNachrichtEncrypted( (char*)&breite, 4 );
-            k->getNachrichtEncrypted( (char*)&height, 4 );
-            k->getNachrichtEncrypted( (char*)&richtung, 1 );
-            k->getNachrichtEncrypted( (char*)&maxAbklingzeit, 4 );
-            k->getNachrichtEncrypted( (char*)&drehend, 1 );
-            k->getNachrichtEncrypted( (char*)&aktiv, 1 );
-            d.schreibe( (char*)&x, 4 );
-            d.schreibe( (char*)&y, 4 );
-            d.schreibe( (char*)&breite, 4 );
-            d.schreibe( (char*)&height, 4 );
-            d.schreibe( (char*)&richtung, 1 );
-            d.schreibe( (char*)&maxAbklingzeit, 4 );
-            d.schreibe( (char*)&drehend, 1 );
-            d.schreibe( (char*)&aktiv, 1 );
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x25: // Add Trigger
-    {
-        Text tmpPf = pfad.getText();
-        tmpPf += "/trigger/";
-        int id = 0;
-        while( true )
-        {
-            if( !DateiExistiert( tmpPf + id + ".t" ) )
-                break;
-            id++;
-        }
-        tmpPf += id;
-        tmpPf += ".t";
-        Datei d;
-        d.setDatei( tmpPf );
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            __int64 size;
-            k->getNachrichtEncrypted( (char*)&size, 8 );
-            char buffer[ 2048 ];
-            while( size > 0 )
-            {
-                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
-                d.schreibe( buffer, MIN( 2048, (int)size ) );
-                size -= 2048;
-            }
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-            return 1;
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x26: // Add Variable
-    {
-        k->sendeEncrypted( "\1", 1 );
-        unsigned char len;
-        k->getNachrichtEncrypted( (char*)&len, 1 );
-        char* name = new char[ len + 1 ];
-        k->getNachrichtEncrypted( (char*)&name, len );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/variable/";
-        tmpPf += name;
-        tmpPf += ".v";
-        Datei d;
-        if( d.existiert() )
-        {
-            err = "Die Variable existiert bereits";
-            return 0;
-        }
-        d.setDatei( tmpPf );
-        name[ len ] = 0;
-        if( d.open( Datei::Style::schreiben ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-            __int64 size;
-            k->getNachrichtEncrypted( (char*)&size, 8 );
-            char buffer[ 2048 ];
-            while( size > 0 )
-            {
-                k->getNachrichtEncrypted( buffer, MIN( 2048, (int)size ) );
-                d.schreibe( buffer, MIN( 2048, (int)size ) );
-                size -= 2048;
-            }
-            d.close();
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim schreiben von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-        delete[]name;
-    }
-    case 0x27: // Remove Bariere
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/bariere/";
-        tmpPf += id;
-        tmpPf += ".b";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x28: // Remove Base
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/base/";
-        tmpPf += id;
-        tmpPf += ".b";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x29: // Remove Drop
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/drop/";
-        tmpPf += id;
-        tmpPf += ".d";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2A: // Remove Schalter
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schalter/";
-        tmpPf += id;
-        tmpPf += ".s";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2B: // Remove Schiene
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/schiene/";
-        tmpPf += id;
-        tmpPf += ".s";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2C: // Remove Timer
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/timer/";
-        tmpPf += id;
-        tmpPf += ".t";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2D: // Remove Tunnel
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/tunnel/";
-        tmpPf += id;
-        tmpPf += ".t";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2E: // Remove Umlenkung
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/umlenkung/";
-        tmpPf += id;
-        tmpPf += ".u";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x2F: // Remove Trigger
-    {
-        k->sendeEncrypted( "\1", 1 );
-        int id;
-        k->getNachrichtEncrypted( (char*)&id, 4 );
-        Text tmpPf = pfad.getText();
-        tmpPf += "/trigger/";
-        tmpPf += id;
-        tmpPf += ".t";
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    case 0x30: // Remove Variable
-    {
-        k->sendeEncrypted( "\1", 1 );
-        unsigned char len;
-        k->getNachrichtEncrypted( (char*)&len, 1 );
-        char* name = new char[ len + 1 ];
-        k->getNachrichtEncrypted( name, len );
-        name[ len ] = 0;
-        Text tmpPf = pfad.getText();
-        tmpPf += "/variable/";
-        tmpPf += name;
-        tmpPf += ".v";
-        delete[]name;
-        if( DateiRemove( tmpPf ) )
-        {
-            k->sendeEncrypted( "\1", 1 );
-        }
-        else
-        {
-            err = "Fehler beim löschen von ";
-            err += tmpPf.getText();
-            return 0;
-        }
-    }
-    default:
-        err = "Unbekannte Nachricht. Error Code: " __FILE__ ":";
-        err += __LINE__;
-        return 0;
-    }
-    return 0;
+	err = "";
+	char n = 0;
+	k->getNachrichtEncrypted(&n, 1);
+	switch (n)
+	{
+	case 0: // Initialisierung
+		k->sendeEncrypted("\1", 1);
+		if (DateiExistiert(pfad))
+			k->sendeEncrypted("\2", 1);
+		else
+		{
+			if (createSitzung())
+				k->sendeEncrypted("\1", 1);
+			else
+				return 0;
+		}
+		return 1;
+	case 1: // Sitzung verwerfen
+		if (createSitzung())
+			k->sendeEncrypted("\1", 1);
+		else
+			return 0;
+		return 1;
+	case 2: // Sitzung speichern und beenden
+		if (saveSitzung())
+			k->sendeEncrypted("\1", 1);
+		else
+			return 0;
+		return 1;
+	case 3: // Get Size
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/size";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::lesen))
+		{
+			k->sendeEncrypted("\1", 1);
+			int width;
+			int height;
+			d.lese((char*)&width, 4);
+			d.lese((char*)&height, 4);
+			k->sendeEncrypted((char*)&width, 4);
+			k->sendeEncrypted((char*)&height, 4);
+			d.close();
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 4: // Lade Team Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/team";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei team;
+				team.setDatei(pf);
+				team.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int maxWbZeit;
+				int punkte;
+				team.lese((char*)&maxWbZeit, 4);
+				team.lese((char*)&punkte, 4);
+				team.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&maxWbZeit, 4);
+				k->sendeEncrypted((char*)&punkte, 4);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 5: // Lade Spieler Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/player";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei player;
+				player.setDatei(pf);
+				player.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int spawnX;
+				int spawnY;
+				player.lese((char*)&spawnX, 4);
+				player.lese((char*)&spawnY, 4);
+				player.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&spawnX, 4);
+				k->sendeEncrypted((char*)&spawnY, 4);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 6: // Lade Bariere Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/bariere";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				int style;
+				int verschiebungWeite;
+				int autoSchaltungMaxTime;
+				int team;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.lese((char*)&style, 4);
+				object.lese((char*)&verschiebungWeite, 4);
+				object.lese((char*)&autoSchaltungMaxTime, 4);
+				object.lese((char*)&team, 4);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+				k->sendeEncrypted((char*)&style, 4);
+				k->sendeEncrypted((char*)&verschiebungWeite, 4);
+				k->sendeEncrypted((char*)&autoSchaltungMaxTime, 4);
+				k->sendeEncrypted((char*)&team, 4);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 7: // Lade Base Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/base";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				int maxTime;
+				int team;
+				bool showTimer;
+				int timerX;
+				int timerY;
+				int timerFarbe;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.lese((char*)&maxTime, 4);
+				object.lese((char*)&team, 4);
+				object.lese((char*)&showTimer, 1);
+				object.lese((char*)&timerX, 4);
+				object.lese((char*)&timerY, 4);
+				object.lese((char*)&timerFarbe, 4);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+				k->sendeEncrypted((char*)&maxTime, 4);
+				k->sendeEncrypted((char*)&team, 4);
+				k->sendeEncrypted((char*)&showTimer, 1);
+				k->sendeEncrypted((char*)&timerX, 4);
+				k->sendeEncrypted((char*)&timerY, 4);
+				k->sendeEncrypted((char*)&timerFarbe, 4);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 8: // Lade Drop Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/drop";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int minX;
+				int minY;
+				int maxX;
+				int maxY;
+				int maxTime;
+				int numDrops;
+				float wahrscheinlichkeit[ITEMANZAHL];
+				unsigned char len;
+				object.lese((char*)&minX, 4);
+				object.lese((char*)&minY, 4);
+				object.lese((char*)&maxX, 4);
+				object.lese((char*)&maxY, 4);
+				object.lese((char*)&maxTime, 4);
+				object.lese((char*)&numDrops, 4);
+				for (int j = 0; j < ITEMANZAHL; j++)
+					object.lese((char*)&wahrscheinlichkeit[j], 4);
+				object.lese((char*)&len, 1);
+				char* name = new char[len];
+				object.lese(name, len);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&minX, 4);
+				k->sendeEncrypted((char*)&minY, 4);
+				k->sendeEncrypted((char*)&maxX, 4);
+				k->sendeEncrypted((char*)&maxY, 4);
+				k->sendeEncrypted((char*)&maxTime, 4);
+				k->sendeEncrypted((char*)&numDrops, 4);
+				for (int j = 0; j < ITEMANZAHL; j++)
+					k->sendeEncrypted((char*)&wahrscheinlichkeit[j], 4);
+				k->sendeEncrypted((char*)&len, 1);
+				k->sendeEncrypted(name, len);
+				delete[] name;
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 9: // Lade Schalter Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schalter";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				bool aktive;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.lese((char*)&aktive, 1);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+				k->sendeEncrypted((char*)&aktive, 1);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xA: // Lade Schiene Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schiene";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xB: // Lade Timer Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/timer";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int maxZeit;
+				bool sichtbar;
+				bool autoWiederhohlung;
+				bool runns;
+				int farbe;
+				unsigned char len;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&maxZeit, 4);
+				object.lese((char*)&sichtbar, 1);
+				object.lese((char*)&autoWiederhohlung, 1);
+				object.lese((char*)&runns, 1);
+				object.lese((char*)&farbe, 4);
+				object.lese((char*)&len, 1);
+				char* name = new char[len];
+				object.lese(name, len);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&maxZeit, 4);
+				k->sendeEncrypted((char*)&sichtbar, 1);
+				k->sendeEncrypted((char*)&autoWiederhohlung, 1);
+				k->sendeEncrypted((char*)&runns, 1);
+				k->sendeEncrypted((char*)&farbe, 4);
+				k->sendeEncrypted((char*)&len, 1);
+				k->sendeEncrypted(name, len);
+				delete[]name;
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xC: // Lade Tunnel Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/tunnel";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				int zielX;
+				int zielY;
+				bool aktiv;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.lese((char*)&zielX, 4);
+				object.lese((char*)&zielY, 4);
+				object.lese((char*)&aktiv, 1);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+				k->sendeEncrypted((char*)&zielX, 4);
+				k->sendeEncrypted((char*)&zielY, 4);
+				k->sendeEncrypted((char*)&aktiv, 1);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xD: // Lade Umlenkung Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/umlenkung";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				object.open(Datei::Style::lesen);
+				int id = (int)*files->z(i);
+				int x;
+				int y;
+				int breite;
+				int height;
+				char richtung;
+				int maxAbklingzeit;
+				bool drehend;
+				bool aktiv;
+				object.lese((char*)&x, 4);
+				object.lese((char*)&y, 4);
+				object.lese((char*)&breite, 4);
+				object.lese((char*)&height, 4);
+				object.lese((char*)&richtung, 1);
+				object.lese((char*)&maxAbklingzeit, 4);
+				object.lese((char*)&drehend, 1);
+				object.lese((char*)&aktiv, 1);
+				object.close();
+				k->sendeEncrypted((char*)&id, 4);
+				k->sendeEncrypted((char*)&x, 4);
+				k->sendeEncrypted((char*)&y, 4);
+				k->sendeEncrypted((char*)&breite, 4);
+				k->sendeEncrypted((char*)&height, 4);
+				k->sendeEncrypted((char*)&richtung, 1);
+				k->sendeEncrypted((char*)&maxAbklingzeit, 4);
+				k->sendeEncrypted((char*)&drehend, 1);
+				k->sendeEncrypted((char*)&aktiv, 1);
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xE: // Lade Trigger Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/trigger";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				__int64 size = object.getSize();
+				object.open(Datei::Style::lesen);
+				char buffer[2048];
+				int id = (int)*files->z(i);
+				k->sendeEncrypted((char*)&id, 4);
+				while (size > 0)
+				{
+					object.lese(buffer, MIN(2048, (int)size));
+					k->sendeEncrypted(buffer, MIN(2048, (int)size));
+					size -= 2048;
+				}
+				object.close();
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0xF: // Lade Variable Daten
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/variable";
+		Datei d;
+		d.setDatei(tmpPf);
+		RCArray< Text >* files = d.getDateiListe();
+		if (files)
+		{
+			k->sendeEncrypted("\1", 1);
+			int anz = files->getEintragAnzahl();
+			k->sendeEncrypted((char*)&anz, 4);
+			for (int i = 0; i < anz; i++)
+			{
+				Text pf = tmpPf;
+				pf += "/";
+				pf += files->z(i)->getText();
+				Datei object;
+				object.setDatei(pf);
+				__int64 size = object.getSize();
+				object.open(Datei::Style::lesen);
+				char buffer[2048];
+				unsigned char len = (unsigned char)(files->z(i)->getLength() - 2);
+				k->sendeEncrypted((char*)&len, 1);
+				k->sendeEncrypted(*files->z(i), len);
+				while (size > 0)
+				{
+					object.lese(buffer, MIN(2048, (int)size));
+					k->sendeEncrypted(buffer, MIN(2048, (int)size));
+					size -= 2048;
+				}
+				object.close();
+			}
+		}
+		else
+		{
+			err = "Fehler beim laden von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0x10: // Change Map Size
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/size";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int width;
+			int height;
+			k->getNachrichtEncrypted((char*)&width, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			if (width <= 0 || height <= 0)
+			{
+				err = "Illegal Argument Exception";
+				return 0;
+			}
+			k->sendeEncrypted("\1", 1);
+			d.schreibe((char*)&width, 4);
+			d.schreibe((char*)&height, 4);
+			d.close();
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		return 1;
+	}
+	case 0x11: // Change Team data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/team/";
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int maxWbZeit;
+			int punkte;
+			k->getNachrichtEncrypted((char*)&maxWbZeit, 4);
+			k->getNachrichtEncrypted((char*)&punkte, 4);
+			d.schreibe((char*)&maxWbZeit, 4);
+			d.schreibe((char*)&punkte, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x12: // Change Player data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/player/";
+		tmpPf += id;
+		tmpPf += ".p";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int spawnX;
+			int spawnY;
+			k->getNachrichtEncrypted((char*)&spawnX, 4);
+			k->getNachrichtEncrypted((char*)&spawnY, 4);
+			d.schreibe((char*)&spawnX, 4);
+			d.schreibe((char*)&spawnY, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x13: // Change Bariere data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/bariere/";
+		tmpPf += id;
+		tmpPf += ".b";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int style;
+			int verschiebungWeite;
+			int autoSchaltungMaxTime;
+			int team;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&style, 4);
+			k->getNachrichtEncrypted((char*)&verschiebungWeite, 4);
+			k->getNachrichtEncrypted((char*)&autoSchaltungMaxTime, 4);
+			k->getNachrichtEncrypted((char*)&team, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&style, 4);
+			d.schreibe((char*)&verschiebungWeite, 4);
+			d.schreibe((char*)&autoSchaltungMaxTime, 4);
+			d.schreibe((char*)&team, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x14: // Change Base data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/base/";
+		tmpPf += id;
+		tmpPf += ".b";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int maxTime;
+			int team;
+			bool showTimer;
+			int timerX;
+			int timerY;
+			int timerFarbe;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&maxTime, 4);
+			k->getNachrichtEncrypted((char*)&team, 4);
+			k->getNachrichtEncrypted((char*)&showTimer, 1);
+			k->getNachrichtEncrypted((char*)&timerX, 4);
+			k->getNachrichtEncrypted((char*)&timerY, 4);
+			k->getNachrichtEncrypted((char*)&timerFarbe, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&maxTime, 4);
+			d.schreibe((char*)&team, 4);
+			d.schreibe((char*)&showTimer, 1);
+			d.schreibe((char*)&timerX, 4);
+			d.schreibe((char*)&timerY, 4);
+			d.schreibe((char*)&timerFarbe, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x15: // Change Drop data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/drop/";
+		tmpPf += id;
+		tmpPf += ".d";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int minX;
+			int minY;
+			int maxX;
+			int maxY;
+			int maxTime;
+			int numDrops;
+			float wahrscheinlichkeit[ITEMANZAHL];
+			unsigned char len;
+			k->getNachrichtEncrypted((char*)&minX, 4);
+			k->getNachrichtEncrypted((char*)&minY, 4);
+			k->getNachrichtEncrypted((char*)&maxX, 4);
+			k->getNachrichtEncrypted((char*)&maxY, 4);
+			k->getNachrichtEncrypted((char*)&maxTime, 4);
+			k->getNachrichtEncrypted((char*)&numDrops, 4);
+			for (int i = 0; i < ITEMANZAHL; i++)
+				k->getNachrichtEncrypted((char*)&wahrscheinlichkeit[i], 4);
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* name = new char[len];
+			k->getNachrichtEncrypted(name, len);
+			d.schreibe((char*)&minX, 4);
+			d.schreibe((char*)&minY, 4);
+			d.schreibe((char*)&maxX, 4);
+			d.schreibe((char*)&maxY, 4);
+			d.schreibe((char*)&maxTime, 4);
+			d.schreibe((char*)&numDrops, 4);
+			for (int i = 0; i < ITEMANZAHL; i++)
+				d.schreibe((char*)&wahrscheinlichkeit[i], 4);
+			d.schreibe((char*)&len, 1);
+			d.schreibe(name, len);
+			delete[]name;
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x16: // Change Schalter data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schalter/";
+		tmpPf += id;
+		tmpPf += ".s";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			bool aktive;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&aktive, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&aktive, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x17: // Change Schiene data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schiene/";
+		tmpPf += id;
+		tmpPf += ".s";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x18: // Change Timer data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/timer/";
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int maxZeit;
+			bool sichtbar;
+			bool autoWiederhohlung;
+			bool runns;
+			int farbe;
+			unsigned char len;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&maxZeit, 4);
+			k->getNachrichtEncrypted((char*)&sichtbar, 1);
+			k->getNachrichtEncrypted((char*)&autoWiederhohlung, 1);
+			k->getNachrichtEncrypted((char*)&runns, 1);
+			k->getNachrichtEncrypted((char*)&farbe, 4);
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* name = new char[len];
+			k->getNachrichtEncrypted(name, len);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&maxZeit, 4);
+			d.schreibe((char*)&sichtbar, 1);
+			d.schreibe((char*)&autoWiederhohlung, 1);
+			d.schreibe((char*)&runns, 1);
+			d.schreibe((char*)&farbe, 4);
+			d.schreibe((char*)&len, 1);
+			d.schreibe(name, len);
+			delete[]name;
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x19: // Change Tunnel data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/tunnel/";
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int zielX;
+			int zielY;
+			bool aktiv;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&zielX, 4);
+			k->getNachrichtEncrypted((char*)&zielY, 4);
+			k->getNachrichtEncrypted((char*)&aktiv, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&zielX, 4);
+			d.schreibe((char*)&zielY, 4);
+			d.schreibe((char*)&aktiv, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x1A: // Change Umlenkung data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/umlenkung/";
+		tmpPf += id;
+		tmpPf += ".u";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			int x;
+			int y;
+			int breite;
+			int height;
+			char richtung;
+			int maxAbklingzeit;
+			bool drehend;
+			bool aktiv;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&richtung, 1);
+			k->getNachrichtEncrypted((char*)&maxAbklingzeit, 4);
+			k->getNachrichtEncrypted((char*)&drehend, 1);
+			k->getNachrichtEncrypted((char*)&aktiv, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&richtung, 1);
+			d.schreibe((char*)&maxAbklingzeit, 4);
+			d.schreibe((char*)&drehend, 1);
+			d.schreibe((char*)&aktiv, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x1B: // Change Trigger data
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/trigger/";
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			// TODO
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x1C: // Change Variable data
+	{
+		k->sendeEncrypted("\1", 1);
+		unsigned char len;
+		k->getNachrichtEncrypted((char*)&len, 1);
+		char* originalName = new char[len + 1];
+		k->getNachrichtEncrypted((char*)&originalName, len);
+		originalName[len] = 0;
+		Text tmpPf = pfad.getText();
+		tmpPf += "/variable/";
+		tmpPf += originalName;
+		tmpPf += ".v";
+		Datei d;
+		d.setDatei(tmpPf);
+		k->getNachrichtEncrypted((char*)&len, 1);
+		char* name = new char[len + 1];
+		k->getNachrichtEncrypted((char*)&name, len);
+		name[len] = 0;
+		if (!Text(name).istGleich(originalName))
+		{
+			Text tmpPf = pfad.getText();
+			tmpPf += "/variable/";
+			tmpPf += name;
+			tmpPf += ".v";
+			if (!d.umbenennen(tmpPf))
+			{
+				err = "Fehler beim schreiben von ";
+				err += tmpPf.getText();
+				return 0;
+			}
+		}
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			__int64 size;
+			k->getNachrichtEncrypted((char*)&size, 8);
+			char buffer[2048];
+			while (size > 0)
+			{
+				k->getNachrichtEncrypted(buffer, MIN(2048, (int)size));
+				d.schreibe(buffer, MIN(2048, (int)size));
+				size -= 2048;
+			}
+			d.close();
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		delete[]name;
+		delete[]originalName;
+	}
+	case 0x1D: // Add Bariere
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/bariere/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".b"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".b";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int style;
+			int verschiebungWeite;
+			int autoSchaltungMaxTime;
+			int team;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&style, 4);
+			k->getNachrichtEncrypted((char*)&verschiebungWeite, 4);
+			k->getNachrichtEncrypted((char*)&autoSchaltungMaxTime, 4);
+			k->getNachrichtEncrypted((char*)&team, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&style, 4);
+			d.schreibe((char*)&verschiebungWeite, 4);
+			d.schreibe((char*)&autoSchaltungMaxTime, 4);
+			d.schreibe((char*)&team, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x1E: // Add Base
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/base/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".b"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".b";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int maxTime;
+			int team;
+			bool showTimer;
+			int timerX;
+			int timerY;
+			int timerFarbe;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&maxTime, 4);
+			k->getNachrichtEncrypted((char*)&team, 4);
+			k->getNachrichtEncrypted((char*)&showTimer, 1);
+			k->getNachrichtEncrypted((char*)&timerX, 4);
+			k->getNachrichtEncrypted((char*)&timerY, 4);
+			k->getNachrichtEncrypted((char*)&timerFarbe, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&maxTime, 4);
+			d.schreibe((char*)&team, 4);
+			d.schreibe((char*)&showTimer, 1);
+			d.schreibe((char*)&timerX, 4);
+			d.schreibe((char*)&timerY, 4);
+			d.schreibe((char*)&timerFarbe, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x1F: // Add Drop
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/drop/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".d"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".d";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int minX;
+			int minY;
+			int maxX;
+			int maxY;
+			int maxTime;
+			int numDrops;
+			float wahrscheinlichkeit[ITEMANZAHL];
+			unsigned char len;
+			k->getNachrichtEncrypted((char*)&minX, 4);
+			k->getNachrichtEncrypted((char*)&minY, 4);
+			k->getNachrichtEncrypted((char*)&maxX, 4);
+			k->getNachrichtEncrypted((char*)&maxY, 4);
+			k->getNachrichtEncrypted((char*)&maxTime, 4);
+			k->getNachrichtEncrypted((char*)&numDrops, 4);
+			for (int i = 0; i < ITEMANZAHL; i++)
+				k->getNachrichtEncrypted((char*)&wahrscheinlichkeit[i], 4);
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* name = new char[len];
+			k->getNachrichtEncrypted(name, len);
+			d.schreibe((char*)&minX, 4);
+			d.schreibe((char*)&minY, 4);
+			d.schreibe((char*)&maxX, 4);
+			d.schreibe((char*)&maxY, 4);
+			d.schreibe((char*)&maxTime, 4);
+			d.schreibe((char*)&numDrops, 4);
+			for (int i = 0; i < ITEMANZAHL; i++)
+				d.schreibe((char*)&wahrscheinlichkeit[i], 4);
+			d.schreibe((char*)&len, 1);
+			d.schreibe(name, len);
+			delete[]name;
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x20: // Add Schalter
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schalter/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".s"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".s";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			bool aktive;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&aktive, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&aktive, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x21: // Add Schiene
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schiene/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".s"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".s";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x22: // Add Timer
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/timer/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".t"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int maxZeit;
+			bool sichtbar;
+			bool autoWiederhohlung;
+			bool runns;
+			int farbe;
+			unsigned char len;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&maxZeit, 4);
+			k->getNachrichtEncrypted((char*)&sichtbar, 1);
+			k->getNachrichtEncrypted((char*)&autoWiederhohlung, 1);
+			k->getNachrichtEncrypted((char*)&runns, 1);
+			k->getNachrichtEncrypted((char*)&farbe, 4);
+			k->getNachrichtEncrypted((char*)&len, 1);
+			char* name = new char[len];
+			k->getNachrichtEncrypted(name, len);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&maxZeit, 4);
+			d.schreibe((char*)&sichtbar, 1);
+			d.schreibe((char*)&autoWiederhohlung, 1);
+			d.schreibe((char*)&runns, 1);
+			d.schreibe((char*)&farbe, 4);
+			d.schreibe((char*)&len, 1);
+			d.schreibe(name, len);
+			delete[]name;
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x23: // Add Tunnel
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/tunnel/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".t"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			int zielX;
+			int zielY;
+			bool aktiv;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&zielX, 4);
+			k->getNachrichtEncrypted((char*)&zielY, 4);
+			k->getNachrichtEncrypted((char*)&aktiv, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&zielX, 4);
+			d.schreibe((char*)&zielY, 4);
+			d.schreibe((char*)&aktiv, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x24: // Add Umlenkung
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/umlenkung/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".u"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".u";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			k->sendeEncrypted((char*)&id, 4);
+			int x;
+			int y;
+			int breite;
+			int height;
+			char richtung;
+			int maxAbklingzeit;
+			bool drehend;
+			bool aktiv;
+			k->getNachrichtEncrypted((char*)&x, 4);
+			k->getNachrichtEncrypted((char*)&y, 4);
+			k->getNachrichtEncrypted((char*)&breite, 4);
+			k->getNachrichtEncrypted((char*)&height, 4);
+			k->getNachrichtEncrypted((char*)&richtung, 1);
+			k->getNachrichtEncrypted((char*)&maxAbklingzeit, 4);
+			k->getNachrichtEncrypted((char*)&drehend, 1);
+			k->getNachrichtEncrypted((char*)&aktiv, 1);
+			d.schreibe((char*)&x, 4);
+			d.schreibe((char*)&y, 4);
+			d.schreibe((char*)&breite, 4);
+			d.schreibe((char*)&height, 4);
+			d.schreibe((char*)&richtung, 1);
+			d.schreibe((char*)&maxAbklingzeit, 4);
+			d.schreibe((char*)&drehend, 1);
+			d.schreibe((char*)&aktiv, 1);
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x25: // Add Trigger
+	{
+		Text tmpPf = pfad.getText();
+		tmpPf += "/trigger/";
+		int id = 0;
+		while (true)
+		{
+			if (!DateiExistiert(tmpPf + id + ".t"))
+				break;
+			id++;
+		}
+		tmpPf += id;
+		tmpPf += ".t";
+		Datei d;
+		d.setDatei(tmpPf);
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			__int64 size;
+			k->getNachrichtEncrypted((char*)&size, 8);
+			char buffer[2048];
+			while (size > 0)
+			{
+				k->getNachrichtEncrypted(buffer, MIN(2048, (int)size));
+				d.schreibe(buffer, MIN(2048, (int)size));
+				size -= 2048;
+			}
+			d.close();
+			k->sendeEncrypted("\1", 1);
+			return 1;
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x26: // Add Variable
+	{
+		k->sendeEncrypted("\1", 1);
+		unsigned char len;
+		k->getNachrichtEncrypted((char*)&len, 1);
+		char* name = new char[len + 1];
+		k->getNachrichtEncrypted((char*)&name, len);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/variable/";
+		tmpPf += name;
+		tmpPf += ".v";
+		Datei d;
+		if (d.existiert())
+		{
+			err = "Die Variable existiert bereits";
+			return 0;
+		}
+		d.setDatei(tmpPf);
+		name[len] = 0;
+		if (d.open(Datei::Style::schreiben))
+		{
+			k->sendeEncrypted("\1", 1);
+			__int64 size;
+			k->getNachrichtEncrypted((char*)&size, 8);
+			char buffer[2048];
+			while (size > 0)
+			{
+				k->getNachrichtEncrypted(buffer, MIN(2048, (int)size));
+				d.schreibe(buffer, MIN(2048, (int)size));
+				size -= 2048;
+			}
+			d.close();
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim schreiben von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+		delete[]name;
+	}
+	case 0x27: // Remove Bariere
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/bariere/";
+		tmpPf += id;
+		tmpPf += ".b";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x28: // Remove Base
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/base/";
+		tmpPf += id;
+		tmpPf += ".b";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x29: // Remove Drop
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/drop/";
+		tmpPf += id;
+		tmpPf += ".d";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2A: // Remove Schalter
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schalter/";
+		tmpPf += id;
+		tmpPf += ".s";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2B: // Remove Schiene
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/schiene/";
+		tmpPf += id;
+		tmpPf += ".s";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2C: // Remove Timer
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/timer/";
+		tmpPf += id;
+		tmpPf += ".t";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2D: // Remove Tunnel
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/tunnel/";
+		tmpPf += id;
+		tmpPf += ".t";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2E: // Remove Umlenkung
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/umlenkung/";
+		tmpPf += id;
+		tmpPf += ".u";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x2F: // Remove Trigger
+	{
+		k->sendeEncrypted("\1", 1);
+		int id;
+		k->getNachrichtEncrypted((char*)&id, 4);
+		Text tmpPf = pfad.getText();
+		tmpPf += "/trigger/";
+		tmpPf += id;
+		tmpPf += ".t";
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	case 0x30: // Remove Variable
+	{
+		k->sendeEncrypted("\1", 1);
+		unsigned char len;
+		k->getNachrichtEncrypted((char*)&len, 1);
+		char* name = new char[len + 1];
+		k->getNachrichtEncrypted(name, len);
+		name[len] = 0;
+		Text tmpPf = pfad.getText();
+		tmpPf += "/variable/";
+		tmpPf += name;
+		tmpPf += ".v";
+		delete[]name;
+		if (DateiRemove(tmpPf))
+		{
+			k->sendeEncrypted("\1", 1);
+		}
+		else
+		{
+			err = "Fehler beim löschen von ";
+			err += tmpPf.getText();
+			return 0;
+		}
+	}
+	default:
+		err = "Unbekannte Nachricht. Error Code: " __FILE__ ":";
+		err += __LINE__;
+		return 0;
+	}
+	return 0;
 }
 
 // constant
-char* Editor::getLetzterFehler() const
+const char* Editor::getLetzterFehler() const
 {
-    return err;
+	return err;
 }
 
 // privat
 bool Editor::createSitzung()
 {
-    DateiRemove( pfad );
-    Text pf = pfad.getText();
-    pf.remove( pf.getLength() - 6, pf.getLength() );
-    pf += "map/server/sts.ltgd";
-    int spielerAnzahl;
-    int teamAnzahl;
-    Datei d;
-    d.setDatei( pf );
-    if( !d.existiert() || d.istOrdner() )
-    {
-        err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
-        err += pf;
-        err += ". Fehler Code: " __FILE__ ":";
-        err += __LINE__;
-        err += "\n";
-        return 0;
-    }
-    d.open( Datei::Style::lesen );
-    d.lese( (char*)&spielerAnzahl, 4 );
-    d.lese( (char*)&teamAnzahl, 4 );
-    d.close();
-    pf = pfad.getText();
-    pf.remove( pf.getLength() - 6, pf.getLength() );
-    pf += "map/server/data.map";
-    d.setDatei( pf.getText() );
-    if( d.open( Datei::Style::lesen ) )
-    {
-        // map size
-        pf = pfad.getText();
-        pf += "/size";
-        Datei s;
-        s.setDatei( pf.getText() );
-        if( !s.open( Datei::Style::schreiben ) )
-        {
-            err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
-            err += pf;
-            err += ". Fehler Code: " __FILE__ ":";
-            err += __LINE__;
-            err += "\n";
-        }
-        __int64 size = 0;
-        d.lese( (char*)&size, 8 );
-        s.schreibe( (char*)&size, 8 );
-        s.close();
-        // teams
-        pf = pfad.getText();
-        pf += "/team/";
-        for( int i = 0; i < teamAnzahl; i++ )
-        {
-            Text tmpPf = pf.getText();
-            tmpPf += i;
-            tmpPf += ".t";
-            int maxWbZeit;
-            int punkte;
-            d.lese( (char*)&maxWbZeit, 4 );
-            d.lese( (char*)&punkte, 4 );
-            Datei t;
-            t.setDatei( tmpPf );
-            t.erstellen();
-            if( !t.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            t.schreibe( (char*)&maxWbZeit, 4 );
-            t.schreibe( (char*)&punkte, 4 );
-            t.close();
-        }
-        // spieler
-        pf = pfad.getText();
-        pf += "/player/";
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            Text tmpPf = pf.getText();
-            tmpPf += i;
-            tmpPf += ".p";
-            int spawnX;
-            int spawnY;
-            d.lese( (char*)&spawnX, 4 );
-            d.lese( (char*)&spawnY, 4 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( (char*)&spawnX, 4 );
-            s.schreibe( (char*)&spawnY, 4 );
-            s.close();
-        }
-        // barieren
-        pf = pfad.getText();
-        pf += "/bariere/";
-        int anz;
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".b";
-            char buffer[ 32 ];
-            d.lese( buffer, 32 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 32 );
-            s.close();
-        }
-        // basen
-        pf = pfad.getText();
-        pf += "/base/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".b";
-            char buffer[ 24 ];
-            d.lese( buffer, 24 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 24 );
-            s.close();
-        }
-        // drops
-        pf = pfad.getText();
-        pf += "/drop/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".d";
-            char buffer[ 96 ];
-            d.lese( buffer, 96 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 96 );
-            unsigned char len;
-            d.lese( (char*)&len, 1 );
-            char* name = new char[ (int)len + 1 ];
-            d.lese( name, len );
-            name[ (int)len ] = 0;
-            s.schreibe( (char*)&len, 1 );
-            s.schreibe( (char*)&name, len );
-            delete[] name;
-            s.close();
-        }
-        // schalter
-        pf = pfad.getText();
-        pf += "/schalter/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".s";
-            char buffer[ 17 ];
-            d.lese( buffer, 17 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 17 );
-            s.close();
-        }
-        // schiene
-        pf = pfad.getText();
-        pf += "/schiene/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".s";
-            char buffer[ 16 ];
-            d.lese( buffer, 16 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 16 );
-            s.close();
-        }
-        // timer
-        pf = pfad.getText();
-        pf += "/timer/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".t";
-            char buffer[ 19 ];
-            d.lese( buffer, 19 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 19 );
-            unsigned char len;
-            d.lese( (char*)&len, 1 );
-            char* name = new char[ (int)len + 1 ];
-            d.lese( name, len );
-            name[ (int)len ] = 0;
-            s.schreibe( (char*)&len, 1 );
-            s.schreibe( (char*)&name, len );
-            delete[] name;
-            s.close();
-        }
-        // tunnel
-        pf = pfad.getText();
-        pf += "/tunnel/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".t";
-            char buffer[ 25 ];
-            d.lese( buffer, 25 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 25 );
-            s.close();
-        }
-        // umlenkung
-        pf = pfad.getText();
-        pf += "/umlenkung/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".u";
-            char buffer[ 23 ];
-            d.lese( buffer, 23 );
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            s.schreibe( buffer, 23 );
-            s.close();
-        }
-        // trigger
-        MapReader mr;
-        pf = pfad.getText();
-        pf += "/trigger/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            int id;
-            d.lese( (char*)&id, 4 );
-            Text tmpPf = pf.getText();
-            tmpPf += id;
-            tmpPf += ".t";
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            unsigned char len;
-            d.lese( (char*)&len, 1 );
-            char* name = new char[ (int)len + 1 ];
-            d.lese( name, len );
-            name[ (int)len ] = 0;
-            s.schreibe( (char*)&len, 1 );
-            s.schreibe( (char*)&name, len );
-            delete[] name;
-            int ereignisAnzahl;
-            int bedingungAnzahl;
-            int aktionAnzahl;
-            d.lese( (char*)&ereignisAnzahl, 4 );
-            d.lese( (char*)&bedingungAnzahl, 4 );
-            d.lese( (char*)&aktionAnzahl, 4 );
-            s.schreibe( (char*)&ereignisAnzahl, 4 );
-            s.schreibe( (char*)&bedingungAnzahl, 4 );
-            s.schreibe( (char*)&aktionAnzahl, 4 );
-            for( int j = 0; j < ereignisAnzahl; j++ )
-            {
-                int typ;
-                d.lese( (char*)&typ, 4 );
-                s.schreibe( (char*)&typ, 4 );
-            }
-            for( int j = 0; j < bedingungAnzahl; j++ )
-                mr.writeAktion( mr.readAktion( d ), s );
-            for( int j = 0; j < aktionAnzahl; j++ )
-                mr.writeAktion( mr.readAktion( d ), s );
-            s.close();
-        }
-        // variable
-        pf = pfad.getText();
-        pf += "/variable/";
-        d.lese( (char*)&anz, 4 );
-        for( int i = 0; i < anz; i++ )
-        {
-            char len;
-            d.lese( (char*)&len, 1 );
-            char* name = new char[ (int)len + 1 ];
-            d.lese( name, len );
-            name[ (int)len ] = 0;
-            Text tmpPf = pf.getText();
-            tmpPf += name;
-            tmpPf += ".v";
-            delete[] name;
-            Datei s;
-            s.setDatei( tmpPf );
-            s.erstellen();
-            if( !s.open( Datei::Style::schreiben ) )
-            {
-                err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
-                err += tmpPf;
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                err += "\n";
-            }
-            char typ;
-            d.lese( &typ, 1 );
-            char def;
-            d.lese( &def, 1 );
-            s.schreibe( &typ, 1 );
-            s.schreibe( &def, 1 );
-            if( def )
-            {
-                if( typ == BOOLEAN || typ == TASTE )
-                {
-                    char v;
-                    d.lese( &v, 1 );
-                    s.schreibe( &v, 1 );
-                }
-                else if( typ == STRING || typ == RICHTUNG )
-                {
-                    char len;
-                    d.lese( (char*)&len, 1 );
-                    char* str = new char[ (int)len + 1 ];
-                    d.lese( str, len );
-                    s.schreibe( &len, 1 );
-                    s.schreibe( str, len );
-                    delete[] str;
-                }
-                else if( typ != NICHTS )
-                {
-                    int v;
-                    d.lese( (char*)&v, 4 );
-                    s.schreibe( (char*)&v, 4 );
-                }
-            }
-            s.close();
-        }
-        d.close();
-    }
-    else
-    {
-        err = "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
-        err += pf;
-        err += ". Fehler Code: " __FILE__ ":";
-        err += __LINE__;
-        pf = pfad.getText();
-        pf += "/empty.file";
-        DateiPfadErstellen( pf );
-        DateiRemove( pf );
-    }
-    if( !err.getLength() )
-        return 1;
-    else
-        return 0;
-    return 0;
+	DateiRemove(pfad);
+	Text pf = pfad.getText();
+	pf.remove(pf.getLength() - 6, pf.getLength());
+	pf += "map/server/sts.ltgd";
+	int spielerAnzahl;
+	int teamAnzahl;
+	Datei d;
+	d.setDatei(pf);
+	if (!d.existiert() || d.istOrdner())
+	{
+		err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+		err += pf;
+		err += ". Fehler Code: " __FILE__ ":";
+		err += __LINE__;
+		err += "\n";
+		return 0;
+	}
+	d.open(Datei::Style::lesen);
+	d.lese((char*)&spielerAnzahl, 4);
+	d.lese((char*)&teamAnzahl, 4);
+	d.close();
+	pf = pfad.getText();
+	pf.remove(pf.getLength() - 6, pf.getLength());
+	pf += "map/server/data.map";
+	d.setDatei(pf.getText());
+	if (d.open(Datei::Style::lesen))
+	{
+		// map size
+		pf = pfad.getText();
+		pf += "/size";
+		Datei s;
+		s.setDatei(pf.getText());
+		if (!s.open(Datei::Style::schreiben))
+		{
+			err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+			err += pf;
+			err += ". Fehler Code: " __FILE__ ":";
+			err += __LINE__;
+			err += "\n";
+		}
+		__int64 size = 0;
+		d.lese((char*)&size, 8);
+		s.schreibe((char*)&size, 8);
+		s.close();
+		// teams
+		pf = pfad.getText();
+		pf += "/team/";
+		for (int i = 0; i < teamAnzahl; i++)
+		{
+			Text tmpPf = pf.getText();
+			tmpPf += i;
+			tmpPf += ".t";
+			int maxWbZeit;
+			int punkte;
+			d.lese((char*)&maxWbZeit, 4);
+			d.lese((char*)&punkte, 4);
+			Datei t;
+			t.setDatei(tmpPf);
+			t.erstellen();
+			if (!t.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			t.schreibe((char*)&maxWbZeit, 4);
+			t.schreibe((char*)&punkte, 4);
+			t.close();
+		}
+		// spieler
+		pf = pfad.getText();
+		pf += "/player/";
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			Text tmpPf = pf.getText();
+			tmpPf += i;
+			tmpPf += ".p";
+			int spawnX;
+			int spawnY;
+			d.lese((char*)&spawnX, 4);
+			d.lese((char*)&spawnY, 4);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe((char*)&spawnX, 4);
+			s.schreibe((char*)&spawnY, 4);
+			s.close();
+		}
+		// barieren
+		pf = pfad.getText();
+		pf += "/bariere/";
+		int anz;
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".b";
+			char buffer[32];
+			d.lese(buffer, 32);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 32);
+			s.close();
+		}
+		// basen
+		pf = pfad.getText();
+		pf += "/base/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".b";
+			char buffer[24];
+			d.lese(buffer, 24);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 24);
+			s.close();
+		}
+		// drops
+		pf = pfad.getText();
+		pf += "/drop/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".d";
+			char buffer[96];
+			d.lese(buffer, 96);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 96);
+			unsigned char len;
+			d.lese((char*)&len, 1);
+			char* name = new char[(int)len + 1];
+			d.lese(name, len);
+			name[(int)len] = 0;
+			s.schreibe((char*)&len, 1);
+			s.schreibe((char*)&name, len);
+			delete[] name;
+			s.close();
+		}
+		// schalter
+		pf = pfad.getText();
+		pf += "/schalter/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".s";
+			char buffer[17];
+			d.lese(buffer, 17);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 17);
+			s.close();
+		}
+		// schiene
+		pf = pfad.getText();
+		pf += "/schiene/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".s";
+			char buffer[16];
+			d.lese(buffer, 16);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 16);
+			s.close();
+		}
+		// timer
+		pf = pfad.getText();
+		pf += "/timer/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".t";
+			char buffer[19];
+			d.lese(buffer, 19);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 19);
+			unsigned char len;
+			d.lese((char*)&len, 1);
+			char* name = new char[(int)len + 1];
+			d.lese(name, len);
+			name[(int)len] = 0;
+			s.schreibe((char*)&len, 1);
+			s.schreibe((char*)&name, len);
+			delete[] name;
+			s.close();
+		}
+		// tunnel
+		pf = pfad.getText();
+		pf += "/tunnel/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".t";
+			char buffer[25];
+			d.lese(buffer, 25);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 25);
+			s.close();
+		}
+		// umlenkung
+		pf = pfad.getText();
+		pf += "/umlenkung/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".u";
+			char buffer[23];
+			d.lese(buffer, 23);
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			s.schreibe(buffer, 23);
+			s.close();
+		}
+		// trigger
+		MapReader mr;
+		pf = pfad.getText();
+		pf += "/trigger/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			int id;
+			d.lese((char*)&id, 4);
+			Text tmpPf = pf.getText();
+			tmpPf += id;
+			tmpPf += ".t";
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			unsigned char len;
+			d.lese((char*)&len, 1);
+			char* name = new char[(int)len + 1];
+			d.lese(name, len);
+			name[(int)len] = 0;
+			s.schreibe((char*)&len, 1);
+			s.schreibe((char*)&name, len);
+			delete[] name;
+			int ereignisAnzahl;
+			int bedingungAnzahl;
+			int aktionAnzahl;
+			d.lese((char*)&ereignisAnzahl, 4);
+			d.lese((char*)&bedingungAnzahl, 4);
+			d.lese((char*)&aktionAnzahl, 4);
+			s.schreibe((char*)&ereignisAnzahl, 4);
+			s.schreibe((char*)&bedingungAnzahl, 4);
+			s.schreibe((char*)&aktionAnzahl, 4);
+			for (int j = 0; j < ereignisAnzahl; j++)
+			{
+				int typ;
+				d.lese((char*)&typ, 4);
+				s.schreibe((char*)&typ, 4);
+			}
+			for (int j = 0; j < bedingungAnzahl; j++)
+				mr.writeAktion(mr.readAktion(d), s);
+			for (int j = 0; j < aktionAnzahl; j++)
+				mr.writeAktion(mr.readAktion(d), s);
+			s.close();
+		}
+		// variable
+		pf = pfad.getText();
+		pf += "/variable/";
+		d.lese((char*)&anz, 4);
+		for (int i = 0; i < anz; i++)
+		{
+			char len;
+			d.lese((char*)&len, 1);
+			char* name = new char[(int)len + 1];
+			d.lese(name, len);
+			name[(int)len] = 0;
+			Text tmpPf = pf.getText();
+			tmpPf += name;
+			tmpPf += ".v";
+			delete[] name;
+			Datei s;
+			s.setDatei(tmpPf);
+			s.erstellen();
+			if (!s.open(Datei::Style::schreiben))
+			{
+				err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim schreiben von ";
+				err += tmpPf;
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				err += "\n";
+			}
+			char typ;
+			d.lese(&typ, 1);
+			char def;
+			d.lese(&def, 1);
+			s.schreibe(&typ, 1);
+			s.schreibe(&def, 1);
+			if (def)
+			{
+				if (typ == BOOLEAN || typ == TASTE)
+				{
+					char v;
+					d.lese(&v, 1);
+					s.schreibe(&v, 1);
+				}
+				else if (typ == STRING || typ == RICHTUNG)
+				{
+					char len;
+					d.lese((char*)&len, 1);
+					char* str = new char[(int)len + 1];
+					d.lese(str, len);
+					s.schreibe(&len, 1);
+					s.schreibe(str, len);
+					delete[] str;
+				}
+				else if (typ != NICHTS)
+				{
+					int v;
+					d.lese((char*)&v, 4);
+					s.schreibe((char*)&v, 4);
+				}
+			}
+			s.close();
+		}
+		d.close();
+	}
+	else
+	{
+		err = "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+		err += pf;
+		err += ". Fehler Code: " __FILE__ ":";
+		err += __LINE__;
+		pf = pfad.getText();
+		pf += "/empty.file";
+		DateiPfadErstellen(pf);
+		DateiRemove(pf);
+	}
+	if (!err.getLength())
+		return 1;
+	else
+		return 0;
+	return 0;
 }
 
 bool Editor::saveSitzung()
 {
-    Text pf = pfad.getText();
-    pf.remove( pf.getLength() - 6, pf.getLength() );
-    pf += "map/server/sts.ltgd";
-    int spielerAnzahl;
-    int teamAnzahl;
-    Datei d;
-    d.setDatei( pf );
-    if( !d.existiert() || d.istOrdner() )
-    {
-        err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
-        err += pf;
-        err += ". Fehler Code: " __FILE__ ":";
-        err += __LINE__;
-        err += "\n";
-        return 0;
-    }
-    d.open( Datei::Style::lesen );
-    d.lese( (char*)&spielerAnzahl, 4 );
-    d.lese( (char*)&teamAnzahl, 4 );
-    d.close();
-    pf = pfad.getText();
-    pf.remove( pf.getLength() - 6, pf.getLength() );
-    pf += "map/server/data_tmp.map";
-    d.setDatei( pf.getText() );
-    if( d.open( Datei::Style::schreiben ) )
-    {
-        pf = pfad.getText();
-        pf += "/size";
-        Datei s;
-        s.setDatei( pf.getText() );
-        if( !s.open( Datei::Style::schreiben ) )
-        {
-            err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
-            err += pf;
-            err += ". Fehler Code: " __FILE__ ":";
-            err += __LINE__;
-            err += "\n";
-        }
-        __int64 size = 0;
-        s.lese( (char*)&size, 8 );
-        d.schreibe( (char*)&size, 8 );
-        s.close();
-        for( int i = 0; i < teamAnzahl; i++ )
-        {
-            Text tmpPf = pfad + "/team/";
-            tmpPf += i;
-            tmpPf += ".t";
-            Datei r;
-            r.setDatei( tmpPf );
-            if( r.open( Datei::Style::lesen ) )
-            {
-                int maxWbZeit;
-                int punkte;
-                r.lese( (char*)&maxWbZeit, 4 );
-                r.lese( (char*)&punkte, 4 );
-                d.schreibe( (char*)&maxWbZeit, 4 );
-                d.schreibe( (char*)&punkte, 4 );
-                r.close();
-            }
-            else
-            {
-                err = "Fehler beim Lesen von ";
-                err += tmpPf.getText();
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                d.close();
-                d.remove();
-                return 0;
-            }
-        }
-        for( int i = 0; i < spielerAnzahl; i++ )
-        {
-            Text tmpPf = pfad + "/player/";
-            tmpPf += i;
-            tmpPf += ".p";
-            Datei r;
-            r.setDatei( tmpPf );
-            if( r.open( Datei::Style::lesen ) )
-            {
-                int spawnX;
-                int spawnY;
-                r.lese( (char*)&spawnX, 4 );
-                r.lese( (char*)&spawnY, 4 );
-                d.schreibe( (char*)&spawnX, 4 );
-                d.schreibe( (char*)&spawnY, 4 );
-                r.close();
-            }
-            else
-            {
-                err = "Fehler beim Lesen von ";
-                err += tmpPf.getText();
-                err += ". Fehler Code: " __FILE__ ":";
-                err += __LINE__;
-                d.close();
-                d.remove();
-                return 0;
-            }
-        }
-        pf = pfad.getText();
-        pf += "/bariere";
-        Datei obj;
-        obj.setDatei( pf );
-        RCArray<Text>* objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 32 ];
-                    r.lese( buffer, 32 );
-                    d.schreibe( buffer, 32 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/base";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 24 ];
-                    r.lese( buffer, 24 );
-                    d.schreibe( buffer, 24 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/drop";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 96 ];
-                    r.lese( buffer, 96 );
-                    d.schreibe( buffer, 96 );
-                    unsigned char len;
-                    r.lese( (char*)&len, 1 );
-                    char* name = new char[ (int)len + 1 ];
-                    r.lese( name, len );
-                    name[ (int)len ] = 0;
-                    d.schreibe( (char*)&len, 1 );
-                    d.schreibe( (char*)&name, len );
-                    delete[] name;
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/schalter";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 17 ];
-                    r.lese( buffer, 17 );
-                    d.schreibe( buffer, 17 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/schiene";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 16 ];
-                    r.lese( buffer, 16 );
-                    d.schreibe( buffer, 16 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/timer";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 19 ];
-                    r.lese( buffer, 19 );
-                    d.schreibe( buffer, 19 );
-                    unsigned char len;
-                    r.lese( (char*)&len, 1 );
-                    char* name = new char[ (int)len + 1 ];
-                    r.lese( name, len );
-                    name[ (int)len ] = 0;
-                    d.schreibe( (char*)&len, 1 );
-                    d.schreibe( (char*)&name, len );
-                    delete[] name;
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/tunnel";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 25 ];
-                    r.lese( buffer, 25 );
-                    d.schreibe( buffer, 25 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/umlenkung";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    char buffer[ 23 ];
-                    r.lese( buffer, 23 );
-                    d.schreibe( buffer, 23 );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/trigger";
-        MapReader mr;
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    int id = (int)*objPf.val();
-                    d.schreibe( (char*)&id, 4 );
-                    unsigned char len;
-                    r.lese( (char*)&len, 1 );
-                    char* name = new char[ (int)len + 1 ];
-                    r.lese( name, len );
-                    name[ (int)len ] = 0;
-                    d.schreibe( (char*)&len, 1 );
-                    d.schreibe( (char*)&name, len );
-                    delete[] name;
-                    int ereignisAnzahl;
-                    int bedingungAnzahl;
-                    int aktionAnzahl;
-                    r.lese( (char*)&ereignisAnzahl, 4 );
-                    r.lese( (char*)&bedingungAnzahl, 4 );
-                    r.lese( (char*)&aktionAnzahl, 4 );
-                    d.schreibe( (char*)&ereignisAnzahl, 4 );
-                    d.schreibe( (char*)&bedingungAnzahl, 4 );
-                    d.schreibe( (char*)&aktionAnzahl, 4 );
-                    for( int j = 0; j < ereignisAnzahl; j++ )
-                    {
-                        int typ;
-                        r.lese( (char*)&typ, 4 );
-                        d.schreibe( (char*)&typ, 4 );
-                    }
-                    for( int j = 0; j < bedingungAnzahl; j++ )
-                        mr.writeAktion( mr.readAktion( r ), d );
-                    for( int j = 0; j < aktionAnzahl; j++ )
-                        mr.writeAktion( mr.readAktion( r ), d );
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf += "/variable";
-        obj.setDatei( pf );
-        objList = obj.getDateiListe();
-        if( objList )
-        {
-            int anz = objList->getEintragAnzahl();
-            d.schreibe( (char*)&anz, 4 );
-            for( auto objPf = objList->begin(); objPf && objPf._; objPf++ )
-            {
-                Text tmp = pf.getText();
-                tmp += "/";
-                tmp += objPf->getText();
-                Datei r;
-                r.setDatei( tmp );
-                if( r.open( Datei::Style::lesen ) )
-                {
-                    unsigned char len = (unsigned char)(objPf->getLength() - 2);
-                    d.schreibe( (char*)&len, 1 );
-                    d.schreibe( objPf->getText(), len );
-                    char typ;
-                    r.lese( &typ, 1 );
-                    char def;
-                    r.lese( &def, 1 );
-                    d.schreibe( &typ, 1 );
-                    d.schreibe( &def, 1 );
-                    if( def )
-                    {
-                        if( typ == BOOLEAN || typ == TASTE )
-                        {
-                            char v;
-                            r.lese( &v, 1 );
-                            d.schreibe( &v, 1 );
-                        }
-                        else if( typ == STRING || typ == RICHTUNG )
-                        {
-                            char len;
-                            r.lese( (char*)&len, 1 );
-                            char* str = new char[ (int)len + 1 ];
-                            r.lese( str, len );
-                            d.schreibe( &len, 1 );
-                            d.schreibe( str, len );
-                            delete[] str;
-                        }
-                        else if( typ != NICHTS )
-                        {
-                            int v;
-                            r.lese( (char*)&v, 4 );
-                            d.schreibe( (char*)&v, 4 );
-                        }
-                    }
-                    r.close();
-                }
-                else
-                {
-                    err = "Fehler beim Lesen von ";
-                    err += tmp.getText();
-                    err = ". Fehler Code: " __FILE__ ":";
-                    err += __LINE__;
-                    d.close();
-                    d.remove();
-                    objList->release();
-                    return 0;
-                }
-            }
-            objList->release();
-        }
-        else
-            d.schreibe( "\0\0\0\0", 4 );
-        pf = pfad.getText();
-        pf.remove( pf.getLength() - 6, pf.getLength() );
-        pf += "map/server/data.map";
-        d.close();
-        if( !DateiRemove( pf ) || !d.umbenennen( pf ) )
-        {
-            err = "Fehler beim Übernehmen der Änderungen. Fehler Code: " __FILE__ ":";
-            err += __LINE__;
-            return 0;
-        }
-    }
-    else
-    {
-        err = "Fehler beim Speichern der Änderungen (Server). Fehler Code: " __FILE__ ":";
-        err += __LINE__;
-        return 0;
-    }
-    pf = pfad.getText();
-    pf.remove( pf.getLength() - 6, pf.getLength() );
-    pf += "map/client/map/data/data.map";
-    Datei d2;
-    d2.setDatei( pf.getText() );
-    if( d2.open( Datei::Style::schreiben ) && d.open( Datei::Style::lesen ) )
-    {
-        __int64 size = d.getSize();
-        char* buffer = new char[ 2048 ];
-        while( size > 0 )
-        {
-            int len = (int)(size > 2048 ? 2048 : size);
-            d.lese( buffer, len );
-            d2.schreibe( buffer, len );
-            size -= len;
-        }
-        delete[] buffer;
-        d.close();
-        d2.close();
-    }
-    else
-    {
-        err = "Fehler beim Speichern der Änderungen (Client). Fehler Code: " __FILE__ ":";
-        err += __LINE__;
-        return 0;
-    }
-    DateiRemove( pfad.getText() );
-    return 1;
+	Text pf = pfad.getText();
+	pf.remove(pf.getLength() - 6, pf.getLength());
+	pf += "map/server/sts.ltgd";
+	int spielerAnzahl;
+	int teamAnzahl;
+	Datei d;
+	d.setDatei(pf);
+	if (!d.existiert() || d.istOrdner())
+	{
+		err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+		err += pf;
+		err += ". Fehler Code: " __FILE__ ":";
+		err += __LINE__;
+		err += "\n";
+		return 0;
+	}
+	d.open(Datei::Style::lesen);
+	d.lese((char*)&spielerAnzahl, 4);
+	d.lese((char*)&teamAnzahl, 4);
+	d.close();
+	pf = pfad.getText();
+	pf.remove(pf.getLength() - 6, pf.getLength());
+	pf += "map/server/data_tmp.map";
+	d.setDatei(pf.getText());
+	if (d.open(Datei::Style::schreiben))
+	{
+		pf = pfad.getText();
+		pf += "/size";
+		Datei s;
+		s.setDatei(pf.getText());
+		if (!s.open(Datei::Style::schreiben))
+		{
+			err += "Sitzung konnte nicht korrekt erstellt werden. Fehler beim lesen von ";
+			err += pf;
+			err += ". Fehler Code: " __FILE__ ":";
+			err += __LINE__;
+			err += "\n";
+		}
+		__int64 size = 0;
+		s.lese((char*)&size, 8);
+		d.schreibe((char*)&size, 8);
+		s.close();
+		for (int i = 0; i < teamAnzahl; i++)
+		{
+			Text tmpPf = pfad + "/team/";
+			tmpPf += i;
+			tmpPf += ".t";
+			Datei r;
+			r.setDatei(tmpPf);
+			if (r.open(Datei::Style::lesen))
+			{
+				int maxWbZeit;
+				int punkte;
+				r.lese((char*)&maxWbZeit, 4);
+				r.lese((char*)&punkte, 4);
+				d.schreibe((char*)&maxWbZeit, 4);
+				d.schreibe((char*)&punkte, 4);
+				r.close();
+			}
+			else
+			{
+				err = "Fehler beim Lesen von ";
+				err += tmpPf.getText();
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				d.close();
+				d.remove();
+				return 0;
+			}
+		}
+		for (int i = 0; i < spielerAnzahl; i++)
+		{
+			Text tmpPf = pfad + "/player/";
+			tmpPf += i;
+			tmpPf += ".p";
+			Datei r;
+			r.setDatei(tmpPf);
+			if (r.open(Datei::Style::lesen))
+			{
+				int spawnX;
+				int spawnY;
+				r.lese((char*)&spawnX, 4);
+				r.lese((char*)&spawnY, 4);
+				d.schreibe((char*)&spawnX, 4);
+				d.schreibe((char*)&spawnY, 4);
+				r.close();
+			}
+			else
+			{
+				err = "Fehler beim Lesen von ";
+				err += tmpPf.getText();
+				err += ". Fehler Code: " __FILE__ ":";
+				err += __LINE__;
+				d.close();
+				d.remove();
+				return 0;
+			}
+		}
+		pf = pfad.getText();
+		pf += "/bariere";
+		Datei obj;
+		obj.setDatei(pf);
+		RCArray<Text>* objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[32];
+					r.lese(buffer, 32);
+					d.schreibe(buffer, 32);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/base";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[24];
+					r.lese(buffer, 24);
+					d.schreibe(buffer, 24);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/drop";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[96];
+					r.lese(buffer, 96);
+					d.schreibe(buffer, 96);
+					unsigned char len;
+					r.lese((char*)&len, 1);
+					char* name = new char[(int)len + 1];
+					r.lese(name, len);
+					name[(int)len] = 0;
+					d.schreibe((char*)&len, 1);
+					d.schreibe((char*)&name, len);
+					delete[] name;
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/schalter";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[17];
+					r.lese(buffer, 17);
+					d.schreibe(buffer, 17);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/schiene";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[16];
+					r.lese(buffer, 16);
+					d.schreibe(buffer, 16);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/timer";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[19];
+					r.lese(buffer, 19);
+					d.schreibe(buffer, 19);
+					unsigned char len;
+					r.lese((char*)&len, 1);
+					char* name = new char[(int)len + 1];
+					r.lese(name, len);
+					name[(int)len] = 0;
+					d.schreibe((char*)&len, 1);
+					d.schreibe((char*)&name, len);
+					delete[] name;
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/tunnel";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[25];
+					r.lese(buffer, 25);
+					d.schreibe(buffer, 25);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/umlenkung";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					char buffer[23];
+					r.lese(buffer, 23);
+					d.schreibe(buffer, 23);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/trigger";
+		MapReader mr;
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					int id = (int)*objPf.val();
+					d.schreibe((char*)&id, 4);
+					unsigned char len;
+					r.lese((char*)&len, 1);
+					char* name = new char[(int)len + 1];
+					r.lese(name, len);
+					name[(int)len] = 0;
+					d.schreibe((char*)&len, 1);
+					d.schreibe((char*)&name, len);
+					delete[] name;
+					int ereignisAnzahl;
+					int bedingungAnzahl;
+					int aktionAnzahl;
+					r.lese((char*)&ereignisAnzahl, 4);
+					r.lese((char*)&bedingungAnzahl, 4);
+					r.lese((char*)&aktionAnzahl, 4);
+					d.schreibe((char*)&ereignisAnzahl, 4);
+					d.schreibe((char*)&bedingungAnzahl, 4);
+					d.schreibe((char*)&aktionAnzahl, 4);
+					for (int j = 0; j < ereignisAnzahl; j++)
+					{
+						int typ;
+						r.lese((char*)&typ, 4);
+						d.schreibe((char*)&typ, 4);
+					}
+					for (int j = 0; j < bedingungAnzahl; j++)
+						mr.writeAktion(mr.readAktion(r), d);
+					for (int j = 0; j < aktionAnzahl; j++)
+						mr.writeAktion(mr.readAktion(r), d);
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf += "/variable";
+		obj.setDatei(pf);
+		objList = obj.getDateiListe();
+		if (objList)
+		{
+			int anz = objList->getEintragAnzahl();
+			d.schreibe((char*)&anz, 4);
+			for (auto objPf = objList->begin(); objPf && objPf._; objPf++)
+			{
+				Text tmp = pf.getText();
+				tmp += "/";
+				tmp += objPf->getText();
+				Datei r;
+				r.setDatei(tmp);
+				if (r.open(Datei::Style::lesen))
+				{
+					unsigned char len = (unsigned char)(objPf->getLength() - 2);
+					d.schreibe((char*)&len, 1);
+					d.schreibe(objPf->getText(), len);
+					char typ;
+					r.lese(&typ, 1);
+					char def;
+					r.lese(&def, 1);
+					d.schreibe(&typ, 1);
+					d.schreibe(&def, 1);
+					if (def)
+					{
+						if (typ == BOOLEAN || typ == TASTE)
+						{
+							char v;
+							r.lese(&v, 1);
+							d.schreibe(&v, 1);
+						}
+						else if (typ == STRING || typ == RICHTUNG)
+						{
+							char len;
+							r.lese((char*)&len, 1);
+							char* str = new char[(int)len + 1];
+							r.lese(str, len);
+							d.schreibe(&len, 1);
+							d.schreibe(str, len);
+							delete[] str;
+						}
+						else if (typ != NICHTS)
+						{
+							int v;
+							r.lese((char*)&v, 4);
+							d.schreibe((char*)&v, 4);
+						}
+					}
+					r.close();
+				}
+				else
+				{
+					err = "Fehler beim Lesen von ";
+					err += tmp.getText();
+					err = ". Fehler Code: " __FILE__ ":";
+					err += __LINE__;
+					d.close();
+					d.remove();
+					objList->release();
+					return 0;
+				}
+			}
+			objList->release();
+		}
+		else
+			d.schreibe("\0\0\0\0", 4);
+		pf = pfad.getText();
+		pf.remove(pf.getLength() - 6, pf.getLength());
+		pf += "map/server/data.map";
+		d.close();
+		if (!DateiRemove(pf) || !d.umbenennen(pf))
+		{
+			err = "Fehler beim Übernehmen der Änderungen. Fehler Code: " __FILE__ ":";
+			err += __LINE__;
+			return 0;
+		}
+	}
+	else
+	{
+		err = "Fehler beim Speichern der Änderungen (Server). Fehler Code: " __FILE__ ":";
+		err += __LINE__;
+		return 0;
+	}
+	pf = pfad.getText();
+	pf.remove(pf.getLength() - 6, pf.getLength());
+	pf += "map/client/map/data/data.map";
+	Datei d2;
+	d2.setDatei(pf.getText());
+	if (d2.open(Datei::Style::schreiben) && d.open(Datei::Style::lesen))
+	{
+		__int64 size = d.getSize();
+		char* buffer = new char[2048];
+		while (size > 0)
+		{
+			int len = (int)(size > 2048 ? 2048 : size);
+			d.lese(buffer, len);
+			d2.schreibe(buffer, len);
+			size -= len;
+		}
+		delete[] buffer;
+		d.close();
+		d2.close();
+	}
+	else
+	{
+		err = "Fehler beim Speichern der Änderungen (Client). Fehler Code: " __FILE__ ":";
+		err += __LINE__;
+		return 0;
+	}
+	DateiRemove(pfad.getText());
+	return 1;
 }

StickmanWorldOnline/Editor.h

@@ -9,22 +9,22 @@ using namespace Framework;
 class Editor : public ESEditorV
 {
 private:
-    Text pfad;
-    Text err;
+	Text pfad;
+	Text err;
 
 public:
-    // Konstruktor
-    Editor();
-    // Destruktor
-    ~Editor();
-    // nicht constant
-    void setPfad( char *pfad ) override;
-    void open() override;
-    bool nachricht( SKlient *k ) override;
-    // constant
-    char *getLetzterFehler() const override;
+	// Konstruktor
+	Editor();
+	// Destruktor
+	~Editor();
+	// nicht constant
+	void setPfad(const char* pfad) override;
+	void open() override;
+	bool nachricht(SKlient* k) override;
+	// constant
+	const char* getLetzterFehler() const override;
 
 private:
-    bool createSitzung();
-    bool saveSitzung();
+	bool createSitzung();
+	bool saveSitzung();
 };

StickmanWorldOnline/Klient.cpp

@@ -4,204 +4,204 @@
 
 // Inhalt der Klient Klasse aus Klient.h
 // Konstruktor
-Klient::Klient( SSKlientV *klient )
-    : ReferenceCounter()
+Klient::Klient(SSKlientV* klient)
+	: ReferenceCounter()
 {
-    this->klient = klient;
+	this->klient = klient;
 }
 
 // Destruktor
 Klient::~Klient()
 {
-    if( klient )
-        klient->release();
+	if (klient)
+		klient->release();
 }
 
 // nicht constant
 void Klient::offline()
 {
-    klient = (SSKlientV *)klient->release();
+	klient = (SSKlientV*)klient->release();
 }
 
-void Klient::online( SSKlientV *zKlient )
+void Klient::online(SSKlientV* zKlient)
 {
-    if( klient )
-        klient = (SSKlientV *)klient->release();
-    klient = dynamic_cast<SSKlientV *>( zKlient->getThis() );
+	if (klient)
+		klient = (SSKlientV*)klient->release();
+	klient = dynamic_cast<SSKlientV*>(zKlient->getThis());
 }
 
-void Klient::sendeInit( RCArray< Spieler > *zSpieler, __int64 seed )
+void Klient::sendeInit(RCArray< Spieler >* zSpieler, __int64 seed)
 {
-    if( !klient )
-        return;
-    short len = (short)( 2 + zSpieler->getEintragAnzahl() * 8 + 8 );
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 0x1;
-    *(char *)( bytes + 1 ) = (char)zSpieler->getEintragAnzahl();
-    for( int i = 0; i < zSpieler->getEintragAnzahl(); i++ )
-    {
-        *(int *)( bytes + 2 + i * 8 ) = zSpieler->z( i )->getId();
-        *(int *)( bytes + 6 + i * 8 ) = zSpieler->z( i )->getAccountId();
-    }
-    *(__int64 *)( bytes + 2 + zSpieler->getEintragAnzahl() * 8 ) = seed;
-    klient->spielNachricht( len, bytes );
-    delete[] bytes;
+	if (!klient)
+		return;
+	short len = (short)(2 + zSpieler->getEintragAnzahl() * 8 + 8);
+	char* bytes = new char[len];
+	*(char*)(bytes) = 0x1;
+	*(char*)(bytes + 1) = (char)zSpieler->getEintragAnzahl();
+	for (int i = 0; i < zSpieler->getEintragAnzahl(); i++)
+	{
+		*(int*)(bytes + 2 + i * 8) = zSpieler->z(i)->getId();
+		*(int*)(bytes + 6 + i * 8) = zSpieler->z(i)->getAccountId();
+	}
+	*(__int64*)(bytes + 2 + zSpieler->getEintragAnzahl() * 8) = seed;
+	klient->spielNachricht(len, bytes);
+	delete[] bytes;
 }
 
-void Klient::sendeSpielerNummer( int sNum )
+void Klient::sendeSpielerNummer(int sNum)
 {
-    if( !klient )
-        return;
-    short len = 5;
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 0x2;
-    *(int *)( bytes + 1 ) = sNum;
-    klient->spielNachricht( len, bytes );
-    delete[] bytes;
+	if (!klient)
+		return;
+	short len = 5;
+	char* bytes = new char[len];
+	*(char*)(bytes) = 0x2;
+	*(int*)(bytes + 1) = sNum;
+	klient->spielNachricht(len, bytes);
+	delete[] bytes;
 }
 
 void Klient::sendeStart()
 {
-    if( !klient )
-        return;
-    char b = 0x3;
-    klient->spielNachricht( 1, &b );
+	if (!klient)
+		return;
+	char b = 0x3;
+	klient->spielNachricht(1, &b);
 }
 
-void Klient::sendeTastaturStatus( int spielerId, char taste, bool aktiv )
+void Klient::sendeTastaturStatus(int spielerId, char taste, bool aktiv)
 {
-    if( !klient )
-        return;
-    short len = 7;
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 0x4;
-    *(char *)( bytes + 1 ) = taste;
-    *(char *)( bytes + 2 ) = (char)aktiv;
-    *(int *)( bytes + 3 ) = spielerId;
-    klient->spielNachricht( len, bytes );
-    delete[] bytes;
+	if (!klient)
+		return;
+	short len = 7;
+	char* bytes = new char[len];
+	*(char*)(bytes) = 0x4;
+	*(char*)(bytes + 1) = taste;
+	*(char*)(bytes + 2) = (char)aktiv;
+	*(int*)(bytes + 3) = spielerId;
+	klient->spielNachricht(len, bytes);
+	delete[] bytes;
 }
 
-void Klient::sendeSpielEnde( char gewonnen )
+void Klient::sendeSpielEnde(char gewonnen)
 {
-    if( !klient )
-        return;
-    short len = 2;
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 0x5;
-    *(char *)( bytes + 1 ) = gewonnen;
-    klient->spielNachricht( len, bytes );
-    delete[] bytes;
+	if (!klient)
+		return;
+	short len = 2;
+	char* bytes = new char[len];
+	*(char*)(bytes) = 0x5;
+	*(char*)(bytes + 1) = gewonnen;
+	klient->spielNachricht(len, bytes);
+	delete[] bytes;
 }
 
 void Klient::sendeTick()
 {
-    if( !klient )
-        return;
-    char b = 0x6;
-    klient->spielNachricht( 1, &b );
-}
-
-void Klient::sendeChatNachricht( char *txt )
-{
-    if( !klient )
-        return;
-    short len = (short)( 1 + textLength( txt ) );
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 0x7;
-    for( int i = 1; i < len; i++ )
-        bytes[ i ] = txt[ i - 1 ];
-    klient->spielNachricht( len, bytes );
-    delete[] bytes;
-}
-
-void Klient::sendeStatistikChatNachricht( int vonAccount, char *txt )
-{
-    if( !klient )
-        return;
-    short len = (short)( 5 + textLength( txt ) );
-    char *bytes = new char[ len ];
-    *(char *)( bytes ) = 3;
-    *(int *)( bytes + 1 ) = vonAccount;
-    for( int i = 5; i < len; i++ )
-        bytes[ i ] = txt[ i - 5 ];
-    klient->statistikNachricht( len, bytes );
-    delete[] bytes;
-}
-
-void Klient::sendeStatistikSpielerOffline( int account )
-{
-    if( !klient )
-        return;
-    char *bytes = new char[ 5 ];
-    *(char *)( bytes ) = 4;
-    *(int *)( bytes + 1 ) = account;
-    klient->statistikNachricht( 5, bytes );
-    delete[] bytes;
-}
-
-void Klient::sendeSpielerStatistik( Spieler *zS )
-{
-    if( !zS || !klient )
-        return;
-    char snl = (char)textLength( zS->getName() );
-    char tnl = (char)zS->zTeam()->getName().getLength();
-    int len = 55 + snl + tnl;
-    char *bytes = new char[ len ];
-    bytes[ 0 ] = 0;
-    *(int *)( bytes + 1 ) = zS->getId();
-    *(char *)( bytes + 5 ) = snl;
-    for( int i = 0; i < snl; i++ )
-        bytes[ i + 6 ] = zS->getName()[ i ];
-    *(char *)( bytes + 6 + snl ) = tnl;
-    for( int i = 0; i < tnl; i++ )
-        bytes[ i + 7 + snl ] = zS->zTeam()->getName()[ i ];
-    *(int *)( bytes + 7 + snl + tnl ) = zS->getFarbe();
-    *(int *)( bytes + 11 + snl + tnl ) = zS->zTeam()->getFarbe();
-    *(int *)( bytes + 15 + snl + tnl ) = (int)zS->getErlittenerSchaden();
-    *(int *)( bytes + 19 + snl + tnl ) = (int)zS->getGemachterSchaden();
-    *(int *)( bytes + 23 + snl + tnl ) = (int)zS->getGeheiltesLeben();
-    *(int *)( bytes + 27 + snl + tnl ) = zS->getGeschossen();
-    *(int *)( bytes + 31 + snl + tnl ) = zS->getTreffer();
-    *(int *)( bytes + 35 + snl + tnl ) = zS->getPunkte();
-    *(int *)( bytes + 39 + snl + tnl ) = zS->getKills();
-    *(int *)( bytes + 43 + snl + tnl ) = zS->getTode();
-    *(int *)( bytes + 47 + snl + tnl ) = zS->getItemsAufgehoben();
-    *(int *)( bytes + 51 + snl + tnl ) = zS->getItemsVerwendet();
-    klient->statistikNachricht( (short)len, bytes );
-    delete[] bytes;
-}
-
-void Klient::sendeTeamStatistik( Team *zS )
-{
-    if( !zS || !klient )
-        return;
-    char tnl = (char)zS->getName().getLength();
-    int len = 22 + tnl;
-    char *bytes = new char[ len ];
-    bytes[ 0 ] = 1;
-    *(int *)( bytes + 1 ) = zS->getTeamNummer();
-    *(char *)( bytes + 5 ) = tnl;
-    for( int i = 0; i < tnl; i++ )
-        bytes[ i + 6 ] = zS->getName()[ i ];
-    *(int *)( bytes + 6 + tnl ) = zS->getFarbe();
-    *(int *)( bytes + 10 + tnl ) = zS->getPunkte();
-    *(int *)( bytes + 14 + tnl ) = zS->getKills();
-    *(int *)( bytes + 18 + tnl ) = zS->getTode();
-    klient->statistikNachricht( (short)len, bytes );
-    delete[] bytes;
+	if (!klient)
+		return;
+	char b = 0x6;
+	klient->spielNachricht(1, &b);
+}
+
+void Klient::sendeChatNachricht(const char* txt)
+{
+	if (!klient)
+		return;
+	short len = (short)(1 + textLength(txt));
+	char* bytes = new char[len];
+	*(char*)(bytes) = 0x7;
+	for (int i = 1; i < len; i++)
+		bytes[i] = txt[i - 1];
+	klient->spielNachricht(len, bytes);
+	delete[] bytes;
+}
+
+void Klient::sendeStatistikChatNachricht(int vonAccount, const char* txt)
+{
+	if (!klient)
+		return;
+	short len = (short)(5 + textLength(txt));
+	char* bytes = new char[len];
+	*(char*)(bytes) = 3;
+	*(int*)(bytes + 1) = vonAccount;
+	for (int i = 5; i < len; i++)
+		bytes[i] = txt[i - 5];
+	klient->statistikNachricht(len, bytes);
+	delete[] bytes;
+}
+
+void Klient::sendeStatistikSpielerOffline(int account)
+{
+	if (!klient)
+		return;
+	char* bytes = new char[5];
+	*(char*)(bytes) = 4;
+	*(int*)(bytes + 1) = account;
+	klient->statistikNachricht(5, bytes);
+	delete[] bytes;
+}
+
+void Klient::sendeSpielerStatistik(Spieler* zS)
+{
+	if (!zS || !klient)
+		return;
+	char snl = (char)textLength(zS->getName());
+	char tnl = (char)zS->zTeam()->getName().getLength();
+	int len = 55 + snl + tnl;
+	char* bytes = new char[len];
+	bytes[0] = 0;
+	*(int*)(bytes + 1) = zS->getId();
+	*(char*)(bytes + 5) = snl;
+	for (int i = 0; i < snl; i++)
+		bytes[i + 6] = zS->getName()[i];
+	*(char*)(bytes + 6 + snl) = tnl;
+	for (int i = 0; i < tnl; i++)
+		bytes[i + 7 + snl] = zS->zTeam()->getName()[i];
+	*(int*)(bytes + 7 + snl + tnl) = zS->getFarbe();
+	*(int*)(bytes + 11 + snl + tnl) = zS->zTeam()->getFarbe();
+	*(int*)(bytes + 15 + snl + tnl) = (int)zS->getErlittenerSchaden();
+	*(int*)(bytes + 19 + snl + tnl) = (int)zS->getGemachterSchaden();
+	*(int*)(bytes + 23 + snl + tnl) = (int)zS->getGeheiltesLeben();
+	*(int*)(bytes + 27 + snl + tnl) = zS->getGeschossen();
+	*(int*)(bytes + 31 + snl + tnl) = zS->getTreffer();
+	*(int*)(bytes + 35 + snl + tnl) = zS->getPunkte();
+	*(int*)(bytes + 39 + snl + tnl) = zS->getKills();
+	*(int*)(bytes + 43 + snl + tnl) = zS->getTode();
+	*(int*)(bytes + 47 + snl + tnl) = zS->getItemsAufgehoben();
+	*(int*)(bytes + 51 + snl + tnl) = zS->getItemsVerwendet();
+	klient->statistikNachricht((short)len, bytes);
+	delete[] bytes;
+}
+
+void Klient::sendeTeamStatistik(Team* zS)
+{
+	if (!zS || !klient)
+		return;
+	char tnl = (char)zS->getName().getLength();
+	int len = 22 + tnl;
+	char* bytes = new char[len];
+	bytes[0] = 1;
+	*(int*)(bytes + 1) = zS->getTeamNummer();
+	*(char*)(bytes + 5) = tnl;
+	for (int i = 0; i < tnl; i++)
+		bytes[i + 6] = zS->getName()[i];
+	*(int*)(bytes + 6 + tnl) = zS->getFarbe();
+	*(int*)(bytes + 10 + tnl) = zS->getPunkte();
+	*(int*)(bytes + 14 + tnl) = zS->getKills();
+	*(int*)(bytes + 18 + tnl) = zS->getTode();
+	klient->statistikNachricht((short)len, bytes);
+	delete[] bytes;
 }
 
 void Klient::sendeStatistikLadenFertig()
 {
-    if( !klient )
-        return;
-    char byte = 2;
-    klient->statistikNachricht( 1, &byte );
+	if (!klient)
+		return;
+	char byte = 2;
+	klient->statistikNachricht(1, &byte);
 }
 
 // constant
 bool Klient::istOnline() const
 {
-    return klient != 0;
+	return klient != 0;
 }

StickmanWorldOnline/Reader.cpp

@@ -3,1055 +3,1055 @@
 
 
 // Konstruktor
-MapReader::MapReader( int karteId, SSDatenbankV* db, char* tmpPfad )
-    : ReferenceCounter()
+MapReader::MapReader(int karteId, SSDatenbankV* db, const char* tmpPfad)
+	: ReferenceCounter()
 {
-    this->karteId = karteId;
-    this->db = db;
-    pfad = new Text( tmpPfad );
+	this->karteId = karteId;
+	this->db = db;
+	pfad = new Text(tmpPfad);
 }
 
 MapReader::MapReader()
-    : ReferenceCounter()
+	: ReferenceCounter()
 {
-    db = 0;
-    pfad = 0;
+	db = 0;
+	pfad = 0;
 }
 
 // Destruktor
 MapReader::~MapReader()
 {
-    if( db )
-        db->release();
-    if( pfad )
-        pfad->release();
+	if (db)
+		db->release();
+	if (pfad)
+		pfad->release();
 }
 
-Aktion* MapReader::readAktion( Datei& dat )
+Aktion* MapReader::readAktion(Datei& 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[ 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[ 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[ 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[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[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[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, Datei& dat )
+void MapReader::writeAktion(Aktion* zAk, Datei& 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( "sts.ltgd" );
-    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[ 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( 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( 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( id, x, y, breite, height, showTimer, Punkt( timerX, timerY ), timerFarbe, 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[ (int)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( 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( 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[ (int)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        zSpiel->addTimer( new Timer( 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( 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( 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[ (int)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[ (int)len + 1 ];
-        mapFile.lese( name, len );
-        name[ (int)len ] = 0;
-        char typ;
-        mapFile.lese( &typ, 1 );
-        char def;
-        mapFile.lese( &def, 1 );
-        Variable* var;
-        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[ (int)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[ (int)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("sts.ltgd");
+	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[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(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(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(id, x, y, breite, height, showTimer, Punkt(timerX, timerY), timerFarbe, 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[(int)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(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(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[(int)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		zSpiel->addTimer(new Timer(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(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(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[(int)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[(int)len + 1];
+		mapFile.lese(name, len);
+		name[(int)len] = 0;
+		char typ;
+		mapFile.lese(&typ, 1);
+		char def;
+		mapFile.lese(&def, 1);
+		Variable* var;
+		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[(int)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[(int)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

@@ -10,30 +10,30 @@ class Aktion;
 
 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;
 };
 
 class MapReader : public virtual ReferenceCounter
 {
 private:
-    SSDatenbankV *db;
-    Text *pfad;
-    int karteId;
+	SSDatenbankV* db;
+	Text* pfad;
+	int karteId;
 
 public:
-    // Konstruktor
-    MapReader( int karteId, SSDatenbankV *db, char *tmpPfad );
-    MapReader();
-    // Destruktor
-    ~MapReader();
-    // nicht constant
-    void ladeKarte( Spiel *zSpiel );
-    Aktion *readAktion( Datei &dat );
-    void writeAktion( Aktion *zAk, Datei &dat );
-    //void writeAktion( Aktion *ak, Datei &dat );
+	// Konstruktor
+	MapReader(int karteId, SSDatenbankV* db, const char* tmpPfad);
+	MapReader();
+	// Destruktor
+	~MapReader();
+	// nicht constant
+	void ladeKarte(Spiel* zSpiel);
+	Aktion* readAktion(Datei& dat);
+	void writeAktion(Aktion* zAk, Datei& dat);
+	//void writeAktion( Aktion *ak, Datei &dat );
 };

StickmanWorldOnline/SSKlient.h

@@ -11,28 +11,28 @@ class Team;
 class Klient : public virtual Framework::ReferenceCounter
 {
 private:
-    SSKlientV *klient;
+	SSKlientV* klient;
 
 public:
-    // Konstruktor
-    Klient( SSKlientV *klient );
-    // Destruktor
-    ~Klient();
-    // nicht constant
-    void offline();
-    void online( SSKlientV *zKlient );
-    void sendeInit( RCArray< Spieler > *zSpieler, __int64 seed );
-    void sendeSpielerNummer( int sNum );
-    void sendeStart();
-    void sendeTastaturStatus( int spielerId, char taste, bool aktiv );
-    void sendeSpielEnde( char gewonnen );
-    void sendeTick();
-    void sendeChatNachricht( char *txt );
-    void sendeStatistikChatNachricht( int vonAccount, char *txt );
-    void sendeStatistikSpielerOffline( int account );
-    void sendeSpielerStatistik( Spieler *zS );
-    void sendeTeamStatistik( Team *zS );
-    void sendeStatistikLadenFertig();
-    // constant
-    bool istOnline() const;
+	// Konstruktor
+	Klient(SSKlientV* klient);
+	// Destruktor
+	~Klient();
+	// nicht constant
+	void offline();
+	void online(SSKlientV* zKlient);
+	void sendeInit(RCArray< Spieler >* zSpieler, __int64 seed);
+	void sendeSpielerNummer(int sNum);
+	void sendeStart();
+	void sendeTastaturStatus(int spielerId, char taste, bool aktiv);
+	void sendeSpielEnde(char gewonnen);
+	void sendeTick();
+	void sendeChatNachricht(const char* txt);
+	void sendeStatistikChatNachricht(int vonAccount, const char* txt);
+	void sendeStatistikSpielerOffline(int account);
+	void sendeSpielerStatistik(Spieler* zS);
+	void sendeTeamStatistik(Team* zS);
+	void sendeStatistikLadenFertig();
+	// constant
+	bool istOnline() const;
 };