Einiege Aktionen implementiert

StickmanWorldOnline/Aktionen.cpp

@@ -160,9 +160,6 @@ Warten::Warten( RCArray< Aktion > *subActions )
     this->erlaubteTypen.add( FLOAT );
 }
 
-Warten::~Warten()
-{}
-
 void Warten::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     waitCount += ( (Float *)zParam( 0 ) )->getValue();
@@ -173,9 +170,6 @@ WennDannSonst::WennDannSonst( RCArray< Aktion > *subActions )
     : Aktion( WENN_DANN_SONST, subActions )
 {}
 
-WennDannSonst::~WennDannSonst()
-{}
-
 bool WennDannSonst::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
@@ -234,9 +228,6 @@ SetVariable::SetVariable( Text name, RCArray< Aktion > *subActions )
     this->name = name;
 }
 
-SetVariable::~SetVariable()
-{}
-
 void SetVariable::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     if( zMemory->zVariable( name ) || zEreignis->zParameter( name ) || !zSpiel->zVariable( name ) )
@@ -250,9 +241,6 @@ TriggerAktion::TriggerAktion( RCArray< Aktion > *subActions )
     : Aktion( TRIGGER_AKTION, subActions )
 {}
 
-TriggerAktion::~TriggerAktion()
-{}
-
 bool TriggerAktion::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
@@ -310,9 +298,6 @@ SpielerNachricht::SpielerNachricht( RCArray< Aktion > *subActions )
     erlaubteTypen.add( STRING );
 }
 
-SpielerNachricht::~SpielerNachricht()
-{}
-
 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)
@@ -329,9 +314,6 @@ DisplayText::DisplayText( RCArray< Aktion > *subActions )
     erlaubteTypen.add( STRING );
 }
 
-DisplayText::~DisplayText()
-{}
-
 void DisplayText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     // do nothing because the server does not need to show text
@@ -344,9 +326,6 @@ SpielPause::SpielPause( RCArray< Aktion > *subActions )
     erlaubteTypen.add( BOOLEAN );
 }
 
-SpielPause::~SpielPause()
-{}
-
 void SpielPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zSpiel->setPausiert( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -357,9 +336,6 @@ SpielEnde::SpielEnde( RCArray< Aktion > *subActions )
     : Aktion( SPIEL_ENDE, subActions )
 {}
 
-SpielEnde::~SpielEnde()
-{}
-
 void SpielEnde::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     Variable *t = zParam( 0 );
@@ -376,9 +352,6 @@ SpielerSetLevel::SpielerSetLevel( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetLevel::~SpielerSetLevel()
-{}
-
 void SpielerSetLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setLevel( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -393,9 +366,6 @@ SpielerGiveItem::SpielerGiveItem( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerGiveItem::~SpielerGiveItem()
-{}
-
 void SpielerGiveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 2 ) )->addItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
@@ -411,9 +381,6 @@ SpielerRemoveItem::SpielerRemoveItem( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerRemoveItem::~SpielerRemoveItem()
-{}
-
 void SpielerRemoveItem::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 2 ) )->removeItem( ( (GegenstandTypVar *)zParam( 0 ) )->getValue(),
@@ -428,9 +395,6 @@ SpielerSetLeben::SpielerSetLeben( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetLeben::~SpielerSetLeben()
-{}
-
 void SpielerSetLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setLeben( ( (Float *)zParam( 0 ) )->getValue() );
@@ -444,9 +408,6 @@ SpielerSetMaxLeben::SpielerSetMaxLeben( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetMaxLeben::~SpielerSetMaxLeben()
-{}
-
 void SpielerSetMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setMaxLeben( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -460,9 +421,6 @@ SpielerSetErfahrung::SpielerSetErfahrung( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetErfahrung::~SpielerSetErfahrung()
-{}
-
 void SpielerSetErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setErfahrung( ( (Float *)zParam( 0 ) )->getValue() );
@@ -476,9 +434,6 @@ SpielerSetMaxErfahrung::SpielerSetMaxErfahrung( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetMaxErfahrung::~SpielerSetMaxErfahrung()
-{}
-
 void SpielerSetMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setMaxErfahrung( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -492,9 +447,6 @@ SpielerSetTempo::SpielerSetTempo( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetTempo::~SpielerSetTempo()
-{}
-
 void SpielerSetTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setLaufTempo( ( (Float *)zParam( 0 ) )->getValue() );
@@ -508,9 +460,6 @@ SpielerSetWaffenTempo::SpielerSetWaffenTempo( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetWaffenTempo::~SpielerSetWaffenTempo()
-{}
-
 void SpielerSetWaffenTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setGeschossTempo( ( (Float *)zParam( 0 ) )->getValue() );
@@ -524,9 +473,6 @@ SpielerSetArmor::SpielerSetArmor( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetArmor::~SpielerSetArmor()
-{}
-
 void SpielerSetArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setArmor( ( (Float *)zParam( 0 ) )->getValue() );
@@ -540,9 +486,6 @@ SpielerSetSchadenBonus::SpielerSetSchadenBonus( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetSchadenBonus::~SpielerSetSchadenBonus()
-{}
-
 void SpielerSetSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setSchadenBonus( ( (Float *)zParam( 0 ) )->getValue() );
@@ -556,9 +499,6 @@ SpielerSetLebensraub::SpielerSetLebensraub( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetLebensraub::~SpielerSetLebensraub()
-{}
-
 void SpielerSetLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setLebensRaub( ( (Float *)zParam( 0 ) )->getValue() );
@@ -572,9 +512,6 @@ SpielerSetLebensregeneration::SpielerSetLebensregeneration( RCArray< Aktion > *s
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetLebensregeneration::~SpielerSetLebensregeneration()
-{}
-
 void SpielerSetLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setLebensRegeneration( ( (Float *)zParam( 0 ) )->getValue() );
@@ -588,9 +525,6 @@ SpielerSetAbklingzeitverringerung::SpielerSetAbklingzeitverringerung( RCArray< A
     erlaubteTypen.add( SPIELER );
 }
 
-SpielerSetAbklingzeitverringerung::~SpielerSetAbklingzeitverringerung()
-{}
-
 void SpielerSetAbklingzeitverringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Spieler *)zParam( 1 ) )->setAbklingZeitVerringerung( ( (Float *)zParam( 0 ) )->getValue() );
@@ -604,9 +538,6 @@ DropSetTime::DropSetTime( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-DropSetTime::~DropSetTime()
-{}
-
 void DropSetTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Drop *)zParam( 1 ) )->setTime( ( (Float *)zParam( 0 ) )->getValue() );
@@ -620,9 +551,6 @@ DropSetMaxTime::DropSetMaxTime( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-DropSetMaxTime::~DropSetMaxTime()
-{}
-
 void DropSetMaxTime::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Drop *)zParam( 1 ) )->setMaxTime( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -639,9 +567,6 @@ DropSetArea::DropSetArea( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-DropSetArea::~DropSetArea()
-{}
-
 void DropSetArea::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Drop *)zParam( 4 ) )->setMinX( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -657,9 +582,6 @@ DropDoDrop::DropDoDrop( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-DropDoDrop::~DropDoDrop()
-{}
-
 void DropDoDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Drop *)zParam( 0 ) )->doDrop( zSpiel );
@@ -672,9 +594,6 @@ BariereBewegung::BariereBewegung( RCArray< Aktion > *subActions )
     erlaubteTypen.add( BARIERE );
 }
 
-BariereBewegung::~BariereBewegung()
-{}
-
 void BariereBewegung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Bariere *)zParam( 0 ) )->startAutoVerschiebung( zSpiel );
@@ -688,9 +607,6 @@ BariereSetEingeschaltet::BariereSetEingeschaltet( RCArray< Aktion > *subActions
     erlaubteTypen.add( DROP );
 }
 
-BariereSetEingeschaltet::~BariereSetEingeschaltet()
-{}
-
 void BariereSetEingeschaltet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Bariere *)zParam( 1 ) )->setEingeschaltet( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -705,9 +621,6 @@ GameObjektSetPosition::GameObjektSetPosition( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GAME_OBJEKT );
 }
 
-GameObjektSetPosition::~GameObjektSetPosition()
-{}
-
 void GameObjektSetPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (GameObject *)zParam( 2 ) )->setX( ( (Float *)zParam( 0 ) )->getValue() );
@@ -723,9 +636,6 @@ GameObjektSetSize::GameObjektSetSize( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GAME_OBJEKT );
 }
 
-GameObjektSetSize::~GameObjektSetSize()
-{}
-
 void GameObjektSetSize::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (GameObject *)zParam( 2 ) )->setWidth( ( (Float *)zParam( 0 ) )->getValue() );
@@ -740,9 +650,6 @@ BariereSetTeam::BariereSetTeam( RCArray< Aktion > *subActions )
     erlaubteTypen.add( BARIERE );
 }
 
-BariereSetTeam::~BariereSetTeam()
-{}
-
 void BariereSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Bariere *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ) );
@@ -756,9 +663,6 @@ SchalterSetErlaubt::SchalterSetErlaubt( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SCHALTER );
 }
 
-SchalterSetErlaubt::~SchalterSetErlaubt()
-{}
-
 void SchalterSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Schalter *)zParam( 1 ) )->setAktive( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -771,9 +675,6 @@ SchalterAktivieren::SchalterAktivieren( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SCHALTER );
 }
 
-SchalterAktivieren::~SchalterAktivieren()
-{}
-
 void SchalterAktivieren::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zSpiel->activateShalter( ( (Schalter *)zParam( 0 ) )->getId() );
@@ -788,9 +689,6 @@ TunnelSetZielPosition::TunnelSetZielPosition( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TUNNEL );
 }
 
-TunnelSetZielPosition::~TunnelSetZielPosition()
-{}
-
 void TunnelSetZielPosition::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Tunnel *)zParam( 2 ) )->setZielX( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -805,9 +703,6 @@ TunnelSetErlaubt::TunnelSetErlaubt( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TUNNEL );
 }
 
-TunnelSetErlaubt::~TunnelSetErlaubt()
-{}
-
 void TunnelSetErlaubt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Tunnel *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -821,9 +716,6 @@ UmlenkungSetRichtung::UmlenkungSetRichtung( RCArray< Aktion > *subActions )
     erlaubteTypen.add( UMLENKUNG );
 }
 
-UmlenkungSetRichtung::~UmlenkungSetRichtung()
-{}
-
 void UmlenkungSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Umlenkung *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
@@ -837,9 +729,6 @@ UmlenkungSetMaxAbk::UmlenkungSetMaxAbk( RCArray< Aktion > *subActions )
     erlaubteTypen.add( UMLENKUNG );
 }
 
-UmlenkungSetMaxAbk::~UmlenkungSetMaxAbk()
-{}
-
 void UmlenkungSetMaxAbk::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Umlenkung *)zParam( 1 ) )->setMaxAbklingzeit( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -853,9 +742,6 @@ UmlenkungSetEnabled::UmlenkungSetEnabled( RCArray< Aktion > *subActions )
     erlaubteTypen.add( UMLENKUNG );
 }
 
-UmlenkungSetEnabled::~UmlenkungSetEnabled()
-{}
-
 void UmlenkungSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Umlenkung *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -869,9 +755,6 @@ BaseSetTeam::BaseSetTeam( RCArray< Aktion > *subActions )
     erlaubteTypen.add( BASE );
 }
 
-BaseSetTeam::~BaseSetTeam()
-{}
-
 void BaseSetTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Base *)zParam( 1 ) )->setTeam( ( (Team *)zParam( 0 ) ) );
@@ -883,9 +766,6 @@ TriggerRunStart::TriggerRunStart( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TRIGGER );
 }
 
-TriggerRunStart::~TriggerRunStart()
-{}
-
 void TriggerRunStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zSpiel->addTriggerRun( ( (Trigger *)zParam( 0 ) )->runTrigger( zEreignis->getThis(), zSpiel ) );
@@ -899,9 +779,6 @@ TriggerSetEnabled::TriggerSetEnabled( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TRIGGER );
 }
 
-TriggerSetEnabled::~TriggerSetEnabled()
-{}
-
 void TriggerSetEnabled::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Trigger *)zParam( 1 ) )->setAktiv( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -915,9 +792,6 @@ TeamSetPunkte::TeamSetPunkte( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TEAM );
 }
 
-TeamSetPunkte::~TeamSetPunkte()
-{}
-
 void TeamSetPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Team *)zParam( 1 ) )->setPunkte( ( (Integer *)zParam( 0 ) )->getValue() );
@@ -931,9 +805,6 @@ TimerSetPause::TimerSetPause( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TIMER );
 }
 
-TimerSetPause::~TimerSetPause()
-{}
-
 void TimerSetPause::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Timer *)zParam( 1 ) )->setPause( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -946,9 +817,6 @@ TimerStart::TimerStart( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TIMER );
 }
 
-TimerStart::~TimerStart()
-{}
-
 void TimerStart::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Timer *)zParam( 0 ) )->start( zSpiel );
@@ -962,9 +830,6 @@ TimerSetZeit::TimerSetZeit( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TIMER );
 }
 
-TimerSetZeit::~TimerSetZeit()
-{}
-
 void TimerSetZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Timer *)zParam( 1 ) )->setZeit( ( (Float *)zParam( 0 ) )->getValue() );
@@ -978,9 +843,6 @@ TimerSetSichtbar::TimerSetSichtbar( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TIMER );
 }
 
-TimerSetSichtbar::~TimerSetSichtbar()
-{}
-
 void TimerSetSichtbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Timer *)zParam( 1 ) )->setSichtbar( ( (Boolean *)zParam( 0 ) )->getValue() );
@@ -996,9 +858,6 @@ GeschossNeu::GeschossNeu( RCArray< Aktion > *subActions )
     erlaubteTypen.add( RICHTUNG );
 }
 
-GeschossNeu::~GeschossNeu()
-{}
-
 void GeschossNeu::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     Geschoss *g = new Geschoss( zSpiel->getNextId(), 0,
@@ -1018,9 +877,6 @@ GeschossSetSpeed::GeschossSetSpeed( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GESCHOSS );
 }
 
-GeschossSetSpeed::~GeschossSetSpeed()
-{}
-
 void GeschossSetSpeed::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Geschoss *)zParam( 1 ) )->setSpeed( ( (Float *)zParam( 0 ) )->getValue() );
@@ -1034,9 +890,6 @@ GeschossSetPlayer::GeschossSetPlayer( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GESCHOSS );
 }
 
-GeschossSetPlayer::~GeschossSetPlayer()
-{}
-
 void GeschossSetPlayer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Geschoss *)zParam( 1 ) )->setBesitzer( ( (Spieler *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
@@ -1050,9 +903,6 @@ GeschossSetRichtung::GeschossSetRichtung( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GESCHOSS );
 }
 
-GeschossSetRichtung::~GeschossSetRichtung()
-{}
-
 void GeschossSetRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Geschoss *)zParam( 1 ) )->setRichtung( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) );
@@ -1066,9 +916,6 @@ GeschossSetType::GeschossSetType( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GESCHOSS );
 }
 
-GeschossSetType::~GeschossSetType()
-{}
-
 void GeschossSetType::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     ( (Geschoss *)zParam( 1 ) )->setTyp( getGeschossTypFromString( ( (String *)zParam( 0 ) )->getValue() ) );
@@ -1182,9 +1029,6 @@ IntegerRechnen::IntegerRechnen( RCArray< Aktion > *subActions, Operator op )
     erlaubteTypen.add( INTEGER );
 }
 
-IntegerRechnen::~IntegerRechnen()
-{}
-
 void IntegerRechnen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     Integer *l = (Integer *)zParam( 0 );
@@ -1271,9 +1115,6 @@ IntegerZufall::IntegerZufall( RCArray< Aktion > *subActions )
     erlaubteTypen.add( INTEGER );
 }
 
-IntegerZufall::~IntegerZufall()
-{}
-
 void IntegerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     int mi = ( (Integer *)zParam( 0 ) )->getValue();
@@ -1288,9 +1129,6 @@ IntegerAusText::IntegerAusText( RCArray< Aktion > *subActions )
     erlaubteTypen.add( STRING );
 }
 
-IntegerAusText::~IntegerAusText()
-{}
-
 void IntegerAusText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (String *)zParam( 0 ) )->getValue() ) );
@@ -1303,9 +1141,6 @@ FloatXVonGameObjekt::FloatXVonGameObjekt( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GAME_OBJEKT );
 }
 
-FloatXVonGameObjekt::~FloatXVonGameObjekt()
-{}
-
 void FloatXVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getX() ) );
@@ -1318,9 +1153,6 @@ FloatYVonGameObjekt::FloatYVonGameObjekt( RCArray< Aktion > *subActions )
     erlaubteTypen.add( GAME_OBJEKT );
 }
 
-FloatYVonGameObjekt::~FloatYVonGameObjekt()
-{}
-
 void FloatYVonGameObjekt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getY() ) );
@@ -1333,9 +1165,6 @@ IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TUNNEL );
 }
 
-IntegerXVonTunnelZiel::~IntegerXVonTunnelZiel()
-{}
-
 void IntegerXVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielX() ) );
@@ -1348,9 +1177,6 @@ IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( RCArray< Aktion > *subActions )
     erlaubteTypen.add( TUNNEL );
 }
 
-IntegerYVonTunnelZiel::~IntegerYVonTunnelZiel()
-{}
-
 void IntegerYVonTunnelZiel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getZielY() ) );
@@ -1363,9 +1189,6 @@ IntegerMinXVonDrop::IntegerMinXVonDrop( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-IntegerMinXVonDrop::~IntegerMinXVonDrop()
-{}
-
 void IntegerMinXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinX() ) );
@@ -1378,9 +1201,6 @@ IntegerMinYVonDrop::IntegerMinYVonDrop( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-IntegerMinYVonDrop::~IntegerMinYVonDrop()
-{}
-
 void IntegerMinYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMinY() ) );
@@ -1393,9 +1213,6 @@ IntegerMaxXVonDrop::IntegerMaxXVonDrop( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-IntegerMaxXVonDrop::~IntegerMaxXVonDrop()
-{}
-
 void IntegerMaxXVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxX() ) );
@@ -1408,9 +1225,6 @@ IntegerMaxYVonDrop::IntegerMaxYVonDrop( RCArray< Aktion > *subActions )
     erlaubteTypen.add( DROP );
 }
 
-IntegerMaxYVonDrop::~IntegerMaxYVonDrop()
-{}
-
 void IntegerMaxYVonDrop::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxY() ) );
@@ -1423,9 +1237,6 @@ IntegerSpielerLevel::IntegerSpielerLevel( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-IntegerSpielerLevel::~IntegerSpielerLevel()
-{}
-
 void IntegerSpielerLevel::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getLevel() ) );
@@ -1438,9 +1249,6 @@ FloatSpielerLeben::FloatSpielerLeben( RCArray< Aktion > *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-FloatSpielerLeben::~FloatSpielerLeben()
-{}
-
 void FloatSpielerLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLeben() ) );
@@ -1459,10 +1267,1149 @@ IntegerSpielerMaxLeben::IntegerSpielerMaxLeben( RCArray<Aktion> *subActions )
     erlaubteTypen.add( SPIELER );
 }
 
-IntegerSpielerMaxLeben::~IntegerSpielerMaxLeben()
-{}
-
 void IntegerSpielerMaxLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxLeben() ) );
+}
+
+
+FloatSpielerErfahrung::FloatSpielerErfahrung( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_ERFAHRUNG, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErfahrung() ) );
+}
+
+
+IntegerSpielerMaxErfahrung::IntegerSpielerMaxErfahrung( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_MAX_ERFAHRUNG, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerMaxErfahrung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getMaxErfahrung() ) );
+}
+
+
+FloatSpielerTempo::FloatSpielerTempo( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_TEMPO, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLaufTempo() ) );
+}
+
+
+FloatSpielerGeschossTempo::FloatSpielerGeschossTempo( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_GESCHOSS_TEMPO, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerGeschossTempo::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeschossTempo() ) );
+}
+
+
+FloatSpielerArmor::FloatSpielerArmor( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_ARMOR, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerArmor::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getArmor() ) );
+}
+
+
+FloatSpielerSchadenBonus::FloatSpielerSchadenBonus( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_SCHADEN_BONUS, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerSchadenBonus::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getSchadenBonus() ) );
+}
+
+
+FloatSpielerLebensraub::FloatSpielerLebensraub( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_LEBENSRAUB, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerLebensraub::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRaub() ) );
+}
+
+
+FloatSpielerLebensregeneration::FloatSpielerLebensregeneration( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_LEBENSREGENERATION, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerLebensregeneration::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getLebensRegenneration() ) );
+}
+
+
+FloatSpielerAbklingzeitVerringerung::FloatSpielerAbklingzeitVerringerung( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerAbklingzeitVerringerung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getAbklingZeitVerringerung() ) );
+}
+
+
+IntegerSpielerTode::IntegerSpielerTode( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_TODE, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTode() ) );
+}
+
+
+IntegerSpielerKills::IntegerSpielerKills( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_KILLS, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getKills() ) );
+}
+
+
+IntegerSpielerTreffer::IntegerSpielerTreffer( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerTreffer::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTreffer() ) );
+}
+
+
+IntegerSpielerGetroffen::IntegerSpielerGetroffen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_TREFFER, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGetroffen() ) );
+}
+
+
+FloatSpielerErlittenerSchaden::FloatSpielerErlittenerSchaden( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerErlittenerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getErlittenerSchaden() ) );
+}
+
+
+FloatSpielerSchaden::FloatSpielerSchaden( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_ERLITTENER_SCHADEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void FloatSpielerSchaden::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGemachterSchaden() ) );
+}
+
 
+FloatSpielerGeheiltesLeben::FloatSpielerGeheiltesLeben( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_SPIELER_GEHEILTES_LEBEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
 }
+
+void FloatSpielerGeheiltesLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Spieler *)zParam( 0 ) )->getGeheiltesLeben() ) );
+}
+
+
+IntegerSpielerItemsAufgehoben::IntegerSpielerItemsAufgehoben( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_ITEMS_AUFGEHOBEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerItemsAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsAufgehoben() ) );
+}
+
+
+IntegerSpielerItemsVerwendet::IntegerSpielerItemsVerwendet( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_ITEMS_VERWENDET, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerItemsVerwendet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsVerwendet() ) );
+}
+
+
+IntegerSpielerItemsInInventar::IntegerSpielerItemsInInventar( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerItemsInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getItemsInInventory() ) );
+}
+
+
+IntegerSpielerItemsTypeInInventar::IntegerSpielerItemsTypeInInventar( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP, subActions )
+{
+    erlaubteTypen.add( GEGENSTAND_TYP );
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerItemsTypeInInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
+}
+
+
+IntegerSpielerTunnelBenutzt::IntegerSpielerTunnelBenutzt( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_TUNNEL_BENUTZT, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getTunnelBenutzt() ) );
+}
+
+
+IntegerSpielerSchalterAktiviert::IntegerSpielerSchalterAktiviert( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_SCHALTER_AKTIVIERT, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getSchalterAktiviert() ) );
+}
+
+
+IntegerSpielerGeschossen::IntegerSpielerGeschossen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SPIELER_GESCHOSSEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void IntegerSpielerGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Spieler *)zParam( 0 ) )->getGeschossen() ) );
+}
+
+
+FloatDropZeit::FloatDropZeit( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_DROP_ZEIT, subActions )
+{
+    erlaubteTypen.add( DROP );
+}
+
+void FloatDropZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Drop *)zParam( 0 ) )->getZeit() ) );
+}
+
+
+IntegerDropMaxZeit::IntegerDropMaxZeit( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_DROP_MAX_ZEIT, subActions )
+{
+    erlaubteTypen.add( DROP );
+}
+
+void IntegerDropMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Drop *)zParam( 0 ) )->getMaxTime() ) );
+}
+
+
+FloatGameObjektBreite::FloatGameObjektBreite( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_GAME_OBJEKT_BREITE, subActions )
+{
+    erlaubteTypen.add( GAME_OBJEKT );
+}
+
+void FloatGameObjektBreite::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getWidth() ) );
+}
+
+
+FloatGameObjektHeight::FloatGameObjektHeight( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_GAME_OBJEKT_HEIGHT, subActions )
+{
+    erlaubteTypen.add( GAME_OBJEKT );
+}
+
+void FloatGameObjektHeight::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (GameObject *)zParam( 0 ) )->getHeight() ) );
+}
+
+
+IntegerBariereVerschiebungen::IntegerBariereVerschiebungen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_BARIERE_VERSCHIEBUNGEN, subActions )
+{
+    erlaubteTypen.add( BARIERE );
+}
+
+void IntegerBariereVerschiebungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getVerschiebungAnzahl() ) );
+}
+
+
+IntegerBariereSchaltungen::IntegerBariereSchaltungen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_BARIERE_SCHALTUNGEN, subActions )
+{
+    erlaubteTypen.add( BARIERE );
+}
+
+void IntegerBariereSchaltungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Bariere *)zParam( 0 ) )->getSchaltungAnzahl() ) );
+}
+
+
+IntegerSchalterAktivierungen::IntegerSchalterAktivierungen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_SCHALTER_AKTIVIERUNGEN, subActions )
+{
+    erlaubteTypen.add( SCHALTER );
+}
+
+void IntegerSchalterAktivierungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Schalter *)zParam( 0 ) )->getAnzahlAktivierungen() ) );
+}
+
+
+IntegerTunnelBenutzungen::IntegerTunnelBenutzungen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TUNNEL_BENUTZUNGEN, subActions )
+{
+    erlaubteTypen.add( TUNNEL );
+}
+
+void IntegerTunnelBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Tunnel *)zParam( 0 ) )->getBenutzungen() ) );
+}
+
+
+IntegerUmlenkungBenutzungen::IntegerUmlenkungBenutzungen( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_UMLENKUNG_BENUTZUNGEN, subActions )
+{
+    erlaubteTypen.add( UMLENKUNG );
+}
+
+void IntegerUmlenkungBenutzungen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Umlenkung *)zParam( 0 ) )->getBenutzungen() ) );
+}
+
+
+IntegerTeamPunkte::IntegerTeamPunkte( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TEAM_PUNKTE, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void IntegerTeamPunkte::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getPunkte() ) );
+}
+
+
+IntegerTeamKills::IntegerTeamKills( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TEAM_KILLS, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void IntegerTeamKills::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getKills() ) );
+}
+
+
+IntegerTeamTode::IntegerTeamTode( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TEAM_TODE, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void IntegerTeamTode::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getTode() ) );
+}
+
+
+FloatTeamWiederbelegungszeit::FloatTeamWiederbelegungszeit( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_TEAM_WIEDERBELEBUNGSZEIT, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void FloatTeamWiederbelegungszeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Team *)zParam( 0 ) )->getMaxWiederbelebungsZeit() ) );
+}
+
+
+IntegerTeamSpieleranzahl::IntegerTeamSpieleranzahl( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TEAM_SPIELERANZAHL, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void IntegerTeamSpieleranzahl::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Team *)zParam( 0 ) )->getSpielerAnzahl() ) );
+}
+
+
+FloatTimerAktuelleZeit::FloatTimerAktuelleZeit( RCArray<Aktion> *subActions )
+    : Aktion( FLOAT_TIMER_AKTUELLE_ZEIT, subActions )
+{
+    erlaubteTypen.add( TIMER );
+}
+
+void FloatTimerAktuelleZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Float( ( (Timer *)zParam( 0 ) )->getTimeLeft() ) );
+}
+
+
+IntegerTimerMaxZeit::IntegerTimerMaxZeit( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TIMER_MAX_ZEIT, subActions )
+{
+    erlaubteTypen.add( TIMER );
+}
+
+void IntegerTimerMaxZeit::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Timer *)zParam( 0 ) )->getMaxTime() ) );
+}
+
+
+IntegerTriggerRunns::IntegerTriggerRunns( RCArray<Aktion> *subActions )
+    : Aktion( INTEGER_TRIGGER_RUNNS, subActions )
+{
+    erlaubteTypen.add( TRIGGER );
+}
+
+void IntegerTriggerRunns::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Integer( ( (Trigger *)zParam( 0 ) )->getRuns() ) );
+}
+
+
+ItemSpielerInventar::ItemSpielerInventar( RCArray<Aktion> *subActions )
+    : Aktion( ITEM_SPIELER_INVENTAR, subActions )
+{
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( SPIELER );
+}
+
+void ItemSpielerInventar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new GegenstandTypVar( ( ( (Spieler *)zParam( 1 ) )->getInventorySlot( ( (Integer *)zParam( 0 ) )->getValue() ) ) ) );
+}
+
+
+ItemZuletztAufgehoben::ItemZuletztAufgehoben()
+    : Aktion( ITEM_ZULETZT_AUFGEHOBEN, new RCArray< Aktion >() )
+{}
+
+void ItemZuletztAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAufgehoben() ) );
+}
+
+
+ItemZuletztAktiviert::ItemZuletztAktiviert()
+    : Aktion( ITEM_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
+{}
+
+void ItemZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztAktiviert() ) );
+}
+
+
+ItemZuletztGedropt::ItemZuletztGedropt()
+    : Aktion( ITEM_ZULETZT_GEDROPT, new RCArray< Aktion >() )
+{}
+
+void ItemZuletztGedropt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new GegenstandTypVar( zSpiel->getItemZuletztGedropt() ) );
+}
+
+
+ItemZufall::ItemZufall()
+    : Aktion( ITEM_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void ItemZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new GegenstandTypVar( (GegenstandTyp)(int)( zSpiel->getRand() * ITEMANZAHL ) ) );
+}
+
+
+GeschossZufall::GeschossZufall()
+    : Aktion( GESCHOSS_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void GeschossZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomGeschoss() );
+}
+
+
+GeschossZuletztAbgefeuert::GeschossZuletztAbgefeuert()
+    : Aktion( GESCHOSS_ZULETZT_ABGEFEUERT, new RCArray< Aktion >() )
+{}
+
+void GeschossZuletztAbgefeuert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getGeschossZuletztAbgefeuert() );
+}
+
+
+GeschossZuletztUmgelenkt::GeschossZuletztUmgelenkt()
+    : Aktion( GESCHOSS_ZULETZT_UMGELENKT, new RCArray< Aktion >() )
+{}
+
+void GeschossZuletztUmgelenkt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getGeschossZuletztUmgelenkt() );
+}
+
+
+GeschossZuletztBarjereGetroffen::GeschossZuletztBarjereGetroffen()
+    : Aktion( GESCHOSS_ZULETZT_BARIERE_GETROFFEN, new RCArray< Aktion >() )
+{}
+
+void GeschossZuletztBarjereGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getGeschossZuletztBariereGetroffen() );
+}
+
+
+GeschossZuletztTunnelBenutzt::GeschossZuletztTunnelBenutzt()
+    : Aktion( GESCHOSS_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
+{}
+
+void GeschossZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getGeschossZuletztTunnelBenutzt() );
+}
+
+
+GeschossZuletztGeschossGetroffen::GeschossZuletztGeschossGetroffen()
+    : Aktion( GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN, new RCArray< Aktion >() )
+{}
+
+void GeschossZuletztGeschossGetroffen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getGeschossZuletztGeschossGetroffen() );
+}
+
+
+RichtungZufall::RichtungZufall()
+    : Aktion( RICHTUNG_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void RichtungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( (Richtung)(int)( zSpiel->getRand() * RICHTUNG_ANZAHL ) ) );
+}
+
+
+RichtungVonUmlenkung::RichtungVonUmlenkung( RCArray< Aktion > *subActions )
+    : Aktion( RICHTUNG_VON_UMLENKUNG, subActions )
+{
+    erlaubteTypen.add( UMLENKUNG );
+}
+
+void RichtungVonUmlenkung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (Umlenkung *)zParam( 0 ) )->getRichtung() ) );
+}
+
+
+RichtungVonGeschoss::RichtungVonGeschoss( RCArray< Aktion > *subActions )
+    : Aktion( RICHTUNG_VON_GESCHOSS, subActions )
+{
+    erlaubteTypen.add( GESCHOSS );
+}
+
+void RichtungVonGeschoss::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (Geschoss *)zParam( 0 ) )->getRichtung() ) );
+}
+
+
+SchalterZufall::SchalterZufall()
+    : Aktion( SCHALTER_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void SchalterZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomSchalter() );
+}
+
+
+SchalterZuletztAktiviert::SchalterZuletztAktiviert()
+    : Aktion( SCHALTER_ZULETZT_AKTIVIERT, new RCArray< Aktion >() )
+{}
+
+void SchalterZuletztAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSchalterZuletztAktiviert() );
+}
+
+
+SpielerZufall::SpielerZufall()
+    : Aktion( SPIELER_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void SpielerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomSpieler() );
+}
+
+
+SpielerZufallAusTeam::SpielerZufallAusTeam( RCArray< Aktion > *subActions )
+    : Aktion( SPIELER_ZUFALL_AUS_TEAM, subActions )
+{
+    erlaubteTypen.add( TEAM );
+}
+
+void SpielerZufallAusTeam::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomSpieler( (Team *)zParam( 0 ) ) );
+}
+
+
+SpielerZuletztSchadenGemacht::SpielerZuletztSchadenGemacht()
+    : Aktion( SPIELER_ZULETZT_SCHADEN_GEMACHT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztSchadenGemacht::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztSchadenGemacht() );
+}
+
+
+SpielerZuletztSchadenGenommen::SpielerZuletztSchadenGenommen()
+    : Aktion( SPIELER_ZULETZT_SCHADEN_GENOMMEN, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztSchadenGenommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztSchadenGenommen() );
+}
+
+
+SpielerZuletztGeheilt::SpielerZuletztGeheilt()
+    : Aktion( SPIELER_ZULETZT_GEHEILT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztGeheilt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztGeheilt() );
+}
+
+
+SpielerZuletztLevelUp::SpielerZuletztLevelUp()
+    : Aktion( SPIELER_ZULETZT_LEVEL_UP, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztLevelUp::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztLevelUp() );
+}
+
+
+SpielerZuletztErfahrungBekommen::SpielerZuletztErfahrungBekommen()
+    : Aktion( SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztErfahrungBekommen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztErfahrungBekommen() );
+}
+
+
+SpielerZuletztGegenstandAktiviert::SpielerZuletztGegenstandAktiviert()
+    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztGegenstandAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztGegenstandAktiviert() );
+}
+
+
+SpielerZuletztGegenstandAufgehoben::SpielerZuletztGegenstandAufgehoben()
+    : Aktion( SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztGegenstandAufgehoben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztGegenstandAufgehoben() );
+}
+
+
+SpielerZuletztSchalterAktiviert::SpielerZuletztSchalterAktiviert()
+    : Aktion( SPIELER_ZULETZT_SCHALTER_AKTIVIERT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztSchalterAktiviert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztSchalterAktiviert() );
+}
+
+
+SpielerZuletztTunnelBenutzt::SpielerZuletztTunnelBenutzt()
+    : Aktion( SPIELER_ZULETZT_TUNNEL_BENUTZT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztTunnelBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztTunnelBenutzt() );
+}
+
+
+SpielerZuletztGestorben::SpielerZuletztGestorben()
+    : Aktion( SPIELER_ZULETZT_GESTORBEN, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztGestorben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztGestorben() );
+}
+
+
+SpielerZuletztWiederbelebent::SpielerZuletztWiederbelebent()
+    : Aktion( SPIELER_ZULETZT_WIEDERBELEBT, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztWiederbelebent::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztWiederbelebt() );
+}
+
+
+SpielerZuletztGeschossGeschossen::SpielerZuletztGeschossGeschossen()
+    : Aktion( SPIELER_ZULETZT_GESCHOSSEN, new RCArray< Aktion >() )
+{}
+
+void SpielerZuletztGeschossGeschossen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getSpielerZuletztGeschossen() );
+}
+
+
+TextConcat::TextConcat( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_CONCAT, subActions )
+{
+    erlaubteTypen.add( STRING );
+    erlaubteTypen.add( STRING );
+}
+
+void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (String *)zParam( 0 ) )->getValue() + ( (String *)zParam( 1 ) )->getValue().getText() ) );
+}
+
+
+TextAusInteger::TextAusInteger( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_AUS_INTEGER, subActions )
+{
+    erlaubteTypen.add( INTEGER );
+}
+
+void TextAusInteger::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( Text( ( (Integer *)zParam( 0 ) )->getValue() ) ) );
+}
+
+
+TextAusRichtung::TextAusRichtung( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_AUS_RICHTUNG, subActions )
+{
+    erlaubteTypen.add( RICHTUNG );
+}
+
+void TextAusRichtung::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (String *)zParam( 0 ) )->getValue() ) );
+}
+
+
+TextAusBoolean::TextAusBoolean( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_AUS_BOOLEAN, subActions )
+{
+    erlaubteTypen.add( BOOLEAN );
+}
+
+void TextAusBoolean::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (Boolean *)zParam( 0 ) )->getValue() ? "true" : "false" ) );
+}
+
+
+TextSpielerName::TextSpielerName( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_SPIELER_NAME, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void TextSpielerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (Spieler *)zParam( 0 ) )->getName() ) );
+}
+
+
+TextItemName::TextItemName( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_ITEM_NAME, subActions )
+{
+    erlaubteTypen.add( GEGENSTAND_TYP );
+}
+
+void TextItemName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    switch( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() )
+    {
+    case PFEIL:
+        setReturn( new String( "PFEIL" ) );
+        break;
+    case LEBEN:
+        setReturn( new String( "LEBEN" ) );
+        break;
+    case SCHILD:
+        setReturn( new String( "SCHILD" ) );
+        break;
+    case SCHUH:
+        setReturn( new String( "SCHUH" ) );
+        break;
+    case GEIST:
+        setReturn( new String( "GEIST" ) );
+        break;
+    case KUGEL:
+        setReturn( new String( "KUGEL" ) );
+        break;
+    case ROLLE:
+        setReturn( new String( "ROLLE" ) );
+        break;
+    case STURM:
+        setReturn( new String( "STURM" ) );
+        break;
+    case DRACHENAUGE:
+        setReturn( new String( "DRACHENAUGE" ) );
+        break;
+    case FEUERBALL:
+        setReturn( new String( "FEUERBALL" ) );
+        break;
+    case ENTERHAKEN:
+        setReturn( new String( "ENTERHAKEN" ) );
+        break;
+    case MINE:
+        setReturn( new String( "MINE" ) );
+        break;
+    case RWEISHEIT:
+        setReturn( new String( "RWEISHEIT" ) );
+        break;
+    case RSTRENGTH:
+        setReturn( new String( "RSTRENGTH" ) );
+        break;
+    case RBOSHEIT:
+        setReturn( new String( "RBOSHEIT" ) );
+        break;
+    case RLEBEN:
+        setReturn( new String( "RLEBEN" ) );
+        break;
+    case RTEMPO:
+        setReturn( new String( "RTEMPO" ) );
+        break;
+    default:
+        setReturn( new String( "NICHTS" ) );
+        break;
+    }
+}
+
+
+TextTriggerName::TextTriggerName( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_TRIGGER_NAME, subActions )
+{
+    erlaubteTypen.add( TRIGGER );
+}
+
+void TextTriggerName::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new String( ( (Trigger *)zParam( 0 ) )->getName() ) );
+}
+
+
+TextTeilVonText::TextTeilVonText( RCArray< Aktion > *subActions )
+    : Aktion( TEXT_TEIL_VON_TEXT, subActions )
+{
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( INTEGER );
+    erlaubteTypen.add( STRING );
+}
+
+void TextTeilVonText::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    Text *txt = ( (String *)zParam( 2 ) )->getValue().getTeilText( ( (Integer *)zParam( 0 ) )->getValue(), ( (Integer *)zParam( 1 ) )->getValue() );
+    setReturn( new String( txt->getText() ) );
+    txt->release();
+}
+
+
+TeamZufall::TeamZufall()
+    : Aktion( TEAM_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void TeamZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomTeam() );
+}
+
+
+TeamVonSpieler::TeamVonSpieler( RCArray< Aktion > *subActions )
+    : Aktion( TEAM_VON_SPIELER, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void TeamVonSpieler::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( ( (Spieler *)zParam( 0 ) )->getTeam() );
+}
+
+
+TeamVonBariere::TeamVonBariere( RCArray< Aktion > *subActions )
+    : Aktion( TEAM_VON_BARIERE, subActions )
+{
+    erlaubteTypen.add( BARIERE );
+}
+
+void TeamVonBariere::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( ( (Bariere *)zParam( 0 ) )->getTeam() );
+}
+
+
+TimerZufall::TimerZufall()
+    : Aktion( TIMER_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void TimerZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomTimer() );
+}
+
+
+TimerZuletztAbgelaufen::TimerZuletztAbgelaufen()
+    : Aktion( TIMER_ZULETZT_ABGELAUFEN, new RCArray< Aktion >() )
+{}
+
+void TimerZuletztAbgelaufen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getTimerZuletztAbgelaufen() );
+}
+
+
+TimerZuletztGestartet::TimerZuletztGestartet()
+    : Aktion( TIMER_ZULETZT_GESTARTET, new RCArray< Aktion >() )
+{}
+
+void TimerZuletztGestartet::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getTimerZuletztGestartet() );
+}
+
+
+TimerZuletztPausiert::TimerZuletztPausiert()
+    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
+{}
+
+void TimerZuletztPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getTimerZuletztPausiert() );
+}
+
+
+TimerZuletztFortgesetzt::TimerZuletztFortgesetzt()
+    : Aktion( TIMER_ZULETZT_PAUSIERT, new RCArray< Aktion >() )
+{}
+
+void TimerZuletztFortgesetzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getTimerZuletztFortgesetzt() );
+}
+
+
+TunnelZufall::TunnelZufall()
+    : Aktion( TUNNEL_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void TunnelZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomTunnel() );
+}
+
+
+TunnelZuletztBenutzt::TunnelZuletztBenutzt()
+    : Aktion( TUNNEL_ZULETZT_BENUTZT, new RCArray< Aktion >() )
+{}
+
+void TunnelZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getTunnelZuletztBenutzt() );
+}
+
+
+UmlenkungZufall::UmlenkungZufall()
+    : Aktion( UMLENKUNG_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void UmlenkungZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRandomUmlenkung() );
+}
+
+
+UmlenkungZuletztBenutzt::UmlenkungZuletztBenutzt()
+    : Aktion( UMLENKUNG_ZULETZT_BENUTZT, new RCArray< Aktion >() )
+{}
+
+void UmlenkungZuletztBenutzt::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getUmlenkungZuletztBenutzt() );
+}
+
+
+BooleanZufall::BooleanZufall()
+    : Aktion( BOOLEAN_ZUFALL, new RCArray< Aktion >() )
+{}
+
+void BooleanZufall::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( zSpiel->getRand() < 0.5 ? new Boolean( false ) : new Boolean( true ) );
+}
+
+
+BooleanSpielPausiert::BooleanSpielPausiert()
+    : Aktion( BOOLEAN_SPIEL_PAUSIERT, new RCArray< Aktion >() )
+{}
+
+void BooleanSpielPausiert::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Boolean( zSpiel->istPausiert() ) );
+}
+
+
+BooleanSpielerAmLeben::BooleanSpielerAmLeben( RCArray< Aktion > *subActions )
+    : Aktion( BOOLEAN_SPIELER_AM_LEBEN, subActions )
+{
+    erlaubteTypen.add( SPIELER );
+}
+
+void BooleanSpielerAmLeben::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Boolean( ( (Spieler *)zParam( 0 ) )->istAmLeben() ) );
+}
+
+
+BooleanSpielerHatGegenstand::BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions )
+    : Aktion( BOOLEAN_SPIELER_HAT_GEGENSTAND, subActions )
+{
+    erlaubteTypen.add( GEGENSTAND_TYP );
+    erlaubteTypen.add( SPIELER );
+}
+
+void BooleanSpielerHatGegenstand::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->getItemsInInventory( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) != 0 ) );
+}
+
+
+BooleanSpielerIstVerwundbar::BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions )
+    : Aktion( BOOLEAN_SPIELER_IST_VERWUNDBAR, subActions )
+{
+    erlaubteTypen.add( RICHTUNG );
+    erlaubteTypen.add( SPIELER );
+}
+
+void BooleanSpielerIstVerwundbar::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->isVerwundbar( getRichtungFromString( ( (String *)zParam( 0 ) )->getValue() ) ) ) );
+}
+
+
+BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions )
+    : Aktion( BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN, subActions )
+{
+    erlaubteTypen.add( GEGENSTAND_TYP );
+    erlaubteTypen.add( SPIELER );
+}
+
+void BooleanSpielerKannItemBenutzen::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    setReturn( new Boolean( ( (Spieler *)zParam( 1 ) )->istGegenstandErlaubt( ( (GegenstandTypVar *)zParam( 0 ) )->getValue() ) ) );
+}

StickmanWorldOnline/Aktionen.h

@@ -31,7 +31,6 @@ enum AktionTyp
     BOOLEAN_SCHALTER_IST_AKTIV,
     BOOLEAN_SPIELER_AM_LEBEN,
     BOOLEAN_SPIELER_HAT_GEGENSTAND,
-    BOOLEAN_SPIELER_IN_TEAM,
     BOOLEAN_SPIELER_IST_VERWUNDBAR,
     BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN,
     BOOLEAN_SPIEL_PAUSIERT,
@@ -116,7 +115,9 @@ enum AktionTyp
     INTEGER_ZUFALL,
     ITEM_SPIELER_INVENTAR,
     ITEM_ZULETZT_AUFGEHOBEN,
+    ITEM_ZULETZT_AKTIVIERT,
     ITEM_ZULETZT_GEDROPT,
+    ITEM_ZUFALL,
     KONSTANT_BOOLEAN,
     KONSTANT_FLOAT,
     KONSTANT_INTEGER,
@@ -320,7 +321,6 @@ class Warten : public Aktion
 public:
     // zeit
     Warten( RCArray< Aktion > *subActions );
-    ~Warten();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -329,7 +329,6 @@ class WennDannSonst : public Aktion
 public:
     // wenn, dann, sonst
     WennDannSonst( RCArray< Aktion > *subActions );
-    ~WennDannSonst();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -341,7 +340,6 @@ private:
 public:
     // value
     SetVariable( Text name, RCArray< Aktion > *subActions );
-    ~SetVariable();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -350,7 +348,6 @@ class TriggerAktion : public Aktion
 public:
     // number, triggerName
     TriggerAktion( RCArray< Aktion > *subActions );
-    ~TriggerAktion();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -359,7 +356,6 @@ class SpielerNachricht : public Aktion
 public:
     // Spieler, Nachricht
     SpielerNachricht( RCArray< Aktion > *subActions );
-    ~SpielerNachricht();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -368,7 +364,6 @@ class DisplayText : public Aktion
 public:
     // x, y, color, dauer, nachricht
     DisplayText( RCArray< Aktion > *subActions );
-    ~DisplayText();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -377,7 +372,6 @@ class SpielPause : public Aktion
 public:
     // paused
     SpielPause( RCArray< Aktion > *subActions );
-    ~SpielPause();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -386,7 +380,6 @@ class SpielEnde : public Aktion
 public:
     // gewinner team
     SpielEnde( RCArray< Aktion > *subActions );
-    ~SpielEnde();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -395,7 +388,6 @@ class SpielerSetLevel : public Aktion
 public:
     // level, spieler
     SpielerSetLevel( RCArray< Aktion > *subActions );
-    ~SpielerSetLevel();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -404,7 +396,6 @@ class SpielerGiveItem : public Aktion
 public:
     // item, anzahl, spieler
     SpielerGiveItem( RCArray< Aktion > *subActions );
-    ~SpielerGiveItem();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -413,7 +404,6 @@ class SpielerRemoveItem : public Aktion
 public:
     // item, anzahl, spieler
     SpielerRemoveItem( RCArray< Aktion > *subActions );
-    ~SpielerRemoveItem();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -422,7 +412,6 @@ class SpielerSetLeben : public Aktion
 public:
     // leben, spieler
     SpielerSetLeben( RCArray< Aktion > *subActions );
-    ~SpielerSetLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -431,7 +420,6 @@ class SpielerSetMaxLeben : public Aktion
 public:
     // leben, spieler
     SpielerSetMaxLeben( RCArray< Aktion > *subActions );
-    ~SpielerSetMaxLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -440,7 +428,6 @@ class SpielerSetErfahrung : public Aktion
 public:
     // erfahrung, spieler
     SpielerSetErfahrung( RCArray< Aktion > *subActions );
-    ~SpielerSetErfahrung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -449,7 +436,6 @@ class SpielerSetMaxErfahrung : public Aktion
 public:
     // erfahrung, spieler
     SpielerSetMaxErfahrung( RCArray< Aktion > *subActions );
-    ~SpielerSetMaxErfahrung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -458,7 +444,6 @@ class SpielerSetTempo : public Aktion
 public:
     // tempo, spieler
     SpielerSetTempo( RCArray< Aktion > *subActions );
-    ~SpielerSetTempo();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -467,7 +452,6 @@ class SpielerSetWaffenTempo : public Aktion
 public:
     // tempo, spieler
     SpielerSetWaffenTempo( RCArray< Aktion > *subActions );
-    ~SpielerSetWaffenTempo();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -476,7 +460,6 @@ class SpielerSetArmor : public Aktion
 public:
     // armor, spieler
     SpielerSetArmor( RCArray< Aktion > *subActions );
-    ~SpielerSetArmor();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -485,7 +468,6 @@ class SpielerSetSchadenBonus : public Aktion
 public:
     // bonus, spieler
     SpielerSetSchadenBonus( RCArray< Aktion > *subActions );
-    ~SpielerSetSchadenBonus();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -494,7 +476,6 @@ class SpielerSetLebensraub : public Aktion
 public:
     // lebensrauf, spieler
     SpielerSetLebensraub( RCArray< Aktion > *subActions );
-    ~SpielerSetLebensraub();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -503,7 +484,6 @@ class SpielerSetLebensregeneration : public Aktion
 public:
     // regeneration, spieler
     SpielerSetLebensregeneration( RCArray< Aktion > *subActions );
-    ~SpielerSetLebensregeneration();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -512,7 +492,6 @@ class SpielerSetAbklingzeitverringerung : public Aktion
 public:
     // verringerung, spieler
     SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions );
-    ~SpielerSetAbklingzeitverringerung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -521,7 +500,6 @@ class DropSetTime : public Aktion
 public:
     // time, drop
     DropSetTime( RCArray< Aktion > *subActions );
-    ~DropSetTime();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -530,7 +508,6 @@ class DropSetMaxTime : public Aktion
 public:
     // time, drop
     DropSetMaxTime( RCArray< Aktion > *subActions );
-    ~DropSetMaxTime();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -539,7 +516,6 @@ class DropSetArea : public Aktion
 public:
     // minX, maxX, minY, maxY, drop
     DropSetArea( RCArray< Aktion > *subActions );
-    ~DropSetArea();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -548,7 +524,6 @@ class DropDoDrop : public Aktion
 public:
     // drop
     DropDoDrop( RCArray< Aktion > *subActions );
-    ~DropDoDrop();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -557,7 +532,6 @@ class BariereBewegung : public Aktion
 public:
     // bariere
     BariereBewegung( RCArray< Aktion > *subActions );
-    ~BariereBewegung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -566,7 +540,6 @@ class BariereSetEingeschaltet : public Aktion
 public:
     // eingeschaltet, bariere
     BariereSetEingeschaltet( RCArray< Aktion > *subActions );
-    ~BariereSetEingeschaltet();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -575,7 +548,6 @@ class GameObjektSetPosition : public Aktion
 public:
     // x, y, objekt
     GameObjektSetPosition( RCArray< Aktion > *subActions );
-    ~GameObjektSetPosition();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -584,7 +556,6 @@ class GameObjektSetSize : public Aktion
 public:
     // x, y, objekt
     GameObjektSetSize( RCArray< Aktion > *subActions );
-    ~GameObjektSetSize();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -593,7 +564,6 @@ class BariereSetTeam : public Aktion
 public:
     // team, bariere
     BariereSetTeam( RCArray< Aktion > *subActions );
-    ~BariereSetTeam();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -602,7 +572,6 @@ class SchalterSetErlaubt : public Aktion
 public:
     // erlaubt, schalter
     SchalterSetErlaubt( RCArray< Aktion > *subActions );
-    ~SchalterSetErlaubt();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -611,7 +580,6 @@ class SchalterAktivieren : public Aktion
 public:
     // schalter
     SchalterAktivieren( RCArray< Aktion > *subActions );
-    ~SchalterAktivieren();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -620,7 +588,6 @@ class TunnelSetZielPosition : public Aktion
 public:
     // x, y, tunnel
     TunnelSetZielPosition( RCArray< Aktion > *subActions );
-    ~TunnelSetZielPosition();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -629,7 +596,6 @@ class TunnelSetErlaubt : public Aktion
 public:
     // erlaubt, tunnel
     TunnelSetErlaubt( RCArray< Aktion > *subActions );
-    ~TunnelSetErlaubt();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -638,33 +604,22 @@ class UmlenkungSetRichtung : public Aktion
 public:
     // richtung, umlenkung
     UmlenkungSetRichtung( RCArray< Aktion > *subActions );
-    ~UmlenkungSetRichtung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetMaxAbk : public Aktion
 {
-private:
-    Aktion *abk;
-    Aktion *umlenkung;
-
 public:
     // abk, umlenkung
     UmlenkungSetMaxAbk( RCArray< Aktion > *subActions );
-    ~UmlenkungSetMaxAbk();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class UmlenkungSetEnabled : public Aktion
 {
-private:
-    Aktion *enabled;
-    Aktion *umlenkung;
-
 public:
     // enabled, umlenkung
     UmlenkungSetEnabled( RCArray< Aktion > *subActions );
-    ~UmlenkungSetEnabled();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -673,7 +628,6 @@ class BaseSetTeam : public Aktion
 public:
     // team, base
     BaseSetTeam( RCArray< Aktion > *subActions );
-    ~BaseSetTeam();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -682,7 +636,6 @@ class TriggerRunStart : public Aktion
 public:
     // trigger
     TriggerRunStart( RCArray< Aktion > *subActions );
-    ~TriggerRunStart();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -691,7 +644,6 @@ class TriggerSetEnabled : public Aktion
 public:
     // enabled, trigger
     TriggerSetEnabled( RCArray< Aktion > *subActions );
-    ~TriggerSetEnabled();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -700,7 +652,6 @@ class TeamSetPunkte : public Aktion
 public:
     // punkte, team
     TeamSetPunkte( RCArray< Aktion > *subActions );
-    ~TeamSetPunkte();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -709,7 +660,6 @@ class TimerSetPause : public Aktion
 public:
     // pause, timer
     TimerSetPause( RCArray< Aktion > *subActions );
-    ~TimerSetPause();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -718,7 +668,6 @@ class TimerStart : public Aktion
 public:
     // timer
     TimerStart( RCArray< Aktion > *subActions );
-    ~TimerStart();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -727,7 +676,6 @@ class TimerSetZeit : public Aktion
 public:
     // zeit, timer
     TimerSetZeit( RCArray< Aktion > *subActions );
-    ~TimerSetZeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -736,7 +684,6 @@ class TimerSetSichtbar : public Aktion
 public:
     // sichtbar, timer
     TimerSetSichtbar( RCArray< Aktion > *subActions );
-    ~TimerSetSichtbar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -745,7 +692,6 @@ class GeschossNeu : public Aktion
 public:
     // x, y, typ, richtung
     GeschossNeu( RCArray< Aktion > *subActions );
-    ~GeschossNeu();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -754,7 +700,6 @@ class GeschossSetSpeed : public Aktion
 public:
     // speed, geschoss
     GeschossSetSpeed( RCArray< Aktion > *subActions );
-    ~GeschossSetSpeed();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -763,7 +708,6 @@ class GeschossSetPlayer : public Aktion
 public:
     // player, geschoss
     GeschossSetPlayer( RCArray< Aktion > *subActions );
-    ~GeschossSetPlayer();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -772,7 +716,6 @@ class GeschossSetRichtung : public Aktion
 public:
     // richtung, geschoss
     GeschossSetRichtung( RCArray< Aktion > *subActions );
-    ~GeschossSetRichtung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -781,7 +724,6 @@ class GeschossSetType : public Aktion
 public:
     // typ, geschoss
     GeschossSetType( RCArray< Aktion > *subActions );
-    ~GeschossSetType();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -863,7 +805,6 @@ private:
 public:
     // left, right
     IntegerRechnen( RCArray< Aktion > *subActions, Operator op );
-    ~IntegerRechnen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -872,7 +813,6 @@ class IntegerZufall : public Aktion
 public:
     // min, max
     IntegerZufall( RCArray< Aktion > *subActions );
-    ~IntegerZufall();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -881,7 +821,6 @@ class IntegerAusText : public Aktion
 public:
     // text
     IntegerAusText( RCArray< Aktion > *subActions );
-    ~IntegerAusText();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -890,7 +829,6 @@ class FloatXVonGameObjekt : public Aktion
 public:
     // objekt
     FloatXVonGameObjekt( RCArray< Aktion > *subActions );
-    ~FloatXVonGameObjekt();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -899,7 +837,6 @@ class FloatYVonGameObjekt : public Aktion
 public:
     // objekt
     FloatYVonGameObjekt( RCArray< Aktion > *subActions );
-    ~FloatYVonGameObjekt();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -908,7 +845,6 @@ class IntegerXVonTunnelZiel : public Aktion
 public:
     // tunnel
     IntegerXVonTunnelZiel( RCArray< Aktion > *subActions );
-    ~IntegerXVonTunnelZiel();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -917,7 +853,6 @@ class IntegerYVonTunnelZiel : public Aktion
 public:
     // tunnel
     IntegerYVonTunnelZiel( RCArray< Aktion > *subActions );
-    ~IntegerYVonTunnelZiel();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -926,7 +861,6 @@ class IntegerMinXVonDrop : public Aktion
 public:
     // drop
     IntegerMinXVonDrop( RCArray< Aktion > *subActions );
-    ~IntegerMinXVonDrop();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -935,7 +869,6 @@ class IntegerMinYVonDrop : public Aktion
 public:
     // drop
     IntegerMinYVonDrop( RCArray< Aktion > *subActions );
-    ~IntegerMinYVonDrop();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -944,7 +877,6 @@ class IntegerMaxXVonDrop : public Aktion
 public:
     // drop
     IntegerMaxXVonDrop( RCArray< Aktion > *subActions );
-    ~IntegerMaxXVonDrop();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -953,7 +885,6 @@ class IntegerMaxYVonDrop : public Aktion
 public:
     // drop
     IntegerMaxYVonDrop( RCArray< Aktion > *subActions );
-    ~IntegerMaxYVonDrop();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -962,7 +893,6 @@ class IntegerSpielerLevel : public Aktion
 public:
     // spieler
     IntegerSpielerLevel( RCArray< Aktion > *subActions );
-    ~IntegerSpielerLevel();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -971,7 +901,6 @@ class FloatSpielerLeben : public Aktion
 public:
     // spieler
     FloatSpielerLeben( RCArray< Aktion > *subActions );
-    ~FloatSpielerLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -980,7 +909,6 @@ class IntegerSpielerMaxLeben : public Aktion
 public:
     // spieler
     IntegerSpielerMaxLeben( RCArray< Aktion > *subActions );
-    ~IntegerSpielerMaxLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -989,7 +917,6 @@ class FloatSpielerErfahrung : public Aktion
 public:
     // spieler
     FloatSpielerErfahrung( RCArray< Aktion > *subActions );
-    ~FloatSpielerErfahrung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -998,7 +925,6 @@ class IntegerSpielerMaxErfahrung : public Aktion
 public:
     // spieler
     IntegerSpielerMaxErfahrung( RCArray< Aktion > *subActions );
-    ~IntegerSpielerMaxErfahrung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1007,7 +933,6 @@ class FloatSpielerTempo : public Aktion
 public:
     // spieler
     FloatSpielerTempo( RCArray< Aktion > *subActions );
-    ~FloatSpielerTempo();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1016,7 +941,6 @@ class FloatSpielerGeschossTempo : public Aktion
 public:
     // spieler
     FloatSpielerGeschossTempo( RCArray< Aktion > *subActions );
-    ~FloatSpielerGeschossTempo();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1025,7 +949,6 @@ class FloatSpielerArmor : public Aktion
 public:
     // spieler
     FloatSpielerArmor( RCArray< Aktion > *subActions );
-    ~FloatSpielerArmor();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1034,7 +957,6 @@ class FloatSpielerSchadenBonus : public Aktion
 public:
     // spieler
     FloatSpielerSchadenBonus( RCArray< Aktion > *subActions );
-    ~FloatSpielerSchadenBonus();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1043,7 +965,6 @@ class FloatSpielerLebensraub : public Aktion
 public:
     // spieler
     FloatSpielerLebensraub( RCArray< Aktion > *subActions );
-    ~FloatSpielerLebensraub();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1052,7 +973,6 @@ class FloatSpielerLebensregeneration : public Aktion
 public:
     // spieler
     FloatSpielerLebensregeneration( RCArray< Aktion > *subActions );
-    ~FloatSpielerLebensregeneration();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1061,7 +981,6 @@ class FloatSpielerAbklingzeitVerringerung : public Aktion
 public:
     // spieler
     FloatSpielerAbklingzeitVerringerung( RCArray< Aktion > *subActions );
-    ~FloatSpielerAbklingzeitVerringerung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1070,7 +989,6 @@ class IntegerSpielerTode : public Aktion
 public:
     // spieler
     IntegerSpielerTode( RCArray< Aktion > *subActions );
-    ~IntegerSpielerTode();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1079,7 +997,6 @@ class IntegerSpielerKills : public Aktion
 public:
     // spieler
     IntegerSpielerKills( RCArray< Aktion > *subActions );
-    ~IntegerSpielerKills();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1088,7 +1005,6 @@ class IntegerSpielerTreffer : public Aktion
 public:
     // spieler
     IntegerSpielerTreffer( RCArray< Aktion > *subActions );
-    ~IntegerSpielerTreffer();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1097,7 +1013,6 @@ class IntegerSpielerGetroffen : public Aktion
 public:
     // spieler
     IntegerSpielerGetroffen( RCArray< Aktion > *subActions );
-    ~IntegerSpielerGetroffen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1106,7 +1021,6 @@ class FloatSpielerErlittenerSchaden : public Aktion
 public:
     // spieler
     FloatSpielerErlittenerSchaden( RCArray< Aktion > *subActions );
-    ~FloatSpielerErlittenerSchaden();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1115,7 +1029,6 @@ class FloatSpielerSchaden : public Aktion
 public:
     // spieler
     FloatSpielerSchaden( RCArray< Aktion > *subActions );
-    ~FloatSpielerSchaden();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1124,7 +1037,6 @@ class FloatSpielerGeheiltesLeben : public Aktion
 public:
     // spieler
     FloatSpielerGeheiltesLeben( RCArray< Aktion > *subActions );
-    ~FloatSpielerGeheiltesLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1133,7 +1045,6 @@ class IntegerSpielerItemsAufgehoben : public Aktion
 public:
     // spieler
     IntegerSpielerItemsAufgehoben( RCArray< Aktion > *subActions );
-    ~IntegerSpielerItemsAufgehoben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1142,7 +1053,6 @@ class IntegerSpielerItemsVerwendet : public Aktion
 public:
     // spieler
     IntegerSpielerItemsVerwendet( RCArray< Aktion > *subActions );
-    ~IntegerSpielerItemsVerwendet();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1151,7 +1061,6 @@ class IntegerSpielerItemsInInventar : public Aktion
 public:
     // spieler
     IntegerSpielerItemsInInventar( RCArray< Aktion > *subActions );
-    ~IntegerSpielerItemsInInventar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1160,7 +1069,6 @@ class IntegerSpielerItemsTypeInInventar : public Aktion
 public:
     // item, spieler
     IntegerSpielerItemsTypeInInventar( RCArray< Aktion > *subActions );
-    ~IntegerSpielerItemsTypeInInventar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1169,7 +1077,6 @@ class IntegerSpielerTunnelBenutzt : public Aktion
 public:
     // spieler
     IntegerSpielerTunnelBenutzt( RCArray< Aktion > *subActions );
-    ~IntegerSpielerTunnelBenutzt();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1178,7 +1085,6 @@ class IntegerSpielerSchalterAktiviert : public Aktion
 public:
     // spieler
     IntegerSpielerSchalterAktiviert( RCArray< Aktion > *subActions );
-    ~IntegerSpielerSchalterAktiviert();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1187,7 +1093,6 @@ class IntegerSpielerGeschossen : public Aktion
 public:
     // spieler
     IntegerSpielerGeschossen( RCArray< Aktion > *subActions );
-    ~IntegerSpielerGeschossen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1196,7 +1101,6 @@ class FloatDropZeit : public Aktion
 public:
     // drop
     FloatDropZeit( RCArray< Aktion > *subActions );
-    ~FloatDropZeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1205,7 +1109,6 @@ class IntegerDropMaxZeit : public Aktion
 public:
     // drop
     IntegerDropMaxZeit( RCArray< Aktion > *subActions );
-    ~IntegerDropMaxZeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1214,7 +1117,6 @@ class FloatGameObjektBreite : public Aktion
 public:
     // objekt
     FloatGameObjektBreite( RCArray< Aktion > *subActions );
-    ~FloatGameObjektBreite();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1223,7 +1125,6 @@ class FloatGameObjektHeight : public Aktion
 public:
     // objekt
     FloatGameObjektHeight( RCArray< Aktion > *subActions );
-    ~FloatGameObjektHeight();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1232,7 +1133,6 @@ class IntegerBariereVerschiebungen : public Aktion
 public:
     // bariere
     IntegerBariereVerschiebungen( RCArray< Aktion > *subActions );
-    ~IntegerBariereVerschiebungen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1241,7 +1141,6 @@ class IntegerBariereSchaltungen : public Aktion
 public:
     // bariere
     IntegerBariereSchaltungen( RCArray< Aktion > *subActions );
-    ~IntegerBariereSchaltungen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1250,7 +1149,6 @@ class IntegerSchalterAktivierungen : public Aktion
 public:
     // schalter
     IntegerSchalterAktivierungen( RCArray< Aktion > *subActions );
-    ~IntegerSchalterAktivierungen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1259,7 +1157,6 @@ class IntegerTunnelBenutzungen : public Aktion
 public:
     // tunnel
     IntegerTunnelBenutzungen( RCArray< Aktion > *subActions );
-    ~IntegerTunnelBenutzungen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1268,7 +1165,6 @@ class IntegerUmlenkungBenutzungen : public Aktion
 public:
     // umlenkung
     IntegerUmlenkungBenutzungen( RCArray< Aktion > *subActions );
-    ~IntegerUmlenkungBenutzungen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1277,7 +1173,6 @@ class IntegerTeamPunkte : public Aktion
 public:
     // team
     IntegerTeamPunkte( RCArray< Aktion > *subActions );
-    ~IntegerTeamPunkte();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1286,7 +1181,6 @@ class IntegerTeamKills : public Aktion
 public:
     // team
     IntegerTeamKills( RCArray< Aktion > *subActions );
-    ~IntegerTeamKills();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1295,7 +1189,6 @@ class IntegerTeamTode : public Aktion
 public:
     // team
     IntegerTeamTode( RCArray< Aktion > *subActions );
-    ~IntegerTeamTode();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1304,7 +1197,6 @@ class FloatTeamWiederbelegungszeit : public Aktion
 public:
     // team
     FloatTeamWiederbelegungszeit( RCArray< Aktion > *subActions );
-    ~FloatTeamWiederbelegungszeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1313,7 +1205,6 @@ class IntegerTeamSpieleranzahl : public Aktion
 public:
     // team
     IntegerTeamSpieleranzahl( RCArray< Aktion > *subActions );
-    ~IntegerTeamSpieleranzahl();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1322,7 +1213,6 @@ class FloatTimerAktuelleZeit : public Aktion
 public:
     // timer
     FloatTimerAktuelleZeit( RCArray< Aktion > *subActions );
-    ~FloatTimerAktuelleZeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1331,7 +1221,6 @@ class IntegerTimerMaxZeit : public Aktion
 public:
     // timer
     IntegerTimerMaxZeit( RCArray< Aktion > *subActions );
-    ~IntegerTimerMaxZeit();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1340,7 +1229,6 @@ class IntegerTriggerRunns : public Aktion
 public:
     // trigger
     IntegerTriggerRunns( RCArray< Aktion > *subActions );
-    ~IntegerTriggerRunns();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1349,7 +1237,6 @@ class ItemSpielerInventar : public Aktion
 public:
     // index, spieler
     ItemSpielerInventar( RCArray< Aktion > *subActions );
-    ~ItemSpielerInventar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1435,7 +1322,6 @@ class RichtungVonUmlenkung : public Aktion
 public:
     // umlenkung
     RichtungVonUmlenkung( RCArray< Aktion > *subActions );
-    ~RichtungVonUmlenkung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1444,7 +1330,6 @@ class RichtungVonGeschoss : public Aktion
 public:
     // geschoss
     RichtungVonGeschoss( RCArray< Aktion > *subActions );
-    ~RichtungVonGeschoss();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1474,7 +1359,6 @@ class SpielerZufallAusTeam : public Aktion
 public:
     // team
     SpielerZufallAusTeam( RCArray< Aktion > *subActions );
-    ~SpielerZufallAusTeam();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1567,7 +1451,6 @@ class TextConcat : public Aktion
 public:
     // t1, t2
     TextConcat( RCArray< Aktion > *subActions );
-    ~TextConcat();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1576,7 +1459,6 @@ class TextAusInteger : public Aktion
 public:
     // integer
     TextAusInteger( RCArray< Aktion > *subActions );
-    ~TextAusInteger();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1585,7 +1467,6 @@ class TextAusRichtung : public Aktion
 public:
     // richtung
     TextAusRichtung( RCArray< Aktion > *subActions );
-    ~TextAusRichtung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1594,7 +1475,6 @@ class TextAusBoolean : public Aktion
 public:
     // boolean
     TextAusBoolean( RCArray< Aktion > *subActions );
-    ~TextAusBoolean();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1603,7 +1483,6 @@ class TextSpielerName : public Aktion
 public:
     // spieler
     TextSpielerName( RCArray< Aktion > *subActions );
-    ~TextSpielerName();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1612,7 +1491,6 @@ class TextItemName : public Aktion
 public:
     // item
     TextItemName( RCArray< Aktion > *subActions );
-    ~TextItemName();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1621,7 +1499,6 @@ class TextTriggerName : public Aktion
 public:
     // trigger
     TextTriggerName( RCArray< Aktion > *subActions );
-    ~TextTriggerName();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1630,7 +1507,6 @@ class TextTeilVonText : public Aktion
 public:
     // start, ende, text
     TextTeilVonText( RCArray< Aktion > *subActions );
-    ~TextTeilVonText();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1646,7 +1522,6 @@ class TeamVonSpieler : public Aktion
 public:
     // spieler
     TeamVonSpieler( RCArray< Aktion > *subActions );
-    ~TeamVonSpieler();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1655,7 +1530,6 @@ class TeamVonBariere : public Aktion
 public:
     // bariere
     TeamVonBariere( RCArray< Aktion > *subActions );
-    ~TeamVonBariere();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1741,7 +1615,6 @@ class BooleanSpielerAmLeben : public Aktion
 public:
     // spieler
     BooleanSpielerAmLeben( RCArray< Aktion > *subActions );
-    ~BooleanSpielerAmLeben();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1750,25 +1623,14 @@ class BooleanSpielerHatGegenstand : public Aktion
 public:
     // item, spieler
     BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions );
-    ~BooleanSpielerHatGegenstand();
-    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class BooleanSpielerInTeam : public Aktion
-{
-public:
-    // team, spieler
-    BooleanSpielerInTeam( RCArray< Aktion > *subActions );
-    ~BooleanSpielerInTeam();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
 class BooleanSpielerIstVerwundbar : public Aktion
 {
 public:
-    // spieler
+    // richtung, spieler
     BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions );
-    ~BooleanSpielerIstVerwundbar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1777,7 +1639,6 @@ class BooleanSpielerKannItemBenutzen : public Aktion
 public:
     // item, spieler
     BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions );
-    ~BooleanSpielerKannItemBenutzen();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1786,7 +1647,6 @@ class BooleanUmlenkungHatAbk : public Aktion
 public:
     // umlenkung
     BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions );
-    ~BooleanUmlenkungHatAbk();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1795,7 +1655,6 @@ class BooleanUmlenkungIstDrehend : public Aktion
 public:
     // umlenkung
     BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions );
-    ~BooleanUmlenkungIstDrehend();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1804,7 +1663,6 @@ class BooleanBariereBewegtSich : public Aktion
 public:
     // bariere
     BooleanBariereBewegtSich( RCArray< Aktion > *subActions );
-    ~BooleanBariereBewegtSich();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1813,7 +1671,6 @@ class BooleanBariereIstSchaltend : public Aktion
 public:
     // bariere
     BooleanBariereIstSchaltend( RCArray< Aktion > *subActions );
-    ~BooleanBariereIstSchaltend();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1822,7 +1679,6 @@ class BooleanBariereIstAktiv : public Aktion
 public:
     // bariere
     BooleanBariereIstAktiv( RCArray< Aktion > *subActions );
-    ~BooleanBariereIstAktiv();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1831,7 +1687,6 @@ class BooleanSchalterIstAktiv : public Aktion
 public:
     // schalter
     BooleanSchalterIstAktiv( RCArray< Aktion > *subActions );
-    ~BooleanSchalterIstAktiv();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1840,7 +1695,6 @@ class BooleanTunnelIstAktiv : public Aktion
 public:
     // tunnel
     BooleanTunnelIstAktiv( RCArray< Aktion > *subActions );
-    ~BooleanTunnelIstAktiv();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1849,7 +1703,6 @@ class BooleanBaseIstNeutral : public Aktion
 public:
     // base
     BooleanBaseIstNeutral( RCArray< Aktion > *subActions );
-    ~BooleanBaseIstNeutral();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1857,7 +1710,6 @@ class BooleanTimerIsRunning : public Aktion
 {
 public:
     BooleanTimerIsRunning( RCArray< Aktion > *subActions );
-    ~BooleanTimerIsRunning();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1866,7 +1718,6 @@ class BooleanTimerIstSichtbar : public Aktion
 public:
     // timer
     BooleanTimerIstSichtbar( RCArray< Aktion > *subActions );
-    ~BooleanTimerIstSichtbar();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1875,7 +1726,6 @@ class BooleanAusText : public Aktion
 public:
     // text
     BooleanAusText( RCArray< Aktion > *subActions );
-    ~BooleanAusText();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1884,7 +1734,6 @@ class BooleanTriggerIstAktiv : public Aktion
 public:
     // trigger
     BooleanTriggerIstAktiv( RCArray< Aktion > *subActions );
-    ~BooleanTriggerIstAktiv();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1896,7 +1745,6 @@ private:
 public:
     // v1, v2
     BooleanRechnung( RCArray< Aktion > *subActions, Operator op );
-    ~BooleanRechnung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1904,7 +1752,6 @@ class Sequenz : public Aktion
 {
 public:
     Sequenz( RCArray< Aktion > *aktions );
-    ~Sequenz();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1916,7 +1763,6 @@ private:
 public:
     // left, right
     FloatRechnung( RCArray< Aktion > *subActions, Operator op );
-    ~FloatRechnung();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1925,7 +1771,6 @@ class FloatAusInteger : public Aktion
 public:
     // integer
     FloatAusInteger( RCArray< Aktion > *subActions );
-    ~FloatAusInteger();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1934,7 +1779,6 @@ class FloatAusText : public Aktion
 public:
     // text
     FloatAusText( RCArray< Aktion > *subActions );
-    ~FloatAusText();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1943,7 +1787,6 @@ class TextAusFloat : public Aktion
 public:
     // f
     TextAusFloat( RCArray< Aktion > *subActions );
-    ~TextAusFloat();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1952,7 +1795,6 @@ class FloatZufall : public Aktion
 public:
     // min, max
     FloatZufall( RCArray< Aktion > *subActions );
-    ~FloatZufall();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1961,6 +1803,5 @@ class IntegerAusFloat : public Aktion
 public:
     // f
     IntegerAusFloat( RCArray< Aktion > *subActions );
-    ~IntegerAusFloat();
     void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };

StickmanWorldOnline/Drop.h

@@ -35,6 +35,7 @@ public:
     int getMaxX() const;
     int getMinY() const;
     int getMaxY() const;
+    float getZeit() const;
     int getMaxTime() const;
     int getId() const;
 };

StickmanWorldOnline/GameObject.cpp

@@ -1,33 +1,6 @@
 #include "GameObject.h"
 
 
-Richtung invert( Richtung r )
-{
-    if( r == OBEN )
-        return UNTEN;
-    if( r == UNTEN )
-        return OBEN;
-    if( r == LINKS )
-        return RECHTS;
-    if( r == RECHTS )
-        return LINKS;
-    return r;
-}
-
-Richtung getRichtungFromString( Text str )
-{
-    if( str.istGleich( "OBEN" ) )
-        return OBEN;
-    if( str.istGleich( "LINKS" ) )
-        return LINKS;
-    if( str.istGleich( "UNTEN" ) )
-        return UNTEN;
-    if( str.istGleich( "RECHTS" ) )
-        return RECHTS;
-    return MITTE;
-}
-
-
 GameObject::GameObject( VariableTyp typ, int x, int y, int width, int height )
     : Variable( typ )
 {

StickmanWorldOnline/GameObject.h

@@ -2,19 +2,6 @@
 
 #include "Variablen.h"
 
-enum Richtung
-{
-    OBEN,
-    RECHTS,
-    UNTEN,
-    LINKS,
-    MITTE
-};
-
-Richtung invert( Richtung r );
-
-Richtung getRichtungFromString( Text str );
-
 class GameObject : public Variable
 {
 protected:

StickmanWorldOnline/Geschoss.cpp

@@ -1,20 +1,6 @@
 #include "Geschoss.h"
 
 
-GeschossTyp getGeschossTypFromString( Text str )
-{
-    if( str.istGleich( "KUGEL" ) )
-        return GESCHOSS_KUGEL;
-    if( str.istGleich( "DRACHENAUGE" ) )
-        return GESCHOSS_DRACHENAUGE;
-    if( str.istGleich( "FEUERBALL" ) )
-        return GESCHOSS_FEUERBALL;
-    if( str.istGleich( "MINE" ) )
-        return GESCHOSS_MINE;
-    return GESCHOSS_PFEIL;
-}
-
-
 Geschoss::Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer )
     : GameObject( GESCHOSS, x, y, 20, 20 )
 {

StickmanWorldOnline/Geschoss.h

@@ -3,17 +3,6 @@
 #include "GameObject.h"
 #include "Spieler.h"
 
-enum GeschossTyp
-{
-    GESCHOSS_PFEIL,
-    GESCHOSS_KUGEL,
-    GESCHOSS_DRACHENAUGE,
-    GESCHOSS_FEUERBALL,
-    GESCHOSS_MINE
-};
-
-GeschossTyp getGeschossTypFromString( Text str );
-
 #define PFEIL_DAMAGE 100
 #define KUGEL_DAMAGE 100
 

StickmanWorldOnline/Reader.cpp

@@ -93,8 +93,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new BooleanSpielerAmLeben( params );
     case BOOLEAN_SPIELER_HAT_GEGENSTAND:
         return new BooleanSpielerHatGegenstand( params );
-    case BOOLEAN_SPIELER_IN_TEAM:
-        return new BooleanSpielerInTeam( params );
     case BOOLEAN_SPIELER_IST_VERWUNDBAR:
         return new BooleanSpielerIstVerwundbar( params );
     case BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN:
@@ -278,9 +276,15 @@ Aktion *MapReader::readAktion( Datei &dat )
     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();

StickmanWorldOnline/Spiel.h

@@ -128,6 +128,41 @@ public:
     Base *getLastTeamChangedBase() const;
     Drop *getRandomDrop() const;
     Drop *getLastDrop() const;
+    GegenstandTyp getItemZuletztAufgehoben() const;
+    GegenstandTyp getItemZuletztAktiviert() const;
+    GegenstandTyp getItemZuletztGedropt() const;
+    Geschoss *getRandomGeschoss() const;
+    Geschoss *getGeschossZuletztAbgefeuert() const;
+    Geschoss *getGeschossZuletztUmgelenkt() const;
+    Geschoss *getGeschossZuletztBariereGetroffen() const;
+    Geschoss *getGeschossZuletztTunnelBenutzt() const;
+    Geschoss *getGeschossZuletztGeschossGetroffen() const;
+    Schalter *getRandomSchalter() const;
+    Schalter *getSchalterZuletztAktiviert() const;
+    Spieler *getRandomSpieler() const;
+    Spieler *getRandomSpieler( Team *zTeam ) const;
+    Spieler *getSpielerZuletztSchadenGemacht() const;
+    Spieler *getSpielerZuletztSchadenGenommen() const;
+    Spieler *getSpielerZuletztGeheilt() const;
+    Spieler *getSpielerZuletztLevelUp() const;
+    Spieler *getSpielerZuletztErfahrungBekommen() const;
+    Spieler *getSpielerZuletztGegenstandAktiviert() const;
+    Spieler *getSpielerZuletztGegenstandAufgehoben() const;
+    Spieler *getSpielerZuletztSchalterAktiviert() const;
+    Spieler *getSpielerZuletztTunnelBenutzt() const;
+    Spieler *getSpielerZuletztGestorben() const;
+    Spieler *getSpielerZuletztWiederbelebt() const;
+    Spieler *getSpielerZuletztGeschossen() const;
+    Team *getRandomTeam() const;
+    Timer *getRandomTimer() const;
+    Timer *getTimerZuletztAbgelaufen() const;
+    Timer *getTimerZuletztGestartet() const;
+    Timer *getTimerZuletztPausiert() const;
+    Timer *getTimerZuletztFortgesetzt() const;
+    Tunnel *getRandomTunnel() const;
+    Tunnel *getTunnelZuletztBenutzt() const;
+    Umlenkung *getRandomUmlenkung() const;
+    Umlenkung *getUmlenkungZuletztBenutzt() const;
     // constant
     StatistikV *getStatistik() const override;
     // Reference Counting 

StickmanWorldOnline/Spieler.h

@@ -118,6 +118,7 @@ public:
     Klient *zKlient() const;
     int getSpielerNummer() const;
     Team *zTeam() const;
+    Team *getTeam() const;
     int getFarbe() const;
     int getAccountId() const;
     int getPunkte() const;
@@ -126,10 +127,30 @@ public:
     bool isVerwundbar( Richtung r ) const;
     bool istBeweglich( Richtung r ) const;
     bool istSichtbar( Team *zTeam ) const;
+    // TODO return false if abklingzeit is active
     bool istGegenstandErlaubt( GegenstandTyp typ ) const;
     Richtung getAusrichtung() const;
     float getAbklingZeitVerringerung() const;
     int getId() const;
     int getLevel() const;
     float getLeben() const;
+    int getMaxLeben() const;
+    float getErfahrung() const;
+    int getMaxErfahrung() const;
+    int getTode() const;
+    int getKills() const;
+    int getTreffer() const;
+    int getGetroffen() const;
+    float getErlittenerSchaden() const;
+    float getGemachterSchaden() const;
+    float getGeheiltesLeben() const;
+    int getItemsAufgehoben() const;
+    int getItemsVerwendet() const;
+    int getItemsInInventory() const;
+    int getItemsInInventory( GegenstandTyp typ ) const;
+    int getTunnelBenutzt() const;
+    int getSchalterAktiviert() const;
+    int getGeschossen() const;
+    GegenstandTyp getInventorySlot( int index ) const;
+    const char *getName() const;
 };

StickmanWorldOnline/Team.cpp

@@ -5,7 +5,7 @@ Team::Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit,
     : Variable( TEAM )
 {
     teamNummer = id;
-    this->maxSpielerAnzahl = maxSpielerAnzahl;
+    this->maxSpielerAnzahl = (float)maxSpielerAnzahl;
     spielerAnzahl = 0;
     this->punkte = punkte;
     kills = 0;
@@ -15,7 +15,7 @@ Team::Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit,
     this->name = name;
 }
 
-void Team::setMaxWiederbelebungsZeit( int sekunden )
+void Team::setMaxWiederbelebungsZeit( float sekunden )
 {
     this->maxWiederbelebungsZeit = sekunden;
 }
@@ -53,7 +53,7 @@ Text Team::getName() const
     return name;
 }
 
-int Team::getMaxWiederbelebungsZeit() const
+float Team::getMaxWiederbelebungsZeit() const
 {
     return maxWiederbelebungsZeit;
 }

StickmanWorldOnline/Team.h

@@ -5,7 +5,7 @@
 class Team : public Variable
 {
 private:
-    int maxWiederbelebungsZeit;
+    float maxWiederbelebungsZeit;
     int tode;
     int kills;
     int punkte;
@@ -17,7 +17,7 @@ private:
 
 public:
     Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit, int farbe, const char *name );
-    void setMaxWiederbelebungsZeit( int sekunden );
+    void setMaxWiederbelebungsZeit( float sekunden );
     void addSpieler();
     void removeSpieler();
     void addTod();
@@ -25,7 +25,7 @@ public:
     void addPunkte( int punkte );
     void setPunkte( int punkte );
     Text getName() const;
-    int getMaxWiederbelebungsZeit() const;
+    float getMaxWiederbelebungsZeit() const;
     int getTode() const;
     int getKills() const;
     int getPunkte() const;

StickmanWorldOnline/Trigger.cpp

@@ -222,6 +222,7 @@ Trigger::Trigger( int id, const char *name, int ereignisAnzahl, EreignisTyp *ere
     this->bedingungen = bedingungen;
     this->aktionen = aktionen;
     aktiv = 1;
+    runCount = 0;
 }
 
 Trigger::~Trigger()
@@ -277,6 +278,7 @@ TriggerRun *Trigger::runTrigger( Ereignis *e, Spiel *zSpiel )
             return 0;
         }
     }
+    runCount++;
     return new TriggerRun( (Trigger *)getThis(), e, zSpiel );
 }
 

StickmanWorldOnline/Trigger.h

@@ -87,6 +87,7 @@ private:
     EreignisTyp *ereignisse;
     RCArray< Bedingung > *bedingungen;
     RCArray< Aktion > *aktionen;
+    int runCount;
     bool aktiv;
 
 public:
@@ -100,6 +101,8 @@ public:
     // return: 0, falls die bedingungen nicht erfüllt sind
     TriggerRun *runTrigger( Ereignis *e, Spiel *zSpiel );
     int getId() const;
+    int getRuns() const;
+    const char *getName() const;
 };
 
 class TriggerRun

StickmanWorldOnline/Umlenkung.h

@@ -26,5 +26,6 @@ public:
     bool istDrehend() const;
     int getMaxAbklingzeit() const;
     Richtung getRichtung() const;
+    int getBenutzungen() const;
     int getId() const;
 };

StickmanWorldOnline/Variablen.cpp

@@ -2,6 +2,48 @@
 #include "Gegenstand.h"
 
 
+GeschossTyp getGeschossTypFromString( Text str )
+{
+    if( str.istGleich( "KUGEL" ) )
+        return GESCHOSS_KUGEL;
+    if( str.istGleich( "DRACHENAUGE" ) )
+        return GESCHOSS_DRACHENAUGE;
+    if( str.istGleich( "FEUERBALL" ) )
+        return GESCHOSS_FEUERBALL;
+    if( str.istGleich( "MINE" ) )
+        return GESCHOSS_MINE;
+    return GESCHOSS_PFEIL;
+}
+
+
+Richtung invert( Richtung r )
+{
+    if( r == OBEN )
+        return UNTEN;
+    if( r == UNTEN )
+        return OBEN;
+    if( r == LINKS )
+        return RECHTS;
+    if( r == RECHTS )
+        return LINKS;
+    return r;
+}
+
+
+Richtung getRichtungFromString( Text str )
+{
+    if( str.istGleich( "OBEN" ) )
+        return OBEN;
+    if( str.istGleich( "LINKS" ) )
+        return LINKS;
+    if( str.istGleich( "UNTEN" ) )
+        return UNTEN;
+    if( str.istGleich( "RECHTS" ) )
+        return RECHTS;
+    return MITTE;
+}
+
+
 bool operator==( VariableTyp a, VariableTyp b )
 {
     if( a == GAME_OBJEKT || b == GAME_OBJEKT )
@@ -111,12 +153,58 @@ bool Boolean::getValue() const
 }
 
 
-String::String( const char *value, bool richtung, bool geschossTyp )
-    : Variable( richtung ? RICHTUNG : ( geschossTyp ? GESCHOSS_TYP : STRING ) )
+String::String( const char *value )
+    : Variable( STRING )
 {
     this->value = value;
 }
 
+String::String( Richtung r )
+    : Variable( RICHTUNG )
+{
+    switch( r )
+    {
+    case OBEN:
+        value = "OBEN";
+        break;
+    case UNTEN:
+        value = "UNTEN";
+        break;
+    case LINKS:
+        value = "LINKS";
+        break;
+    case RECHTS:
+        value = "RECHTS";
+        break;
+    case MITTE:
+        value = "MITTE";
+        break;
+    }
+}
+
+String::String( GeschossTyp typ )
+    : Variable( GESCHOSS_TYP )
+{
+    switch( typ )
+    {
+    case GESCHOSS_PFEIL:
+        value = "PFEIL";
+        break;
+    case GESCHOSS_KUGEL:
+        value = "KUGEL";
+        break;
+    case GESCHOSS_FEUERBALL:
+        value = "FEUERBALL";
+        break;
+    case GESCHOSS_DRACHENAUGE:
+        value = "DRACHENAUGE";
+        break;
+    case GESCHOSS_MINE:
+        value = "MINE";
+        break;
+    }
+}
+
 void String::setValue( Text value )
 {
     this->value = value;

StickmanWorldOnline/Variablen.h

@@ -34,6 +34,31 @@ enum VariableTyp
     ALLE
 };
 
+enum GeschossTyp
+{
+    GESCHOSS_PFEIL,
+    GESCHOSS_KUGEL,
+    GESCHOSS_DRACHENAUGE,
+    GESCHOSS_FEUERBALL,
+    GESCHOSS_MINE
+};
+
+GeschossTyp getGeschossTypFromString( Text str );
+
+enum Richtung
+{
+    OBEN,
+    RECHTS,
+    UNTEN,
+    LINKS,
+    MITTE,
+    RICHTUNG_ANZAHL
+};
+
+Richtung invert( Richtung r );
+
+Richtung getRichtungFromString( Text str );
+
 bool operator==( VariableTyp a, VariableTyp b );
 bool operator!=( VariableTyp a, VariableTyp b );
 
@@ -81,7 +106,9 @@ private:
     Text value;
 
 public:
-    String( const char *value, bool richtung = 0, bool geschossTyp = 0 );
+    String( const char *value );
+    String( Richtung r );
+    String( GeschossTyp typ );
     void setValue( Text value );
     const Text &getValue() const;
 };