server code hinzugefügt (fehlt nurnoch das zeichnen)

StickmanWorldOnline/Aktionen.cpp

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

StickmanWorldOnline/Aktionen.h

@@ -0,0 +1,1807 @@
+#pragma once
+
+#include "Variablen.h"
+#include <Array.h>
+
+class Spiel;
+class Ereignis;
+class ProgramCounter;
+class LocalMemory;
+
+enum AktionTyp
+{
+    BARIERE_BEWEGUNG,
+    BARIERE_SET_EINGESCHALTET,
+    GAME_OBJEKT_SET_POSITION,
+    GAME_OBJEKT_SET_SIZE,
+    BARIERE_SET_TEAM,
+    BARIERE_ZUFALL,
+    BARIERE_ZULETZT_AUSGESCHALTET,
+    BARIERE_ZULETZT_BEWEGT,
+    BARIERE_ZULETZT_EINGESCHALTET,
+    BASE_SET_TEAM,
+    BASE_ZUFALL,
+    BASE_ZULETZT_BESITZER_GEWECHSELT,
+    BOOLEAN_AUS_TEXT,
+    BOOLEAN_BARIERE_BEWEGT_SICH,
+    BOOLEAN_BARIERE_IST_AKTIV,
+    BOOLEAN_BARIERE_IST_SCHALTEND,
+    BOOLEAN_BASE_IST_NEUTRAL,
+    BOOLEAN_RECHNUNG,
+    BOOLEAN_SCHALTER_IST_AKTIV,
+    BOOLEAN_SPIELER_AM_LEBEN,
+    BOOLEAN_SPIELER_HAT_GEGENSTAND,
+    BOOLEAN_SPIELER_IST_VERWUNDBAR,
+    BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN,
+    BOOLEAN_SPIEL_PAUSIERT,
+    BOOLEAN_TIMER_IS_RUNNING,
+    BOOLEAN_TIMER_IST_SICHTBAR,
+    BOOLEAN_TRIGGER_IST_AKTIV,
+    BOOLEAN_TUNNEL_IST_AKTIV,
+    BOOLEAN_UMLENKUNG_HAT_ABK,
+    BOOLEAN_UMLENKUNG_IST_DREHEND,
+    BOOLEAN_ZUFALL,
+    DISPLAY_TEXT,
+    DROP_DO_DROP,
+    DROP_SET_AREA,
+    DROP_SET_MAX_TIME,
+    DROP_SET_TIME,
+    DROP_ZUFALL,
+    DROP_ZULETZT_GEDROPT,
+    GESCHOSS_NEU,
+    GESCHOSS_SET_PLAYER,
+    GESCHOSS_SET_RICHTUNG,
+    GESCHOSS_SET_SPEED,
+    GESCHOSS_SET_TYPE,
+    GESCHOSS_ZUFALL,
+    GESCHOSS_ZULETZT_ABGEFEUERT,
+    GESCHOSS_ZULETZT_BARIERE_GETROFFEN,
+    GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN,
+    GESCHOSS_ZULETZT_TUNNEL_BENUTZT,
+    GESCHOSS_ZULETZT_UMGELENKT,
+    INTEGER_AUS_TEXT,
+    FLOAT_GAME_OBJEKT_BREITE,
+    FLOAT_GAME_OBJEKT_HEIGHT,
+    INTEGER_BARIERE_SCHALTUNGEN,
+    INTEGER_BARIERE_VERSCHIEBUNGEN,
+    INTEGER_DROP_MAX_ZEIT,
+    FLOAT_DROP_ZEIT,
+    INTEGER_MAX_X_VON_DROP,
+    INTEGER_MAX_Y_VON_DROP,
+    INTEGER_MIN_X_VON_DROP,
+    INTEGER_MIN_Y_VON_DROP,
+    INTEGER_RECHNEN,
+    INTEGER_SCHALTER_AKTIVIERUNGEN,
+    FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG,
+    FLOAT_SPIELER_ARMOR,
+    FLOAT_SPIELER_ERFAHRUNG,
+    FLOAT_SPIELER_ERLITTENER_SCHADEN,
+    FLOAT_SPIELER_GEHEILTES_LEBEN,
+    INTEGER_SPIELER_GESCHOSSEN,
+    FLOAT_SPIELER_GESCHOSS_TEMPO,
+    INTEGER_SPIELER_GETROFFEN,
+    INTEGER_SPIELER_ITEMS_AUFGEHOBEN,
+    INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR,
+    INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP,
+    INTEGER_SPIELER_ITEMS_VERWENDET,
+    INTEGER_SPIELER_KILLS,
+    FLOAT_SPIELER_LEBEN,
+    FLOAT_SPIELER_LEBENSRAUB,
+    FLOAT_SPIELER_LEBENSREGENERATION,
+    INTEGER_SPIELER_LEVEL,
+    INTEGER_SPIELER_MAX_ERFAHRUNG,
+    INTEGER_SPIELER_MAX_LEBEN,
+    FLOAT_SPIELER_SCHADEN,
+    FLOAT_SPIELER_SCHADEN_BONUS,
+    INTEGER_SPIELER_SCHALTER_AKTIVIERT,
+    FLOAT_SPIELER_TEMPO,
+    INTEGER_SPIELER_TODE,
+    INTEGER_SPIELER_TREFFER,
+    INTEGER_SPIELER_TUNNEL_BENUTZT,
+    INTEGER_TEAM_KILLS,
+    INTEGER_TEAM_PUNKTE,
+    INTEGER_TEAM_SPIELERANZAHL,
+    INTEGER_TEAM_TODE,
+    FLOAT_TEAM_WIEDERBELEBUNGSZEIT,
+    FLOAT_TIMER_AKTUELLE_ZEIT,
+    INTEGER_TIMER_MAX_ZEIT,
+    INTEGER_TRIGGER_RUNNS,
+    INTEGER_TUNNEL_BENUTZUNGEN,
+    INTEGER_UMLENKUNG_BENUTZUNGEN,
+    FLOAT_X_VON_GAME_OBJEKT,
+    FLOAT_Y_VON_GAME_OBJEKT,
+    INTEGER_X_VON_TUNNEL_ZIEL,
+    INTEGER_Y_VON_TUNNEL_ZIEL,
+    INTEGER_ZUFALL,
+    ITEM_SPIELER_INVENTAR,
+    ITEM_ZULETZT_AUFGEHOBEN,
+    ITEM_ZULETZT_AKTIVIERT,
+    ITEM_ZULETZT_GEDROPT,
+    ITEM_ZUFALL,
+    KONSTANT_BOOLEAN,
+    KONSTANT_FLOAT,
+    KONSTANT_INTEGER,
+    KONSTANT_NICHTS,
+    KONSTANT_STRING,
+    KONSTANT_VARIABLE,
+    RICHTUNG_VON_GESCHOSS,
+    RICHTUNG_VON_UMLENKUNG,
+    RICHTUNG_ZUFALL,
+    SCHALTER_AKTIVIEREN,
+    SCHALTER_SET_ERLAUBT,
+    SCHALTER_ZUFALL,
+    SCHALTER_ZULETZT_AKTIVIERT,
+    SET_VARIABLE,
+    SPIEL_ENDE,
+    SPIELER_GIVE_ITEM,
+    SPIELER_NACHRICHT,
+    SPIELER_REMOVE_ITEM,
+    SPIELER_SET_ABKLINGZEITVERRINGERUNG,
+    SPIELER_SET_ARMOR,
+    SPIELER_SET_ERFAHRUNG,
+    SPIELER_SET_LEBEN,
+    SPIELER_SET_LEBENSRAUB,
+    SPIELER_SET_LEBENSREGENERATION,
+    SPIELER_SET_LEVEL,
+    SPIELER_SET_MAX_ERFAHRUNG,
+    SPIELER_SET_SCHADEN_BONUS,
+    SPIELER_SET_TEMPO,
+    SPIELER_SET_GESCHOSS_TEMPO,
+    SPIELER_ZUFALL,
+    SPIELER_ZUFALL_AUS_TEAM,
+    SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN,
+    SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT,
+    SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN,
+    SPIELER_ZULETZT_GEHEILT,
+    SPIELER_ZULETZT_GESCHOSSEN,
+    SPIELER_ZULETZT_GESTORBEN,
+    SPIELER_ZULETZT_LEVEL_UP,
+    SPIELER_ZULETZT_SCHADEN_GEMACHT,
+    SPIELER_ZULETZT_SCHADEN_GENOMMEN,
+    SPIELER_ZULETZT_SCHALTER_AKTIVIERT,
+    SPIELER_ZULETZT_TUNNEL_BENUTZT,
+    SPIELER_ZULETZT_WIEDERBELEBT,
+    SPIEL_PAUSE,
+    TEAM_SET_PUNKTE,
+    TEAM_VON_BARIERE,
+    TEAM_VON_SPIELER,
+    TEAM_ZUFALL,
+    TEXT_AUS_BOOLEAN,
+    TEXT_AUS_RICHTUNG,
+    TEXT_AUS_INTEGER,
+    TEXT_CONCAT,
+    TEXT_ITEM_NAME,
+    TEXT_SPIELER_NAME,
+    TEXT_TEIL_VON_TEXT,
+    TEXT_TRIGGER_NAME,
+    TIMER_SET_PAUSE,
+    TIMER_SET_SICHTBAR,
+    TIMER_SET_ZEIT,
+    TIMER_START,
+    TIMER_ZUFALL,
+    TIMER_ZULETZT_ABGELAUFEN,
+    TIMER_ZULETZT_FOTOGRAFIERT,
+    TIMER_ZULETZT_GESTARTET,
+    TIMER_ZULETZT_PAUSIERT,
+    TRIGGER_AKTION,
+    TRIGGER_LAST_RUNNED,
+    TRIGGER_RUN_START,
+    TRIGGER_SET_ENABLED,
+    TRIGGER_ZUFALL,
+    TUNNEL_SET_ERLAUBT,
+    TUNNEL_SET_ZIEL_POSITION,
+    TUNNEL_ZUFALL,
+    TUNNEL_ZULETZT_BENUTZT,
+    UMLENKUNG_SET_ERLAUBT,
+    UMLENKUNG_SET_MAX_ABK,
+    UMLENKUNG_SET_RICHTUNG,
+    UMLENKUNG_ZUFALL,
+    UMLENKUNG_ZULETZT_BENUTZT,
+    WARTEN,
+    WENN_DANN_SONST,
+    SEQUENZ,
+    FLOAT_RECHNUNG,
+    FLOAT_AUS_INTEGER,
+    FLOAT_AUS_TEXT,
+    TEXT_AUS_FLOAT,
+    FLOAT_ZUFALL,
+    INTEGER_AUS_FLOAT
+};
+
+enum Operator
+{
+    PLUS,
+    MINUS,
+    MAHL,
+    GETEILT,
+    HOCH,
+    WURZEL,
+    BIT_ODER,
+    BIT_UND,
+    BIT_XOR,
+    BIT_FLIP,
+    BIT_SHIFT_LEFT,
+    BIT_SHIFT_RIGHT,
+    INVERT_SIGN,
+    PLUS_PLUS_LEFT,
+    PLUS_PLUS_RIGHT,
+    MINUS_MINUS_LEFT,
+    MINUS_MINUS_RIGHT,
+    LOGARITHM,
+    MODULO,
+    UND,
+    ODER,
+    GLEICH,
+    UNGLEICH,
+    GREATER,
+    SMALLER,
+    GREATER_OR_EQUAL,
+    SMALLER_OR_EQUAL,
+    INVERT_BOOL
+};
+
+bool isBinary( Operator op );
+
+class Aktion : public Variable
+{
+protected:
+    RCArray< Aktion > *subActions;
+    Array< VariableTyp > erlaubteTypen;
+    AktionTyp typ;
+    Variable *zEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );
+    Variable *getEvaluatedParam( int number, LocalMemory *zMemory, ProgramCounter *zPC );
+
+public:
+    Aktion( AktionTyp typ, RCArray< Aktion > *subActions );
+    virtual ~Aktion();
+    // gibt 1 zurück, wenn die aktion vollständig ausgeführt wurde
+    virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount );
+    virtual void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount );
+};
+
+class KonstantNichts : public Aktion
+{
+public:
+    KonstantNichts();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class KonstantInteger : public Aktion
+{
+private:
+    int value;
+
+public:
+    KonstantInteger( int val );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class KonstantBoolean : public Aktion
+{
+private:
+    bool value;
+
+public:
+    KonstantBoolean( bool val );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class KonstantString : public Aktion
+{
+private:
+    Text value;
+
+public:
+    KonstantString( Text val );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class KonstantFloat : public Aktion
+{
+private:
+    float value;
+
+public:
+    KonstantFloat( float val );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class KonstantVariable : public Aktion
+{
+private:
+    Text name;
+
+public:
+    KonstantVariable( Text name );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class Warten : public Aktion
+{
+public:
+    // zeit
+    Warten( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class WennDannSonst : public Aktion
+{
+public:
+    // wenn, dann, sonst
+    WennDannSonst( RCArray< Aktion > *subActions );
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SetVariable : public Aktion
+{
+private:
+    Text name;
+
+public:
+    // value
+    SetVariable( Text name, RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TriggerAktion : public Aktion
+{
+public:
+    // number, triggerName
+    TriggerAktion( RCArray< Aktion > *subActions );
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerNachricht : public Aktion
+{
+public:
+    // Spieler, Nachricht
+    SpielerNachricht( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DisplayText : public Aktion
+{
+public:
+    // x, y, color, dauer, nachricht
+    DisplayText( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielPause : public Aktion
+{
+public:
+    // paused
+    SpielPause( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielEnde : public Aktion
+{
+public:
+    // gewinner team
+    SpielEnde( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetLevel : public Aktion
+{
+public:
+    // level, spieler
+    SpielerSetLevel( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerGiveItem : public Aktion
+{
+public:
+    // item, anzahl, spieler
+    SpielerGiveItem( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerRemoveItem : public Aktion
+{
+public:
+    // item, anzahl, spieler
+    SpielerRemoveItem( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetLeben : public Aktion
+{
+public:
+    // leben, spieler
+    SpielerSetLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetMaxLeben : public Aktion
+{
+public:
+    // leben, spieler
+    SpielerSetMaxLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetErfahrung : public Aktion
+{
+public:
+    // erfahrung, spieler
+    SpielerSetErfahrung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetMaxErfahrung : public Aktion
+{
+public:
+    // erfahrung, spieler
+    SpielerSetMaxErfahrung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetTempo : public Aktion
+{
+public:
+    // tempo, spieler
+    SpielerSetTempo( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetWaffenTempo : public Aktion
+{
+public:
+    // tempo, spieler
+    SpielerSetWaffenTempo( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetArmor : public Aktion
+{
+public:
+    // armor, spieler
+    SpielerSetArmor( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetSchadenBonus : public Aktion
+{
+public:
+    // bonus, spieler
+    SpielerSetSchadenBonus( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetLebensraub : public Aktion
+{
+public:
+    // lebensrauf, spieler
+    SpielerSetLebensraub( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetLebensregeneration : public Aktion
+{
+public:
+    // regeneration, spieler
+    SpielerSetLebensregeneration( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerSetAbklingzeitverringerung : public Aktion
+{
+public:
+    // verringerung, spieler
+    SpielerSetAbklingzeitverringerung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropSetTime : public Aktion
+{
+public:
+    // time, drop
+    DropSetTime( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropSetMaxTime : public Aktion
+{
+public:
+    // time, drop
+    DropSetMaxTime( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropSetArea : public Aktion
+{
+public:
+    // minX, maxX, minY, maxY, drop
+    DropSetArea( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropDoDrop : public Aktion
+{
+public:
+    // drop
+    DropDoDrop( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereBewegung : public Aktion
+{
+public:
+    // bariere
+    BariereBewegung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereSetEingeschaltet : public Aktion
+{
+public:
+    // eingeschaltet, bariere
+    BariereSetEingeschaltet( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GameObjektSetPosition : public Aktion
+{
+public:
+    // x, y, objekt
+    GameObjektSetPosition( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GameObjektSetSize : public Aktion
+{
+public:
+    // x, y, objekt
+    GameObjektSetSize( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereSetTeam : public Aktion
+{
+public:
+    // team, bariere
+    BariereSetTeam( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SchalterSetErlaubt : public Aktion
+{
+public:
+    // erlaubt, schalter
+    SchalterSetErlaubt( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SchalterAktivieren : public Aktion
+{
+public:
+    // schalter
+    SchalterAktivieren( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TunnelSetZielPosition : public Aktion
+{
+public:
+    // x, y, tunnel
+    TunnelSetZielPosition( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TunnelSetErlaubt : public Aktion
+{
+public:
+    // erlaubt, tunnel
+    TunnelSetErlaubt( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class UmlenkungSetRichtung : public Aktion
+{
+public:
+    // richtung, umlenkung
+    UmlenkungSetRichtung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class UmlenkungSetMaxAbk : public Aktion
+{
+public:
+    // abk, umlenkung
+    UmlenkungSetMaxAbk( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class UmlenkungSetEnabled : public Aktion
+{
+public:
+    // enabled, umlenkung
+    UmlenkungSetEnabled( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BaseSetTeam : public Aktion
+{
+public:
+    // team, base
+    BaseSetTeam( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TriggerRunStart : public Aktion
+{
+public:
+    // trigger
+    TriggerRunStart( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TriggerSetEnabled : public Aktion
+{
+public:
+    // enabled, trigger
+    TriggerSetEnabled( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TeamSetPunkte : public Aktion
+{
+public:
+    // punkte, team
+    TeamSetPunkte( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerSetPause : public Aktion
+{
+public:
+    // pause, timer
+    TimerSetPause( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerStart : public Aktion
+{
+public:
+    // timer
+    TimerStart( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerSetZeit : public Aktion
+{
+public:
+    // zeit, timer
+    TimerSetZeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerSetSichtbar : public Aktion
+{
+public:
+    // sichtbar, timer
+    TimerSetSichtbar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossNeu : public Aktion
+{
+public:
+    // x, y, typ, richtung
+    GeschossNeu( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossSetSpeed : public Aktion
+{
+public:
+    // speed, geschoss
+    GeschossSetSpeed( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossSetPlayer : public Aktion
+{
+public:
+    // player, geschoss
+    GeschossSetPlayer( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossSetRichtung : public Aktion
+{
+public:
+    // richtung, geschoss
+    GeschossSetRichtung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossSetType : public Aktion
+{
+public:
+    // typ, geschoss
+    GeschossSetType( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TriggerZufall : public Aktion
+{
+public:
+    TriggerZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TriggerLastRunned : public Aktion
+{
+public:
+    TriggerLastRunned();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereZufall : public Aktion
+{
+public:
+    BariereZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereZuletztEingeschaltet : public Aktion
+{
+public:
+    BariereZuletztEingeschaltet();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereZuletztAusgeschaltet : public Aktion
+{
+public:
+    BariereZuletztAusgeschaltet();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BariereZuletztBewegt : public Aktion
+{
+public:
+    BariereZuletztBewegt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BaseZufall : public Aktion
+{
+public:
+    BaseZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BaseZuletztBesitzerGewechselt : public Aktion
+{
+public:
+    BaseZuletztBesitzerGewechselt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropZufall : public Aktion
+{
+public:
+    DropZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class DropZuletztGedropt : public Aktion
+{
+public:
+    DropZuletztGedropt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerRechnen : public Aktion
+{
+private:
+    Operator op;
+
+public:
+    // left, right
+    IntegerRechnen( RCArray< Aktion > *subActions, Operator op );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerZufall : public Aktion
+{
+public:
+    // min, max
+    IntegerZufall( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerAusText : public Aktion
+{
+public:
+    // text
+    IntegerAusText( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatXVonGameObjekt : public Aktion
+{
+public:
+    // objekt
+    FloatXVonGameObjekt( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatYVonGameObjekt : public Aktion
+{
+public:
+    // objekt
+    FloatYVonGameObjekt( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerXVonTunnelZiel : public Aktion
+{
+public:
+    // tunnel
+    IntegerXVonTunnelZiel( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerYVonTunnelZiel : public Aktion
+{
+public:
+    // tunnel
+    IntegerYVonTunnelZiel( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerMinXVonDrop : public Aktion
+{
+public:
+    // drop
+    IntegerMinXVonDrop( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerMinYVonDrop : public Aktion
+{
+public:
+    // drop
+    IntegerMinYVonDrop( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerMaxXVonDrop : public Aktion
+{
+public:
+    // drop
+    IntegerMaxXVonDrop( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerMaxYVonDrop : public Aktion
+{
+public:
+    // drop
+    IntegerMaxYVonDrop( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerLevel : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerLevel( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerLeben : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerMaxLeben : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerMaxLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerErfahrung : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerErfahrung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerMaxErfahrung : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerMaxErfahrung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerTempo : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerTempo( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerGeschossTempo : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerGeschossTempo( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerArmor : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerArmor( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerSchadenBonus : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerSchadenBonus( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerLebensraub : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerLebensraub( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerLebensregeneration : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerLebensregeneration( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerAbklingzeitVerringerung : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerAbklingzeitVerringerung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerTode : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerTode( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerKills : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerKills( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerTreffer : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerTreffer( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerGetroffen : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerGetroffen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerErlittenerSchaden : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerErlittenerSchaden( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerSchaden : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerSchaden( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatSpielerGeheiltesLeben : public Aktion
+{
+public:
+    // spieler
+    FloatSpielerGeheiltesLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsAufgehoben : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerItemsAufgehoben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsVerwendet : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerItemsVerwendet( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsInInventar : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerItemsInInventar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerItemsTypeInInventar : public Aktion
+{
+public:
+    // item, spieler
+    IntegerSpielerItemsTypeInInventar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerTunnelBenutzt : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerTunnelBenutzt( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerSchalterAktiviert : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerSchalterAktiviert( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSpielerGeschossen : public Aktion
+{
+public:
+    // spieler
+    IntegerSpielerGeschossen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatDropZeit : public Aktion
+{
+public:
+    // drop
+    FloatDropZeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerDropMaxZeit : public Aktion
+{
+public:
+    // drop
+    IntegerDropMaxZeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatGameObjektBreite : public Aktion
+{
+public:
+    // objekt
+    FloatGameObjektBreite( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatGameObjektHeight : public Aktion
+{
+public:
+    // objekt
+    FloatGameObjektHeight( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerBariereVerschiebungen : public Aktion
+{
+public:
+    // bariere
+    IntegerBariereVerschiebungen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerBariereSchaltungen : public Aktion
+{
+public:
+    // bariere
+    IntegerBariereSchaltungen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerSchalterAktivierungen : public Aktion
+{
+public:
+    // schalter
+    IntegerSchalterAktivierungen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTunnelBenutzungen : public Aktion
+{
+public:
+    // tunnel
+    IntegerTunnelBenutzungen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerUmlenkungBenutzungen : public Aktion
+{
+public:
+    // umlenkung
+    IntegerUmlenkungBenutzungen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTeamPunkte : public Aktion
+{
+public:
+    // team
+    IntegerTeamPunkte( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTeamKills : public Aktion
+{
+public:
+    // team
+    IntegerTeamKills( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTeamTode : public Aktion
+{
+public:
+    // team
+    IntegerTeamTode( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatTeamWiederbelegungszeit : public Aktion
+{
+public:
+    // team
+    FloatTeamWiederbelegungszeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTeamSpieleranzahl : public Aktion
+{
+public:
+    // team
+    IntegerTeamSpieleranzahl( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatTimerAktuelleZeit : public Aktion
+{
+public:
+    // timer
+    FloatTimerAktuelleZeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTimerMaxZeit : public Aktion
+{
+public:
+    // timer
+    IntegerTimerMaxZeit( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerTriggerRunns : public Aktion
+{
+public:
+    // trigger
+    IntegerTriggerRunns( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class ItemSpielerInventar : public Aktion
+{
+public:
+    // index, spieler
+    ItemSpielerInventar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class ItemZuletztAufgehoben : public Aktion
+{
+public:
+    ItemZuletztAufgehoben();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class ItemZuletztAktiviert : public Aktion
+{
+public:
+    ItemZuletztAktiviert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class ItemZuletztGedropt : public Aktion
+{
+public:
+    ItemZuletztGedropt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class ItemZufall : public Aktion
+{
+public:
+    ItemZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZufall : public Aktion
+{
+public:
+    GeschossZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZuletztAbgefeuert : public Aktion
+{
+public:
+    GeschossZuletztAbgefeuert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZuletztUmgelenkt : public Aktion
+{
+public:
+    GeschossZuletztUmgelenkt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZuletztBarjereGetroffen : public Aktion
+{
+public:
+    GeschossZuletztBarjereGetroffen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZuletztTunnelBenutzt : public Aktion
+{
+public:
+    GeschossZuletztTunnelBenutzt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GeschossZuletztGeschossGetroffen : public Aktion
+{
+public:
+    GeschossZuletztGeschossGetroffen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class RichtungZufall : public Aktion
+{
+public:
+    RichtungZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class RichtungVonUmlenkung : public Aktion
+{
+public:
+    // umlenkung
+    RichtungVonUmlenkung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class RichtungVonGeschoss : public Aktion
+{
+public:
+    // geschoss
+    RichtungVonGeschoss( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SchalterZufall : public Aktion
+{
+public:
+    SchalterZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SchalterZuletztAktiviert : public Aktion
+{
+public:
+    SchalterZuletztAktiviert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZufall : public Aktion
+{
+public:
+    SpielerZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZufallAusTeam : public Aktion
+{
+public:
+    // team
+    SpielerZufallAusTeam( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztSchadenGemacht : public Aktion
+{
+public:
+    SpielerZuletztSchadenGemacht();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztSchadenGenommen : public Aktion
+{
+public:
+    SpielerZuletztSchadenGenommen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztGeheilt : public Aktion
+{
+public:
+    SpielerZuletztGeheilt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztLevelUp : public Aktion
+{
+public:
+    SpielerZuletztLevelUp();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztErfahrungBekommen : public Aktion
+{
+public:
+    SpielerZuletztErfahrungBekommen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztGegenstandAktiviert : public Aktion
+{
+public:
+    SpielerZuletztGegenstandAktiviert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztGegenstandAufgehoben : public Aktion
+{
+public:
+    SpielerZuletztGegenstandAufgehoben();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztSchalterAktiviert : public Aktion
+{
+public:
+    SpielerZuletztSchalterAktiviert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztTunnelBenutzt : public Aktion
+{
+public:
+    SpielerZuletztTunnelBenutzt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztGestorben : public Aktion
+{
+public:
+    SpielerZuletztGestorben();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztWiederbelebent : public Aktion
+{
+public:
+    SpielerZuletztWiederbelebent();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class SpielerZuletztGeschossGeschossen : public Aktion
+{
+public:
+    SpielerZuletztGeschossGeschossen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextConcat : public Aktion
+{
+public:
+    // t1, t2
+    TextConcat( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextAusInteger : public Aktion
+{
+public:
+    // integer
+    TextAusInteger( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextAusRichtung : public Aktion
+{
+public:
+    // richtung
+    TextAusRichtung( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextAusBoolean : public Aktion
+{
+public:
+    // boolean
+    TextAusBoolean( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextSpielerName : public Aktion
+{
+public:
+    // spieler
+    TextSpielerName( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextItemName : public Aktion
+{
+public:
+    // item
+    TextItemName( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextTriggerName : public Aktion
+{
+public:
+    // trigger
+    TextTriggerName( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextTeilVonText : public Aktion
+{
+public:
+    // start, ende, text
+    TextTeilVonText( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TeamZufall : public Aktion
+{
+public:
+    TeamZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TeamVonSpieler : public Aktion
+{
+public:
+    // spieler
+    TeamVonSpieler( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TeamVonBariere : public Aktion
+{
+public:
+    // bariere
+    TeamVonBariere( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerZufall : public Aktion
+{
+public:
+    TimerZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerZuletztAbgelaufen : public Aktion
+{
+public:
+    TimerZuletztAbgelaufen();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerZuletztGestartet : public Aktion
+{
+public:
+    TimerZuletztGestartet();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerZuletztPausiert : public Aktion
+{
+public:
+    TimerZuletztPausiert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TimerZuletztFortgesetzt : public Aktion
+{
+public:
+    TimerZuletztFortgesetzt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TunnelZufall : public Aktion
+{
+public:
+    TunnelZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TunnelZuletztBenutzt : public Aktion
+{
+public:
+    TunnelZuletztBenutzt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class UmlenkungZufall : public Aktion
+{
+public:
+    UmlenkungZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class UmlenkungZuletztBenutzt : public Aktion
+{
+public:
+    UmlenkungZuletztBenutzt();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanZufall : public Aktion
+{
+public:
+    BooleanZufall();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSpielPausiert : public Aktion
+{
+public:
+    BooleanSpielPausiert();
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSpielerAmLeben : public Aktion
+{
+public:
+    // spieler
+    BooleanSpielerAmLeben( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSpielerHatGegenstand : public Aktion
+{
+public:
+    // item, spieler
+    BooleanSpielerHatGegenstand( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSpielerIstVerwundbar : public Aktion
+{
+public:
+    // richtung, spieler
+    BooleanSpielerIstVerwundbar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSpielerKannItemBenutzen : public Aktion
+{
+public:
+    // item, spieler
+    BooleanSpielerKannItemBenutzen( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanUmlenkungHatAbk : public Aktion
+{
+public:
+    // umlenkung
+    BooleanUmlenkungHatAbk( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanUmlenkungIstDrehend : public Aktion
+{
+public:
+    // umlenkung
+    BooleanUmlenkungIstDrehend( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanBariereBewegtSich : public Aktion
+{
+public:
+    // bariere
+    BooleanBariereBewegtSich( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanBariereIstSchaltend : public Aktion
+{
+public:
+    // bariere
+    BooleanBariereIstSchaltend( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanBariereIstAktiv : public Aktion
+{
+public:
+    // bariere
+    BooleanBariereIstAktiv( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanSchalterIstAktiv : public Aktion
+{
+public:
+    // schalter
+    BooleanSchalterIstAktiv( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanTunnelIstAktiv : public Aktion
+{
+public:
+    // tunnel
+    BooleanTunnelIstAktiv( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanBaseIstNeutral : public Aktion
+{
+public:
+    // base
+    BooleanBaseIstNeutral( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanTimerIsRunning : public Aktion
+{
+public:
+    BooleanTimerIsRunning( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanTimerIstSichtbar : public Aktion
+{
+public:
+    // timer
+    BooleanTimerIstSichtbar( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanAusText : public Aktion
+{
+public:
+    // text
+    BooleanAusText( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanTriggerIstAktiv : public Aktion
+{
+public:
+    // trigger
+    BooleanTriggerIstAktiv( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class BooleanRechnung : public Aktion
+{
+private:
+    Operator op;
+
+public:
+    // v1, v2
+    BooleanRechnung( RCArray< Aktion > *subActions, Operator op );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class Sequenz : public Aktion
+{
+public:
+    Sequenz( RCArray< Aktion > *aktions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatRechnung : public Aktion
+{
+private:
+    Operator op;
+
+public:
+    // left, right
+    FloatRechnung( RCArray< Aktion > *subActions, Operator op );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatAusInteger : public Aktion
+{
+public:
+    // integer
+    FloatAusInteger( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatAusText : public Aktion
+{
+public:
+    // text
+    FloatAusText( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextAusFloat : public Aktion
+{
+public:
+    // f
+    TextAusFloat( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatZufall : public Aktion
+{
+public:
+    // min, max
+    FloatZufall( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerAusFloat : public Aktion
+{
+public:
+    // f
+    IntegerAusFloat( RCArray< Aktion > *subActions );
+    void run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};

StickmanWorldOnline/Bariere.cpp

@@ -0,0 +1,157 @@
+#include "Bariere.h"
+#include "Spiel.h"
+#include "Ereignis.h"
+
+
+Bariere::Bariere( int id, int x, int y, int breite, int height, int style, int verschiebungWeite, int autoSchaltungMaxTime, Team *team )
+    : GameObject( BARIERE, x, y, breite, height )
+{
+    this->id = id;
+    this->style = style;
+    this->autoSchaltungMaxTime = autoSchaltungMaxTime;
+    autoSchaltungCurrentTime = (float)autoSchaltungMaxTime;
+    this->verschiebungWeite = verschiebungWeite;
+    currentWeite = 0;
+    verschiebungAnzahl = 0;
+    schaltungAnzahl = 0;
+    this->team = team;
+}
+
+Bariere::~Bariere()
+{
+    if( team )
+        team->release();
+}
+
+void Bariere::setStyle( int style, bool add, Spiel *zSpiel )
+{
+    if( add )
+    {
+        if( ( style | Style::Aktiv ) == style && ( this->style | Style::Aktiv ) != this->style )
+            zSpiel->setZuletztEingeschalteteBariere( (Bariere *)getThis() );
+        this->style |= style;
+    }
+    else
+    {
+        if( ( style | Style::Aktiv ) == style && ( this->style | Style::Aktiv ) == this->style )
+            zSpiel->setZuletztAusgeschalteteBariere( (Bariere *)getThis() );
+        this->style &= ~style;
+    }
+}
+
+void Bariere::setAutoVerschiebungWeite( int pixel )
+{
+    autoSchaltungMaxTime = pixel;
+}
+
+void Bariere::startAutoVerschiebung( Spiel *zSpiel )
+{
+    if( !hatStyle( Style::AutoVerschiebung ) || hatStyle( Style::InVerschiebung ) )
+        return;
+    zSpiel->setZuletztBewegteBariere( (Bariere *)getThis() );
+    currentWeite = 0;
+    setStyle( Style::InVerschiebung, 1, zSpiel );
+    Ereignis *e = new Ereignis( BARIERE_WIRD_VERSCHOBEN );
+    e->addParameter( "Betroffene Bariere", getThis() );
+    e->addParameter( "Status", new String( "Start" ) );
+    zSpiel->throwEvent( e );
+}
+
+void Bariere::setAutoSchaltungMaxTime( int seconds )
+{
+    autoSchaltungMaxTime = seconds;
+}
+
+void Bariere::startAutoSchaltung( Spiel *zSpiel )
+{
+    if( !hatStyle( Style::AutoSchaltung ) || hatStyle( Style::InSchaltung ) )
+        return;
+    autoSchaltungCurrentTime = (float)autoSchaltungMaxTime;
+    setStyle( Style::InSchaltung, 1, zSpiel );
+}
+
+void Bariere::setTeam( Team *team )
+{
+    if( this->team )
+        this->team->release();
+    this->team = team;
+}
+
+void Bariere::tick( double time, Spiel *zSpiel )
+{
+    if( hatStyle( Style::InSchaltung ) )
+    {
+        autoSchaltungCurrentTime -= (float)time;
+        if( autoSchaltungCurrentTime < 0 )
+        {
+            setStyle( Style::InSchaltung, 0, zSpiel );
+            setStyle( Style::Aktiv, !hatStyle( Style::Aktiv ), zSpiel );
+            schaltungAnzahl++;
+            Ereignis *e = new Ereignis( BARIERE_SWITCHED );
+            e->addParameter( "Betroffene Bariere", getThis() );
+            zSpiel->throwEvent( e );
+        }
+    }
+    if( hatStyle( Style::InVerschiebung ) )
+    {
+        float last = currentWeite;
+        currentWeite += (float)time * 10;
+        if( currentWeite >= verschiebungWeite )
+        {
+            currentWeite = (float)verschiebungWeite;
+            setStyle( Style::InVerschiebung, 0, zSpiel );
+            setStyle( Style::NextVerschiebungLinksOben, !hatStyle( Style::NextVerschiebungLinksOben ), zSpiel );
+            verschiebungAnzahl++;
+            Ereignis *e = new Ereignis( BARIERE_WIRD_VERSCHOBEN );
+            e->addParameter( "Betroffene Bariere", getThis() );
+            e->addParameter( "Status", new String( "Feritg" ) );
+            zSpiel->throwEvent( e );
+        }
+        if( hatStyle( Style::VerschiebungWaagerecht ) )
+        {
+            if( hatStyle( Style::NextVerschiebungLinksOben ) )
+                setX( getX() + last - currentWeite );
+            else
+                setX( getX() - last + currentWeite );
+        }
+        else
+        {
+            if( hatStyle( Style::NextVerschiebungLinksOben ) )
+                setY( getX() + last - currentWeite );
+            else
+                setY( getX() - last + currentWeite );
+        }
+    }
+}
+
+bool Bariere::hatStyle( int style ) const
+{
+    return ( this->style | style ) == this->style;
+}
+
+int Bariere::getVerschiebungAnzahl() const
+{
+    return verschiebungAnzahl;
+}
+
+int Bariere::getSchaltungAnzahl() const
+{
+    return schaltungAnzahl;
+}
+
+int Bariere::getId() const
+{
+    return id;
+}
+
+Team *Bariere::getTeam() const
+{
+    if( !team )
+        return 0;
+    return (Team *)team->getThis();
+}
+
+Team *Bariere::zTeam() const
+{
+    return team;
+}

StickmanWorldOnline/Bariere.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "GameObject.h"
+#include "Team.h"
+#include "Timer.h"
+
+class Spiel;
+
+class Bariere : public GameObject
+{
+public:
+    class Style
+    {
+    public:
+        const static int AutoSchaltung = 0x1;
+        const static int AutoVerschiebung = 0x2;
+        const static int InSchaltung = 0x4;
+        const static int InVerschiebung = 0x8;
+        const static int VerschiebungWaagerecht = 0x10;
+        const static int NextVerschiebungLinksOben = 0x20;
+        const static int Aktiv = 0x40;
+    };
+private:
+    int style;
+    int autoSchaltungMaxTime;
+    float autoSchaltungCurrentTime;
+    int verschiebungWeite;
+    float currentWeite;
+    int verschiebungAnzahl;
+    int schaltungAnzahl;
+    int id;
+    Team *team;
+
+public:
+    Bariere( int id, int x, int y, int breite, int height, int style, int verschiebungWeite = 0, int autoSchaltungMaxTime = 0, Team * team = 0 );
+    ~Bariere();
+    void setStyle( int style, bool add, Spiel *zSpiel );
+    void setAutoVerschiebungWeite( int pixel );
+    void startAutoVerschiebung( Spiel *zSpiel );
+    void setAutoSchaltungMaxTime( int seconds );
+    void startAutoSchaltung( Spiel *zSpiel );
+    void setTeam( Team *team );
+    void tick( double time, Spiel *zSpiel );
+    bool hatStyle( int style ) const;
+    int getVerschiebungAnzahl() const;
+    int getSchaltungAnzahl() const;
+    int getId() const;
+    Team *getTeam() const;
+    Team *zTeam() const;
+};

StickmanWorldOnline/Base.cpp

@@ -0,0 +1,93 @@
+#include "Base.h"
+#include "Spiel.h"
+#include "Ereignis.h"
+
+
+Base::Base( int id, int x, int y, int width, int height, int maxTime, Team *team )
+    : GameObject( BASE, x, y, width, height )
+{
+    this->id = id;
+    this->maxTime = maxTime;
+    this->team = team;
+    inChange = 0;
+    nextTeam = 0;
+    leftTime = (float)maxTime;
+}
+
+Base::~Base()
+{
+    if( team )
+        team->release();
+    if( nextTeam )
+        nextTeam->release();
+}
+
+void Base::setTeam( Team *team, Spiel *zSpiel )
+{
+    if( this->team )
+        this->team->release();
+    this->team = team;
+    zSpiel->setLastTeamChangedBase( (Base *)getThis() );
+}
+
+void Base::startChange( Team *team )
+{
+    if( team == this->team )
+    {
+        inChange = 0;
+        if( nextTeam )
+            nextTeam = (Team *)nextTeam->release();
+        team->release();
+        return;
+    }
+    else if( this->team )
+    {
+        if( nextTeam )
+            nextTeam = (Team *)nextTeam->release();
+        leftTime = (float)maxTime;
+        inChange = 1;
+        team->release();
+    }
+    else
+    {
+        if( nextTeam )
+            nextTeam = (Team *)nextTeam->release();
+        nextTeam = team;
+        leftTime = (float)maxTime;
+        inChange = 1;
+    }
+}
+
+void Base::tick( double time, Spiel *zSpiel )
+{
+    if( inChange )
+    {
+        leftTime -= (float)time;
+        if( leftTime <= 0 )
+        {
+            Ereignis *e = new Ereignis( BASIS_BESITZERWECHSEL );
+            e->addParameter( "Betroffene Basis", getThis() );
+            e->addParameter( "Vorheriges Team", team ? team->getThis() : new Variable( NICHTS ) );
+            e->addParameter( "Nächstes Team", nextTeam ? nextTeam->getThis() : new Variable( NICHTS ) );
+            zSpiel->throwEvent( e );
+            this->team->release();
+            this->team = nextTeam;
+            inChange = 0;
+        }
+    }
+}
+
+int Base::getId() const
+{
+    return id;
+}
+
+Team *Base::getTeam() const
+{
+    return team ? (Team *)team->getThis() : 0;
+}
+
+Team *Base::zTeam() const
+{
+    return team;
+}

StickmanWorldOnline/Base.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "GameObject.h"
+#include "Team.h"
+
+class Spiel;
+
+class Base : public GameObject
+{
+private:
+    int id;
+    Team *team;
+    int maxTime;
+    bool inChange;
+    Team *nextTeam;
+    float leftTime;
+
+public:
+    Base( int id, int x, int y, int width, int height, int maxTime = 10, Team * team = 0 );
+    ~Base();
+    void setTeam( Team *team, Spiel *zSpiel );
+    void startChange( Team *team );
+    void tick( double time, Spiel *zSpiel );
+    int getId() const;
+    Team *getTeam() const;
+    Team *zTeam() const;
+};

StickmanWorldOnline/BosheitRune.cpp

@@ -0,0 +1,16 @@
+#include "BosheitRune.h"
+#include "Spieler.h"
+
+
+BosheitRuneEffect::BosheitRuneEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() + 7 );
+    zSpieler->setLebensRaub( zSpieler->getLebensRaub() + 3 );
+}
+
+BosheitRuneEffect::~BosheitRuneEffect()
+{
+    zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() - 7 );
+    zSpieler->setLebensRaub( zSpieler->getLebensRaub() - 3 );
+}

StickmanWorldOnline/BosheitRune.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Effect.h"
+
+class BosheitRuneEffect : public Effect
+{
+private:
+
+public:
+    BosheitRuneEffect( Spieler *zSpieler );
+    ~BosheitRuneEffect();
+};

StickmanWorldOnline/Brand.cpp

@@ -0,0 +1,23 @@
+#include "Brand.h"
+#include "Spieler.h"
+
+
+BrandEffekt::BrandEffekt( Spieler *zVerursacher, Spieler *zOpfer )
+    : Effect( zOpfer, B_DURATION )
+{
+    this->zVerursacher = zVerursacher;
+    laufTempoDecrease = B_MOVEMENT_DECREASE <= zSpieler->getLaufTempo() ? B_MOVEMENT_DECREASE : zSpieler->getLaufTempo();
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() - laufTempoDecrease );
+}
+
+BrandEffekt::~BrandEffekt()
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() + laufTempoDecrease );
+}
+
+bool BrandEffekt::tick( double time, Spiel *zSpiel )
+{
+    float damage = B_MIN_DPS * (float)time;
+    zSpieler->nimmSchaden( damage, zVerursacher, MITTE, zSpiel );
+    return Effect::tick( time, zSpiel );
+}

StickmanWorldOnline/Brand.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Effect.h"
+
+#define B_MOVEMENT_DECREASE 1
+#define B_MIN_DPS 5
+#define B_DURATION 1
+
+class BrandEffekt : public Effect
+{
+private:
+    Spieler *zVerursacher;
+    float laufTempoDecrease;
+
+public:
+    BrandEffekt( Spieler *zVerursacher, Spieler *zOpfer );
+    ~BrandEffekt();
+    bool tick( double time, Spiel *zSpiel ) override;
+};

StickmanWorldOnline/DLLStart.cpp

@@ -1,4 +1,4 @@
-#include "SpielKlasse.h"
+#include "Spiel.h"
 #include "SpielStatistik.h"
 #include "HistorieStatistik.h"
 #include "../../../../Klient/Include/AufzeichnungV.h"
@@ -9,7 +9,7 @@ extern "C"
 { // Dll Einstiegs Funktionen
 	__declspec( dllexport ) SpielV *getSpielKlasse()
 	{
-		return new SpielKlasse();
+		return new Spiel();
 	}
 
 	__declspec( dllexport ) SpielStatistikV *GetStatistikKlasse()

StickmanWorldOnline/DrachenAuge.cpp

@@ -0,0 +1,25 @@
+#include "DrachenAuge.h"
+#include "Spieler.h"
+
+
+DrachenAugeEffect::DrachenAugeEffect( Spieler *zVerursacher, Spieler *zOpfer )
+    : Effect( zOpfer, DA_DURATION )
+{
+    this->zVerursacher = zVerursacher;
+    laufTempoDecrease = DA_MOVEMENT_DECREASE <= zSpieler->getLaufTempo() ? DA_MOVEMENT_DECREASE : zSpieler->getLaufTempo();
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() - laufTempoDecrease );
+}
+
+DrachenAugeEffect::~DrachenAugeEffect()
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() + laufTempoDecrease );
+}
+
+bool DrachenAugeEffect::tick( double time, Spiel *zSpiel )
+{
+    float damage = DA_MIN_DPS * (float)time;
+    zSpieler->nimmSchaden( damage, zVerursacher, MITTE, zSpiel );
+    if( zVerursacher )
+        zVerursacher->heilung( DA_HEALPS * (float)time, zSpiel );
+    return Effect::tick( time, zSpiel );
+}

StickmanWorldOnline/DrachenAuge.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "Effect.h"
+
+#define DA_MOVEMENT_DECREASE 10
+#define DA_MIN_DPS 10
+#define DA_DURATION 10
+#define DA_HEALPS 4
+
+class DrachenAugeEffect : public Effect
+{
+private:
+    Spieler *zVerursacher;
+    float laufTempoDecrease;
+
+public:
+    DrachenAugeEffect( Spieler *zVerursacher, Spieler *zOpfer );
+    ~DrachenAugeEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+};

StickmanWorldOnline/Drop.cpp

@@ -0,0 +1,122 @@
+#include "Drop.h"
+#include "Spiel.h"
+#include "Ereignis.h"
+
+Drop::Drop( int id, int minX, int maxX, int minY, int maxY, int maxTime, int numDrops, const char *name, float wkeit[ ITEMANZAHL ] )
+    : Variable( DROP )
+{
+    this->id = id;
+    this->name = name;
+    this->minX = minX;
+    this->maxX = maxX;
+    this->minY = minY;
+    this->maxY = maxY;
+    this->maxTime = maxTime;
+    this->nextDrop = (float)maxTime;
+    this->numDrops = numDrops;
+    memcpy( wahrscheinlichkeit, wkeit, sizeof( float ) * ITEMANZAHL );
+}
+
+Drop::~Drop()
+{}
+
+void Drop::setMinX( int x )
+{
+    minX = x;
+}
+
+void Drop::setMaxX( int x )
+{
+    maxX = x;
+}
+
+void Drop::setMinY( int y )
+{
+    minY = y;
+}
+
+void Drop::setMaxY( int y )
+{
+    maxY = y;
+}
+
+void Drop::setMaxTime( int seconds )
+{
+    maxTime = seconds;
+}
+
+void Drop::setTime( float time )
+{
+    this->nextDrop = time;
+}
+
+void Drop::doDrop( Spiel *zSpiel )
+{
+    zSpiel->setLastDrop( (Drop *)getThis() );
+    nextDrop = (float)maxTime;
+    for( int i = 0; i < numDrops; i++ )
+    {
+        double p = zSpiel->getRand();
+        int typ = 0;
+        for( ; typ < ITEMANZAHL; typ++ )
+        {
+            if( p <= wahrscheinlichkeit[ typ ] )
+                break;
+            p -= wahrscheinlichkeit[ typ ];
+        }
+        int x = (int)( zSpiel->getRand() * ( maxX - minX - 100 ) + minX + 50 );
+        int y = (int)( zSpiel->getRand() * ( maxY - minY - 100 ) + minY + 50 );
+        if( x >= minX + 50 && x < maxX - 50 && y >= minY + 50 && y < maxY - 50 )
+            zSpiel->addGegenstand( new Gegenstand( zSpiel->getNextId(), (GegenstandTyp)typ, x, y ) );
+    }
+    Ereignis *e = new Ereignis( DROP_AKTION );
+    e->addParameter( "Betroffener Drop", getThis() );
+    zSpiel->throwEvent( e );
+}
+
+void Drop::tick( double time, Spiel *zSpiel )
+{
+    nextDrop -= (float)time;
+    if( nextDrop <= 0 )
+        doDrop( zSpiel );
+}
+
+int Drop::getNumDrops() const
+{
+    return numDrops;
+}
+
+int Drop::getMinX() const
+{
+    return minX;
+}
+
+int Drop::getMaxX() const
+{
+    return maxX;
+}
+
+int Drop::getMinY() const
+{
+    return minY;
+}
+
+int Drop::getMaxY() const
+{
+    return maxY;
+}
+
+float Drop::getZeit() const
+{
+    return nextDrop;
+}
+
+int Drop::getMaxTime() const
+{
+    return maxTime;
+}
+
+int Drop::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Drop.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "Variablen.h"
+#include "Gegenstand.h"
+
+class Spiel;
+
+class Drop : public Variable
+{
+private:
+    Text name;
+    int minX;
+    int maxX;
+    int minY;
+    int maxY;
+    int maxTime;
+    float nextDrop;
+    int numDrops;
+    float wahrscheinlichkeit[ ITEMANZAHL ];
+    int id;
+
+public:
+    Drop( int id, int minX, int maxX, int minY, int maxY, int maxTime, int numDrops, const char *name, float wkeit[ ITEMANZAHL ] );
+    ~Drop();
+    void setMinX( int x );
+    void setMaxX( int x );
+    void setMinY( int y );
+    void setMaxY( int y );
+    void setMaxTime( int seconds );
+    void setTime( float time );
+    void doDrop( Spiel *zSpiel );
+    void tick( double time, Spiel *zSpiel );
+    int getNumDrops() const;
+    int getMinX() const;
+    int getMaxX() const;
+    int getMinY() const;
+    int getMaxY() const;
+    float getZeit() const;
+    int getMaxTime() const;
+    int getId() const;
+};

StickmanWorldOnline/Effect.cpp

@@ -0,0 +1,54 @@
+#include "Effect.h"
+
+
+Effect::Effect( Spieler *zSpieler, float maxTime )
+{
+    this->zSpieler = zSpieler;
+    timeLeft = maxTime;
+    ref = 1;
+}
+
+Effect::~Effect()
+{}
+
+bool Effect::tick( double time, Spiel *zSpiel )
+{
+    timeLeft -= (float)time;
+    return timeLeft <= 0;
+}
+
+bool Effect::istSpielerBeweglich( Richtung r )
+{
+    return 1;
+}
+
+bool Effect::istSpielerVerwundbar( Richtung r )
+{
+    return 1;
+}
+
+bool Effect::istSpielerSichtbar( Team *zTeam )
+{
+    return 1;
+}
+
+void Effect::move( double time )
+{}
+
+bool Effect::istGegenstandErlaubt( GegenstandTyp typ )
+{
+    return 1;
+}
+
+Effect *Effect::getThis()
+{
+    ref++;
+    return this;
+}
+
+Effect *Effect::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Effect.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "Gegenstand.h"
+
+class Spieler;
+class Spiel;
+class Team;
+
+class Effect
+{
+protected:
+    Spieler *zSpieler;
+    float timeLeft;
+    int ref;
+
+public:
+    Effect( Spieler *zSpieler, float maxTime );
+    virtual ~Effect();
+    virtual bool tick( double time, Spiel *zSpiel );
+    virtual bool istSpielerBeweglich( Richtung r );
+    virtual bool istSpielerVerwundbar( Richtung r );
+    virtual bool istSpielerSichtbar( Team *zTeam );
+    virtual void move( double time );
+    virtual bool istGegenstandErlaubt( GegenstandTyp typ );
+    Effect *getThis();
+    Effect *release();
+};

StickmanWorldOnline/Ende.cpp

@@ -0,0 +1,121 @@
+#include "Ende.h"
+#include <TextFeld.h>
+#include <Bild.h>
+#include <MausEreignis.h>
+#include <Rahmen.h>
+#include <Schrift.h>
+
+// Inhalt der Ende Klasse aus Ende.h
+// Konstruktor
+Ende::Ende( Schrift *zSchrift )
+{
+	rahmen = new LRahmen();
+	rahmen->setSize( 200, 100 );
+	rahmen->setRamenBreite( 2 );
+	rahmen->setFarbe( 0xFFFFFFFF );
+	text = new TextFeld();
+	text->setStyle( TextFeld::Style::Text | TextFeld::Style::Center );
+	text->setSchriftZ( zSchrift->getThis() );
+	text->setText( "" );
+	text->setSchriftFarbe( 0xFFFFFFFF );
+	text->setSize( 200, 50 );
+	warten = new TextFeld();
+	warten->setStyle( ( TextFeld::Style::Text | TextFeld::Style::Center ) & ~TextFeld::Style::Sichtbar );
+	warten->setSchriftZ( zSchrift->getThis() );
+	warten->setText( "Bitte warten..." );
+	warten->setSchriftFarbe( 0xFFFFFFFF );
+	warten->setSize( 200, 50 );
+	ok = new Knopf();
+	ok->setStyle( Knopf::Style::Normal );
+	ok->setSize( 100, 20 );
+	ok->setText( "Weiter" );
+	ok->setSchriftZ( zSchrift->getThis() );
+	weiter = 0;
+	ref = 1;
+}
+
+// Destruktor
+Ende::~Ende()
+{
+	rahmen->release();
+	text->release();
+	warten->release();
+	ok->release();
+}
+
+// nicht constant
+void Ende::setGewonnen( char gewonnen )
+{
+	if( gewonnen == 1 )
+	{
+		text->setText( "Du hast gewonnen." );
+		text->setSchriftFarbe( 0xFF00FF00 );
+	}
+	else if( !gewonnen )
+	{
+		text->setText( "Du hast verloren." );
+		text->setSchriftFarbe( 0xFFFF0000 );
+	}
+	else
+	{
+		text->setText( "Unentschieden." );
+		text->setSchriftFarbe( 0xFFFFFFFF );
+	}
+}
+
+void Ende::doTastaturEreignis( TastaturEreignis &te )
+{
+    if( te.taste == T_Enter && te.id == TE_Release )
+    {
+        ok->removeStyle( Knopf::Style::Sichtbar );
+        warten->addStyle( TextFeld::Style::Sichtbar );
+        weiter = 1;
+    }
+}
+
+void Ende::doPublicMausEreignis( MausEreignis &me )
+{
+	bool vera = me.verarbeitet;
+	ok->doPublicMausEreignis( me );
+	if( !vera && me.verarbeitet && me.id == ME_RLinks )
+	{
+		ok->removeStyle( Knopf::Style::Sichtbar );
+		warten->addStyle( TextFeld::Style::Sichtbar );
+		weiter = 1;
+	}
+	me.verarbeitet = 1;
+}
+
+void Ende::render( Bild &zRObj )
+{
+	rahmen->setPosition( zRObj.getBreite() / 2 - rahmen->getBreite() / 2, zRObj.getHeight() / 2 - rahmen->getHeight() / 2 );
+	zRObj.alphaRegion( rahmen->getX(), rahmen->getY(), rahmen->getBreite(), rahmen->getHeight(), 0xA0000000 );
+	rahmen->render( zRObj );
+	text->setPosition( rahmen->getX(), rahmen->getY() );
+	text->render( zRObj );
+	warten->setPosition( rahmen->getX(), rahmen->getY() + 50 );
+	warten->render( zRObj );
+	ok->setPosition( rahmen->getX() + rahmen->getBreite() / 2 - ok->getBreite() / 2, rahmen->getY() + 65 );
+	ok->render( zRObj );
+}
+
+// constant
+bool Ende::getWeiter() const
+{
+	return weiter;
+}
+
+// Reference Counting
+Ende *Ende::getThis()
+{
+	ref++;
+	return this;
+}
+
+Ende *Ende::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

StickmanWorldOnline/Ende.h

@@ -0,0 +1,36 @@
+#ifndef Ende_H
+#define Ende_H
+
+#include <Knopf.h>
+#include <Rahmen.h>
+
+using namespace Framework;
+
+class Ende
+{
+private:
+	LRahmen *rahmen;
+	TextFeld *text;
+	TextFeld *warten;
+	Knopf *ok;
+	bool weiter;
+	int ref;
+
+public:
+	// Konstruktor
+	Ende( Schrift *zSchrift );
+	// Destruktor
+	~Ende();
+	// nicht constant
+	void setGewonnen( char gewonnen );
+    void doTastaturEreignis( TastaturEreignis &te );
+	void doPublicMausEreignis( MausEreignis &me );
+	void render( Bild &zRObj );
+	// constant
+	bool getWeiter() const;
+	// Reference Counting
+	Ende *getThis();
+	Ende *release();
+};
+
+#endif

StickmanWorldOnline/Enterhaken.cpp

@@ -0,0 +1,165 @@
+#include "Enterhaken.h"
+#include "Spieler.h"
+#include "Spiel.h"
+
+EnterhakenEffect::EnterhakenEffect( Spieler *zSpieler, Richtung r )
+    : Effect( zSpieler, 1.5f + ( 1.5f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    maxTime = timeLeft;
+    state = 0;
+    ehpx = zSpieler->getX() + zSpieler->getWidth() / 2;
+    ehpy = zSpieler->getY() + zSpieler->getHeight() / 2;
+}
+
+EnterhakenEffect::~EnterhakenEffect()
+{}
+
+bool EnterhakenEffect::istSpielerBeweglich( Richtung r )
+{
+    return 0;
+}
+
+void EnterhakenEffect::move( double time )
+{
+    if( time < 0 )
+        return;
+    if( state == 3 || state == 4 )
+    {
+        switch( r )
+        {
+        case OBEN:
+            zSpieler->setY( zSpieler->getY() - 200 * (float)time );
+            if( zSpieler->getY() <= ehpy - 10 )
+                state = 4;
+            break;
+        case LINKS:
+            zSpieler->setX( zSpieler->getX() - 200 * (float)time );
+            if( zSpieler->getX() <= ehpx - 10 )
+                state = 4;
+            break;
+        case UNTEN:
+            zSpieler->setY( zSpieler->getY() + 200 * (float)time );
+            if( zSpieler->getY() >= ehpy - 10 )
+                state = 4;
+            break;
+        case RECHTS:
+            zSpieler->setX( zSpieler->getX() + 200 * (float)time );
+            if( zSpieler->getX() >= ehpx - 10 )
+                state = 4;
+            break;
+        default:
+            break;
+        }
+        if( state == 4 )
+        {
+            if( !target->hatStyle( Bariere::Style::Aktiv ) || !target->intersectsWith( zSpieler ) )
+                state = 5;
+        }
+    }
+}
+
+bool EnterhakenEffect::tick( double time, Spiel *zSpiel )
+{
+    switch( state )
+    {
+    case 0:
+        switch( r )
+        {
+        case OBEN:
+            ehpy -= 200 * (float)time;
+            break;
+        case LINKS:
+            ehpx -= 200 * (float)time;
+            break;
+        case UNTEN:
+            ehpy += 200 * (float)time;
+            break;
+        case RECHTS:
+            ehpx += 200 * (float)time;
+            break;
+        default:
+            break;
+        }
+        timeLeft -= (float)time;
+        if( timeLeft <= 0 )
+        {
+            state = 1;
+            timeLeft = maxTime;
+        }
+        for( auto s = zSpiel->getSpieler(); s; s++ )
+        {
+            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 10 && s->getX() + s->getWidth() > ehpx + 10 && s->getY() <= ehpy - 10 && s->getY() + s->getWidth() > ehpy + 10 )
+                s->nimmSchaden( 150 * (float)time, zSpieler, r, zSpiel );
+        }
+        for( auto b = zSpiel->getBarieren(); b; b++ )
+        {
+            if( b->hatStyle( Bariere::Style::Aktiv ) && ( !b->zTeam() || b->zTeam() == zSpieler->zTeam() ) )
+            {
+                if( b->getX() <= ehpx - 10 && b->getX() + b->getWidth() > ehpx + 10 && b->getY() <= ehpy - 10 && b->getY() + b->getWidth() > ehpy + 10 )
+                {
+                    target = b;
+                    state = 2;
+                }
+            }
+        }
+        break;
+    case 1:
+        switch( r )
+        {
+        case OBEN:
+            ehpy += 200 * (float)time;
+            break;
+        case LINKS:
+            ehpx += 200 * (float)time;
+            break;
+        case UNTEN:
+            ehpy -= 200 * (float)time;
+            break;
+        case RECHTS:
+            ehpx -= 200 * (float)time;
+            break;
+        default:
+            break;
+        }
+        for( auto s = zSpiel->getSpieler(); s; s++ )
+        {
+            if( s->zTeam() != zSpieler->zTeam() && s->getX() <= ehpx - 10 && s->getX() + s->getWidth() > ehpx + 10 && s->getY() <= ehpy - 10 && s->getY() + s->getWidth() > ehpy + 10 )
+                s->nimmSchaden( 150 * (float)time, zSpieler, invert( r ), zSpiel );
+        }
+        timeLeft -= (float)time;
+        if( timeLeft <= 0 )
+            return 1;
+        break;
+    case 2:
+        switch( r )
+        {
+        case OBEN:
+            ehpy -= 200 * (float)time;
+            break;
+        case LINKS:
+            ehpx -= 200 * (float)time;
+            break;
+        case UNTEN:
+            ehpy += 200 * (float)time;
+            break;
+        case RECHTS:
+            ehpx += 200 * (float)time;
+            break;
+        default:
+            break;
+        }
+        if( !target->hatStyle( Bariere::Style::Aktiv ) || target->getX() > ehpx - 10 || target->getX() + target->getWidth() <= ehpx + 10 || target->getY() > ehpy - 10 || target->getY() + target->getWidth() <= ehpy + 10 )
+            state = 3;
+    }
+    return state != 5;
+}
+
+bool EnterhakenEffect::istGegenstandErlaubt( GegenstandTyp typ )
+{
+    return typ != STURM && typ != ROLLE;
+}
+
+bool EnterhakenEffect::istSpielerVerwundbar( Richtung r )
+{
+    return r != MITTE;
+}

StickmanWorldOnline/Enterhaken.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "Effect.h"
+#include "Bariere.h"
+
+
+class EnterhakenEffect : public Effect
+{
+private:
+    float ehpx;
+    float ehpy;
+    int state;
+    float maxTime;
+    Richtung r;
+    Bariere *target;
+
+public:
+    EnterhakenEffect( Spieler *zSpieler, Richtung r );
+    ~EnterhakenEffect();
+    bool istSpielerBeweglich( Richtung r ) override;
+    void move( double time ) override;
+    bool tick( double time, Spiel *zSpiel ) override;
+    bool istGegenstandErlaubt( GegenstandTyp typ ) override;
+    bool istSpielerVerwundbar( Richtung r ) override;
+};

StickmanWorldOnline/Ereignis.cpp

@@ -0,0 +1,54 @@
+#include "Ereignis.h"
+#include "Trigger.h"
+
+Ereignis::Ereignis( EreignisTyp typ )
+{
+    this->typ = typ;
+    ref = 1;
+}
+
+Ereignis::~Ereignis()
+{}
+
+EreignisTyp Ereignis::getTyp() const
+{
+    return typ;
+}
+
+void Ereignis::addParameter( const char *name, Variable *var )
+{
+    params.add( new VarPointer( name, var ) );
+}
+
+Variable *Ereignis::getParameter( const char *name ) const
+{
+    for( auto v = params.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->getVariable();
+    }
+    return 0;
+}
+
+Variable *Ereignis::zParameter( const char *name ) const
+{
+    for( auto v = params.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->zVariable();
+    }
+    return 0;
+}
+
+Ereignis *Ereignis::getThis()
+{
+    ref++;
+    return this;
+}
+
+Ereignis *Ereignis::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Ereignis.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <Array.h>
+#include "Variablen.h"
+
+class VarPointer;
+
+enum EreignisTyp
+{
+    AUSLOESER_RUNNED, // "Betroffener Auslöser"
+    BARIERE_SWITCHED, // "Betroffene Bariere"
+    BARIERE_WIRD_VERSCHOBEN, // "Betroffene Bariere", "Status"
+    BASIS_BESITZERWECHSEL, // "Betroffene Basis", "Vorheriges Team", "Nächstes Team"
+    DROP_AKTION, // "Betroffener Drop"
+    GEGENSTAND_DROPED, // "Betroffener Gegenstand"
+    INITIALISIERUNG, //
+    SCHALTER_AKTIVIERT, // "Betroffener Schalter"
+    SPIELER_BENUTZT_GEGENSTAND, // "Betroffener Spieler", "Betroffener Gegenstand"
+    SPIELER_KEY_PRESSED, // "Betroffene Taste", "Ausführender Spieler"
+    SPIELER_BEKOMMT_ERFAHRUNG, // "Betroffer Spieler", "Wert"
+    SPIELER_BEKOMMT_GEGENSTAND, // "Betroffener Spieler", "Betroffener Gegenstand", "Anzahl"
+    SPIELER_KEY_RELEASED, // "Betroffene Taste", "Ausführender Spieler"
+    SPIELER_LEVEL_UP, // "Betroffer Spieler"
+    SPIELER_MACHT_SCHADEN, // "Betroffer Spieler", "Wert"
+    SPIELER_NIMMT_SCHADEN, // "Betroffer Spieler", "Wert"
+    SPIELER_STIRBT, // "Betroffer Spieler"
+    SPIELER_WIEDERBELEBT, // "Betroffer Spieler"
+    SPIELER_WIRD_GEHEILT, // "Betroffer Spieler", "Wert"
+    TIMER_RUNNS_OUT, // "Betroffener Timer"
+    TIMER_BEGINNT, // "Betroffener Timer"
+    TUNNEL_BENUTZT, // {"Betroffes Geschoss", "Betroffer Spieler"}, "Betroffer Tunnel"
+    UMLENKUNG_LENKT_UM // "Betroffes Geschoss", "Betroffe Umlenkung"
+};
+
+class Ereignis
+{
+private:
+    EreignisTyp typ;
+    RCArray< VarPointer > params;
+    int ref;
+
+public:
+    Ereignis( EreignisTyp typ );
+    ~Ereignis();
+    EreignisTyp getTyp() const;
+    void addParameter( const char *name, Variable *var );
+    Variable *getParameter( const char *name ) const;
+    Variable *zParameter( const char *name ) const;
+    Ereignis *getThis();
+    Ereignis *release();
+};

StickmanWorldOnline/GameObject.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "Variablen.h"
+
+class GameObject : public Variable
+{
+protected:
+    float x, y, w, h;
+
+public:
+    GameObject( VariableTyp typ, int x, int y, int width, int height );
+    void setX( float x );
+    void setY( float y );
+    void setWidth( float width );
+    void setHeight( float height );
+    bool intersectsWith( GameObject *zObj );
+    float getX() const;
+    float getY() const;
+    float getWidth() const;
+    float getHeight() const;
+    float abstandZu( GameObject *zObj );
+};

StickmanWorldOnline/GameObjekt.cpp

@@ -0,0 +1,62 @@
+#include "GameObject.h"
+#include "Punkt.h"
+
+
+GameObject::GameObject( VariableTyp typ, int x, int y, int width, int height )
+    : Variable( typ )
+{
+    this->x = (float)x;
+    this->y = (float)y;
+    w = (float)width;
+    h = (float)height;
+}
+
+void GameObject::setX( float x )
+{
+    this->x = x;
+}
+
+void GameObject::setY( float y )
+{
+    this->y = y;
+}
+
+void GameObject::setWidth( float width )
+{
+    w = width;
+}
+
+void GameObject::setHeight( float height )
+{
+    h = height;
+}
+
+bool GameObject::intersectsWith( GameObject *zObj )
+{
+    return x < zObj->x + zObj->w && x + w > zObj->x && y < zObj->y + zObj->h && y + h > zObj->y;
+}
+
+float GameObject::getX() const
+{
+    return x;
+}
+
+float GameObject::getY() const
+{
+    return y;
+}
+
+float GameObject::getWidth() const
+{
+    return w;
+}
+
+float GameObject::getHeight() const
+{
+    return h;
+}
+
+float GameObject::abstandZu( GameObject *zObj )
+{
+    return ( Vec2<float>( x + w / 2, y + h / 2 ) - Vec2<float>( zObj->x + zObj->w / 2, zObj->y + zObj->h / 2 ) ).getLength();
+}

StickmanWorldOnline/Gegenstand.cpp

@@ -0,0 +1,124 @@
+#include "Gegenstand.h"
+
+
+bool consumable( GegenstandTyp typ )
+{
+    switch( typ )
+    {
+    case PFEIL:
+        return 1;
+    case LEBEN:
+        return 1;
+    case SCHILD:
+        return 0;
+    case SCHUH:
+        return 0;
+    case GEIST:
+        return 0;
+    case KUGEL:
+        return 1;
+    case ROLLE:
+        return 0;
+    case STURM:
+        return 0;
+    case DRACHENAUGE:
+        return 1;
+    case FEUERBALL:
+        return 1;
+    case ENTERHAKEN:
+        return 0;
+    case MINE:
+        return 1;
+    case RWEISHEIT:
+    case RSTRENGTH:
+    case RBOSHEIT:
+    case RLEBEN:
+    case RTEMPO:
+    default:
+        return 0;
+    }
+}
+
+
+float abklingzeit( GegenstandTyp typ )
+{
+    switch( typ )
+    {
+    case PFEIL:
+        return 5;
+    case LEBEN:
+        return 5;
+    case SCHILD:
+        return 100;
+    case SCHUH:
+        return 100;
+    case GEIST:
+        return 100;
+    case KUGEL:
+        return 5;
+    case ROLLE:
+        return 30;
+    case STURM:
+        return 30;
+    case DRACHENAUGE:
+        return 5;
+    case FEUERBALL:
+        return 5;
+    case ENTERHAKEN:
+        return 60;
+    case MINE:
+        return 5;
+    case RWEISHEIT:
+    case RSTRENGTH:
+    case RBOSHEIT:
+    case RLEBEN:
+    case RTEMPO:
+    default:
+        return 0;
+    }
+}
+
+bool storable( GegenstandTyp typ )
+{
+    return typ == RWEISHEIT || typ == RSTRENGTH || typ == RBOSHEIT || typ == RLEBEN || typ == RTEMPO;
+}
+
+bool brauchtRichtung( GegenstandTyp typ )
+{
+    return typ == PFEIL || typ == KUGEL || typ == DRACHENAUGE || typ == FEUERBALL || typ == ENTERHAKEN || typ == ROLLE || typ == STURM;
+}
+
+
+GegenstandTypVar::GegenstandTypVar( GegenstandTyp value )
+    : Variable( GEGENSTAND_TYP )
+{
+    this->value = value;
+}
+
+void GegenstandTypVar::setValue( GegenstandTyp value )
+{
+    this->value = value;
+}
+
+GegenstandTyp GegenstandTypVar::getValue() const
+{
+    return value;
+}
+
+
+Gegenstand::Gegenstand( int id, GegenstandTyp typ, int x, int y, int w, int h )
+    : GameObject( GEGENSTAND, x, y, w, h )
+{
+    this->id = id;
+    this->typ = typ;
+}
+
+int Gegenstand::getId() const
+{
+    return id;
+}
+
+GegenstandTyp Gegenstand::getTyp() const
+{
+    return typ;
+}

StickmanWorldOnline/Gegenstand.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "GameObject.h"
+
+enum GegenstandTyp
+{
+    KEIN_GEGENSTAND,
+    PFEIL,
+    LEBEN,
+    SCHILD,
+    SCHUH,
+    GEIST,
+    KUGEL,
+    ROLLE,
+    STURM,
+    DRACHENAUGE,
+    FEUERBALL,
+    ENTERHAKEN,
+    MINE,
+    RWEISHEIT,
+    RSTRENGTH,
+    RBOSHEIT,
+    RLEBEN,
+    RTEMPO,
+    ITEMANZAHL
+};
+
+bool consumable( GegenstandTyp typ );
+
+float abklingzeit( GegenstandTyp typ );
+
+bool storable( GegenstandTyp typ );
+
+bool brauchtRichtung( GegenstandTyp typ );
+
+class GegenstandTypVar : public Variable
+{
+private:
+    GegenstandTyp value;
+
+public:
+    GegenstandTypVar( GegenstandTyp value );
+    void setValue( GegenstandTyp value );
+    GegenstandTyp getValue() const;
+};
+
+class Gegenstand : public GameObject
+{
+private:
+    GegenstandTyp typ;
+    int id;
+
+public:
+    Gegenstand( int id, GegenstandTyp typ, int x = 0, int y = 0, int w = 50, int h = 50 );
+    int getId() const;
+    GegenstandTyp getTyp() const;
+};

StickmanWorldOnline/Geist.cpp

@@ -0,0 +1,14 @@
+#include "Geist.h"
+#include "Spieler.h"
+
+GeistEffect::GeistEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 5.f + ( 5.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{}
+
+GeistEffect::~GeistEffect()
+{}
+
+bool GeistEffect::istSpielerSichtbar( Team *zTeam )
+{
+    return zTeam == zSpieler->zTeam();
+}

StickmanWorldOnline/Geist.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Effect.h"
+
+class GeistEffect : public Effect
+{
+private:
+
+public:
+    GeistEffect( Spieler *zSpieler );
+    ~GeistEffect();
+    bool istSpielerSichtbar( Team *zTeam ) override;
+};

StickmanWorldOnline/Geschoss.cpp

@@ -0,0 +1,169 @@
+#include "Geschoss.h"
+#include "Spiel.h"
+
+
+Geschoss::Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer )
+    : GameObject( GESCHOSS, x, y, 20, 20 )
+{
+    if( typ == GESCHOSS_PFEIL )
+    {
+        if( r == OBEN || r == UNTEN )
+            setHeight( 50 );
+        else
+            setWidth( 50 );
+    }
+    this->speed = speed;
+    this->richtung = richtung;
+    this->besitzer = besitzer;
+    this->typ = typ;
+    tunnelBenutzt = 0;
+    umgelenkt = 0;
+    geschosseGetroffen = 0;
+    schalter = 0;
+    this->id = id;
+}
+
+Geschoss::~Geschoss()
+{
+    if( besitzer )
+        besitzer->release();
+}
+
+void Geschoss::invertDirection()
+{
+    richtung = invert( richtung );
+}
+
+void Geschoss::addUmlenkung( Spiel *zSpiel )
+{
+    zSpiel->setGeschossZuletztUmgelenkt( (Geschoss *)getThis() );
+    umgelenkt++;
+}
+
+void Geschoss::addGeschossTreffer( Spiel *zSpiel )
+{
+    zSpiel->setGeschossZuletztGeschossGetroffen( (Geschoss *)getThis() );
+    geschosseGetroffen++;
+}
+
+void Geschoss::addTunnel( Spiel *zSpiel )
+{
+    zSpiel->setGeschossZuletztTunnelBenutzt( (Geschoss *)getThis() );
+    schalter++;
+}
+
+void Geschoss::addSchalter()
+{
+    id++;
+}
+
+void Geschoss::setSpeed( float speed )
+{
+    this->speed = speed;
+}
+
+void Geschoss::setBesitzer( Spieler *besitzer )
+{
+    if( this->besitzer )
+        this->besitzer->release();
+    this->besitzer = besitzer;
+}
+
+void Geschoss::setTyp( GeschossTyp typ )
+{
+    this->typ = typ;
+    if( typ == GESCHOSS_PFEIL )
+    {
+        if( richtung == OBEN || richtung == UNTEN )
+            setHeight( 50 );
+        else
+            setWidth( 50 );
+    }
+    else
+    {
+        setWidth( 20 );
+        setHeight( 20 );
+    }
+}
+
+void Geschoss::setRichtung( Richtung r )
+{
+    richtung = r;
+}
+
+void Geschoss::tick( double zeit )
+{
+    switch( richtung )
+    {
+    case OBEN:
+        y -= (float)zeit * speed;
+        break;
+    case UNTEN:
+        y += (float)zeit * speed;
+        break;
+    case RECHTS:
+        x += (float)zeit * speed;
+        break;
+    case LINKS:
+        x -= (float)zeit * speed;
+        break;
+    default:
+        break;
+    }
+}
+
+GeschossTyp Geschoss::getTyp() const
+{
+    return typ;
+}
+
+Spieler *Geschoss::zBesitzer() const
+{
+    return besitzer;
+}
+
+Spieler *Geschoss::getBesitzer() const
+{
+    return besitzer ? (Spieler *)besitzer->getThis() : 0;
+}
+
+Richtung Geschoss::getRichtung() const
+{
+    return richtung;
+}
+
+
+FeuerballTreffer::FeuerballTreffer( int id, int x, int y, Spieler *besitzer, int maxZeit )
+    : GameObject( FEUERBALL_TREFFER, x - 75, y - 75, 150, 150 )
+{
+    this->id = id;
+    this->besitzer = besitzer;
+    this->timeLeft = (float)maxZeit;
+    count = 0;
+}
+
+FeuerballTreffer::~FeuerballTreffer()
+{
+    besitzer->release();
+}
+
+void FeuerballTreffer::tick( double zeit )
+{
+    timeLeft -= (float)zeit;
+    count++;
+}
+
+bool FeuerballTreffer::isOver() const
+{
+    return timeLeft <= 0;
+}
+
+bool FeuerballTreffer::makeDamage() const
+{
+    return count % 2;
+}
+
+Spieler *FeuerballTreffer::zVerursacher() const
+{
+    return besitzer;
+}

StickmanWorldOnline/Geschoss.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "GameObject.h"
+#include "Spieler.h"
+
+class Spiel;
+
+#define PFEIL_DAMAGE 100
+#define KUGEL_DAMAGE 100
+
+class Geschoss : public GameObject
+{
+private:
+    float speed;
+    Richtung richtung;
+    Spieler *besitzer;
+    GeschossTyp typ;
+    int tunnelBenutzt;
+    int umgelenkt;
+    int geschosseGetroffen;
+    int schalter;
+    int id;
+
+public:
+    Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer );
+    ~Geschoss();
+    void invertDirection();
+    void addUmlenkung( Spiel *zSpiel );
+    void addGeschossTreffer( Spiel *zSpiel );
+    void addTunnel( Spiel *zSpiel );
+    void addSchalter();
+    void setSpeed( float speed );
+    void setBesitzer( Spieler *besitzer );
+    void setTyp( GeschossTyp typ );
+    void setRichtung( Richtung r );
+    void tick( double zeit );
+    GeschossTyp getTyp() const;
+    Spieler *zBesitzer() const;
+    Spieler *getBesitzer() const;
+    Richtung getRichtung() const;
+};
+
+// size: 150x150
+class FeuerballTreffer : public GameObject
+{
+private:
+    int id;
+    Spieler *besitzer;
+    int count;
+    float timeLeft;
+
+public:
+    FeuerballTreffer( int id, int x, int y, Spieler *besitzer, int maxZeit );
+    ~FeuerballTreffer();
+    void tick( double zeit );
+    bool isOver() const;
+    bool makeDamage() const;
+    Spieler *zVerursacher() const;
+};

StickmanWorldOnline/Leben.cpp

@@ -0,0 +1,13 @@
+#include "Leben.h"
+#include "Spieler.h"
+
+LebenEffect::LebenEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 10.f + ( 10.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() + 10 );
+}
+
+LebenEffect::~LebenEffect()
+{
+    zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() - 10 );
+}

StickmanWorldOnline/Leben.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Effect.h"
+
+class LebenEffect : public Effect
+{
+private:
+
+public:
+    LebenEffect( Spieler *zSpieler );
+    ~LebenEffect();
+};

StickmanWorldOnline/LebenRune.cpp

@@ -0,0 +1,14 @@
+#include "LebenRune.h"
+#include "Spieler.h"
+
+
+LebenRuneEffect::LebenRuneEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() + 10 );
+}
+
+LebenRuneEffect::~LebenRuneEffect()
+{
+    zSpieler->setLebensRegeneration( zSpieler->getLebensRegenneration() - 10 );
+}

StickmanWorldOnline/LebenRune.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Effect.h"
+
+class LebenRuneEffect : public Effect
+{
+private:
+
+public:
+    LebenRuneEffect( Spieler *zSpieler );
+    ~LebenRuneEffect();
+};

StickmanWorldOnline/Reader.cpp

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

StickmanWorldOnline/Reader.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <Datei.h>
+#include <Vec2.h>
+#include "Team.h"
+#include "Spiel.h"
+
+class Spiel;
+class Aktion;
+
+class MapReader
+{
+private:
+    Text *pfad;
+    int karteId;
+    int ref;
+
+    Aktion *readAktion( Datei &dat );
+
+public:
+    // Konstruktor
+    MapReader( int karteId, char *tmpPfad );
+    // Destruktor
+    ~MapReader();
+    // nicht constant
+    void ladeKarte( Spiel *zSpiel );
+    // Reference Counting
+    MapReader *getThis();
+    MapReader *release();
+};

StickmanWorldOnline/Rolle.cpp

@@ -0,0 +1,47 @@
+#include "Rolle.h"
+#include "Spieler.h"
+
+RolleEffect::RolleEffect( Spieler *zSpieler, Richtung r )
+    : Effect( zSpieler, 2.f + ( 2.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    this->r = r;
+}
+
+RolleEffect::~RolleEffect()
+{}
+
+bool RolleEffect::istSpielerBeweglich( Richtung r )
+{
+    return false;
+}
+
+bool RolleEffect::istSpielerVerwundbar( Richtung r )
+{
+    return r == MITTE;
+}
+
+void RolleEffect::move( double time )
+{
+    switch( r )
+    {
+    case OBEN:
+        zSpieler->setY( zSpieler->getY() - ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case RECHTS:
+        zSpieler->setX( zSpieler->getX() + ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case UNTEN:
+        zSpieler->setY( zSpieler->getY() + ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case LINKS:
+        zSpieler->setX( zSpieler->getX() - ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    default:
+        break;
+    }
+}
+
+bool RolleEffect::istGegenstandErlaubt( GegenstandTyp typ )
+{
+    return typ != STURM && typ != ENTERHAKEN;
+}

StickmanWorldOnline/Rolle.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "Effect.h"
+
+class RolleEffect : public Effect
+{
+private:
+    Richtung r;
+
+public:
+    RolleEffect( Spieler *zSpieler, Richtung r );
+    ~RolleEffect();
+    bool istSpielerBeweglich( Richtung r ) override;
+    bool istSpielerVerwundbar( Richtung r ) override;
+    void move( double time ) override;
+    bool istGegenstandErlaubt( GegenstandTyp typ ) override;
+};

StickmanWorldOnline/STKNachricht.cpp

@@ -0,0 +1,56 @@
+#include "STKNachricht.h"
+#include <cstring>
+
+// Inhalt der STKNachricht Klasse aus STKNachricht.h
+// Konstruktor
+STKNachricht::STKNachricht( int län, char *nachricht )
+{
+	verarbeitet = 0;
+	this->län = län;
+	this->nachricht = new char[ this->län ];
+    memcpy( this->nachricht, nachricht, län );
+	ref = 1;
+}
+
+// Destruktor
+STKNachricht::~STKNachricht()
+{
+	delete[] nachricht;
+}
+
+// nicht constant
+void STKNachricht::setVerarbeitet()
+{
+	verarbeitet = 1;
+}
+
+// constant
+bool STKNachricht::istVerarbeitet() const
+{
+	return verarbeitet;
+}
+
+int STKNachricht::getLength() const
+{
+	return län;
+}
+
+char *STKNachricht::getNachricht() const
+{
+	return nachricht;
+}
+
+// Reference Counting
+STKNachricht *STKNachricht::getThis()
+{
+	ref++;
+	return this;
+}
+
+STKNachricht *STKNachricht::release()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

StickmanWorldOnline/STKNachricht.h

@@ -0,0 +1,28 @@
+#ifndef STKNachricht_H
+#define STKNachricht_H
+
+class STKNachricht
+{
+private:
+	int län;
+	char *nachricht;
+	bool verarbeitet;
+	int ref;
+
+public:
+	// Konstruktor
+	STKNachricht( int län, char *nachricht );
+	// Destruktor
+	~STKNachricht();
+	// nicht constant
+	void setVerarbeitet();
+	// constant
+	bool istVerarbeitet() const;
+	int getLength() const;
+	char *getNachricht() const;
+	// Reference Counting
+	STKNachricht *getThis();
+	STKNachricht *release();
+};
+
+#endif

StickmanWorldOnline/Schalter.cpp

@@ -0,0 +1,40 @@
+#include "Schalter.h"
+#include "Spiel.h"
+
+
+Schalter::Schalter( int id, int x, int y, int width, int height, bool aktive )
+    : GameObject( SCHALTER, x, y, width, height )
+{
+    this->id = id;
+    this->aktiv = aktive;
+    aktivierungen = 0;
+}
+
+void Schalter::setAktive( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+void Schalter::press( Spiel *zSpiel )
+{
+    zSpiel->setSchalterZuletztAktiviert( (Schalter *)getThis() );
+    aktivierungen++;
+    Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
+    e->addParameter( "Betroffener Schalter", getThis() );
+    zSpiel->throwEvent( e );
+}
+
+int Schalter::getAnzahlAktivierungen() const
+{
+    return aktivierungen;
+}
+
+bool Schalter::isAktive() const
+{
+    return aktiv;
+}
+
+int Schalter::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Schalter.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "GameObject.h"
+
+class Spiel;
+
+class Schalter : public GameObject
+{
+private:
+    int id;
+    bool aktiv;
+    int aktivierungen;
+
+public:
+    Schalter( int id, int x, int y, int width, int height, bool aktive );
+    void setAktive( bool aktiv );
+    void press( Spiel *zSpiel );
+    int getAnzahlAktivierungen() const;
+    bool isAktive() const;
+    int getId() const;
+};

StickmanWorldOnline/Schiene.cpp

@@ -0,0 +1,12 @@
+#include "Schiene.h"
+
+Schiene::Schiene( int id, int x, int y, int width, int height )
+    : GameObject( SCHIENE, x, y, width, height )
+{
+    this->id = id;
+}
+
+int Schiene::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Schiene.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "GameObject.h"
+
+class Schiene : public GameObject
+{
+private:
+    int id;
+public:
+    Schiene( int id, int x, int y, int width, int height );
+    int getId() const;
+};

StickmanWorldOnline/Schild.cpp

@@ -0,0 +1,15 @@
+#include "Schild.h"
+#include "Spieler.h"
+
+
+SchildEffect::SchildEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 5.f + ( 5.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{}
+
+SchildEffect::~SchildEffect()
+{}
+
+bool SchildEffect::istSpielerVerwundbar( Richtung r )
+{
+    return 0;
+}

StickmanWorldOnline/Schild.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Effect.h"
+
+class SchildEffect : public Effect
+{
+private:
+
+public:
+    SchildEffect( Spieler *zSpieler );
+    ~SchildEffect();
+    bool istSpielerVerwundbar( Richtung r ) override;
+};

StickmanWorldOnline/Schuh.cpp

@@ -0,0 +1,21 @@
+#include "Schuh.h"
+#include "Spieler.h"
+
+SchuhEffect::SchuhEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 20.f + ( 20.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    speedup = 15;
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() + speedup );
+}
+
+SchuhEffect::~SchuhEffect()
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() - speedup );
+}
+
+bool SchuhEffect::tick( double time, Spiel *zSpiel )
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() - ( (float)time / timeLeft ) * speedup );
+    speedup -= ( (float)time / timeLeft ) * speedup;
+    return Effect::tick( time, zSpiel );
+}

StickmanWorldOnline/Schuh.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "Effect.h"
+
+class SchuhEffect : public Effect
+{
+private:
+    float speedup;
+
+public:
+    SchuhEffect( Spieler *zSpieler );
+    ~SchuhEffect();
+    bool tick( double time, Spiel *zSpiel ) override;
+};

StickmanWorldOnline/Spiel.cpp

@@ -0,0 +1,1000 @@
+#include "Spiel.h"
+
+
+// Konstruktor
+Spiel::Spiel()
+{
+
+    lastRunnedTrigger = 0;
+    zuletztEingeschalteteBariere = 0;
+    zuletztAusgeschalteteBariere = 0;
+    zuletztBewegteBariere = 0;
+    lastTeamChangedBase = 0;
+    lastDropedDrop = 0;
+    zuletztAufgehobenerGegenstand = KEIN_GEGENSTAND;
+    zuletztBenutzterGegenstand = KEIN_GEGENSTAND;
+    zuletztGedropterGegenstand = KEIN_GEGENSTAND;
+    zuletztAbgefeuertesGeschoss = 0;
+    zuletztUmgelenktesGeschoss = 0;
+    zuletztBariereGetroffenesGeschoss = 0;
+    zuletztTunnelBenutztesGeschoss = 0;
+    zuletztGeschossGetroffenesGeschoss = 0;
+    zuletztAktivierterSchalter = 0;
+    zuletztSchadenGemachterSpieler = 0;
+    zuletztSchadenGenommenerSpieler = 0;
+    zuletztGeheilterSpieler = 0;
+    zuletztLevelUpSpieler = 0;
+    zuletztErfahrungBekommenerSpieler = 0;
+    zuletztGegenstandAktivierterSpieler = 0;
+    zuletztGegenstandAufgehobenerSpieler = 0;
+    zuletztSchalterAktivierterSpieler = 0;
+    zuletztTunnelBenutzterSpieler = 0;
+    zuletztGestorbenerSpieler = 0;
+    zuletztWiederbelebterSpieler = 0;
+    zuletztGeschossenerSpieler = 0;
+    zuletztAbgelaufenerTimer = 0;
+    zuletztGestarteterTimer = 0;
+    zuletztPausierterTimer = 0;
+    zuletztFortgesetzterTimer = 0;
+    zuletztBenutzterTunnel = 0;
+    zuletztBenutzteUmlenkung = 0;
+    ref = 1;
+}
+
+// Destruktor
+Spiel::~Spiel()
+{
+    if( lastRunnedTrigger )
+        lastRunnedTrigger->release();
+    if( zuletztEingeschalteteBariere )
+        zuletztEingeschalteteBariere->release();
+    if( zuletztAusgeschalteteBariere )
+        zuletztAusgeschalteteBariere->release();
+    if( zuletztBewegteBariere )
+        zuletztBewegteBariere->release();
+    if( lastTeamChangedBase )
+        lastTeamChangedBase->release();
+    if( lastDropedDrop )
+        lastDropedDrop->release();
+    if( zuletztAbgefeuertesGeschoss )
+        zuletztAbgefeuertesGeschoss->release();
+    if( zuletztUmgelenktesGeschoss )
+        zuletztUmgelenktesGeschoss->release();
+    if( zuletztBariereGetroffenesGeschoss )
+        zuletztBariereGetroffenesGeschoss->release();
+    if( zuletztTunnelBenutztesGeschoss )
+        zuletztTunnelBenutztesGeschoss->release();
+    if( zuletztGeschossGetroffenesGeschoss )
+        zuletztGeschossGetroffenesGeschoss->release();
+    if( zuletztAktivierterSchalter )
+        zuletztAktivierterSchalter->release();
+    if( zuletztSchadenGemachterSpieler )
+        zuletztSchadenGemachterSpieler->release();
+    if( zuletztSchadenGenommenerSpieler )
+        zuletztSchadenGenommenerSpieler->release();
+    if( zuletztGeheilterSpieler )
+        zuletztGeheilterSpieler->release();
+    if( zuletztLevelUpSpieler )
+        zuletztLevelUpSpieler->release();
+    if( zuletztErfahrungBekommenerSpieler )
+        zuletztErfahrungBekommenerSpieler->release();
+    if( zuletztGegenstandAktivierterSpieler )
+        zuletztGegenstandAktivierterSpieler->release();
+    if( zuletztGegenstandAufgehobenerSpieler )
+        zuletztGegenstandAufgehobenerSpieler->release();
+    if( zuletztSchalterAktivierterSpieler )
+        zuletztSchalterAktivierterSpieler->release();
+    if( zuletztTunnelBenutzterSpieler )
+        zuletztTunnelBenutzterSpieler->release();
+    if( zuletztGestorbenerSpieler )
+        zuletztGestorbenerSpieler->release();
+    if( zuletztWiederbelebterSpieler )
+        zuletztWiederbelebterSpieler->release();
+    if( zuletztGeschossenerSpieler )
+        zuletztGeschossenerSpieler->release();
+    if( zuletztAbgelaufenerTimer )
+        zuletztAbgelaufenerTimer->release();
+    if( zuletztGestarteterTimer )
+        zuletztGestarteterTimer->release();
+    if( zuletztPausierterTimer )
+        zuletztPausierterTimer->release();
+    if( zuletztFortgesetzterTimer )
+        zuletztFortgesetzterTimer->release();
+    if( zuletztBenutzterTunnel )
+        zuletztBenutzterTunnel->release();
+    if( zuletztBenutzteUmlenkung )
+        zuletztBenutzteUmlenkung->release();
+}
+
+// nicht constant
+void Spiel::lock()
+{
+
+}
+
+void Spiel::unlock()
+{
+
+}
+
+void Spiel::setSchrift( Schrift *schrift )
+{
+
+}
+ // call 4
+void Spiel::setBildschirm( Bildschirm *zScreen )
+{
+
+}
+ // call 3
+void Spiel::nachricht( int län, char *bytes )
+{
+
+}
+
+void Spiel::setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient )
+{
+
+}
+ // call 2
+void Spiel::setKarteId( int karteId )
+{
+
+}
+ // call 1
+void Spiel::ladeDaten()
+{
+
+}
+ // call 5
+void Spiel::doPublicMausEreignis( MausEreignis &me )
+{
+
+}
+
+void Spiel::doTastaturEreignis( TastaturEreignis &te )
+{
+
+}
+
+void Spiel::stknVerarbeitung()
+{
+
+}
+
+bool Spiel::tick( double zeit )
+{
+
+}
+
+void Spiel::render( Bild &zRObj )
+{
+
+}
+
+void Spiel::setMapSize( int width, int height )
+{
+    mapSize = Punkt( width, height );
+}
+
+void Spiel::setPausiert( bool pausiert )
+{
+    this->pause = pausiert;
+}
+
+void Spiel::addVariable( const char *name, Variable *var )
+{
+    bool found = 0;
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+        {
+            found = 1;
+            break;
+        }
+    }
+    if( !found )
+        variablen.add( new VarPointer( name, var ) );
+    else
+        var->release();
+}
+
+void Spiel::setVariable( const char *name, Variable *var )
+{
+    bool found = 0;
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+        {
+            v->setVariable( var );
+            break;
+        }
+    }
+    if( !found )
+        var->release();
+}
+
+void Spiel::addTeam( Team *team )
+{
+    teams.add( team );
+}
+
+void Spiel::addSpieler( Spieler *spieler )
+{
+    this->spieler.add( spieler );
+}
+
+void Spiel::addBariere( Bariere *bariere )
+{
+    barieren.add( bariere );
+}
+
+void Spiel::addBase( Base *base )
+{
+    basen.add( base );
+}
+
+void Spiel::addDrop( Drop *drop )
+{
+    drops.add( drop );
+}
+
+void Spiel::addGegenstand( Gegenstand *gegenstand )
+{
+    items.add( gegenstand );
+    zuletztGedropterGegenstand = gegenstand->getTyp();
+    Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
+    e->addParameter( "Betroffener Gegenstand", gegenstand->getThis() );
+    throwEvent( e );
+}
+
+void Spiel::addGeschoss( Geschoss *geschoss )
+{
+    if( zuletztAbgefeuertesGeschoss )
+        zuletztAbgefeuertesGeschoss->release();
+    zuletztAbgefeuertesGeschoss = geschoss;
+    shots.add( geschoss );
+}
+
+void Spiel::addSchalter( Schalter *schalter )
+{
+    this->schalter.add( schalter );
+}
+
+void Spiel::addSchiene( Schiene *schiene )
+{
+    schienen.add( schiene );
+}
+
+void Spiel::addTimer( Timer *timer )
+{
+    this->timer.add( timer );
+}
+
+void Spiel::addTunnel( Tunnel *tunnel )
+{
+    this->tunnel.add( tunnel );
+}
+
+void Spiel::addUmlenkung( Umlenkung *umlenkung )
+{
+    umlenkungen.add( umlenkung );
+}
+
+void Spiel::addTrigger( Trigger *trigger )
+{
+    this->trigger.add( trigger );
+}
+
+void Spiel::addTriggerRun( TriggerRun *tRun )
+{
+    if( tRun )
+    {
+        if( lastRunnedTrigger )
+            lastRunnedTrigger->release();
+        lastRunnedTrigger = tRun->getTrigger();
+        triggerRuns.add( tRun );
+    }
+}
+
+void Spiel::spielerActivate( Spieler *zSpieler )
+{
+    // spieler - item intersection
+    for( int i = 0; i < items.getEintragAnzahl(); i++ )
+    {
+        if( items.z( i )->intersectsWith( zSpieler ) )
+        {
+            items.remove( i );
+            zSpieler->addItem( items.z( i )->getTyp(), 1, this );
+            i--;
+        }
+    }
+    // Spieler - schalter intersection
+    for( int i = 0; i < schalter.getEintragAnzahl(); i++ )
+    {
+        if( schalter.z( i )->intersectsWith( zSpieler ) )
+        {
+            zSpieler->addSchalterBenutzung( this );
+            schalter.z( i )->press( this );
+        }
+    }
+    // Spieler - tunnel intersection
+    for( int i = 0; i < tunnel.getEintragAnzahl(); i++ )
+    {
+        if( tunnel.z( i )->intersectsWith( zSpieler ) )
+        {
+            zSpieler->addTunnelBenutzung( this );
+            zSpieler->setX( (float)tunnel.z( i )->getZielX() - zSpieler->getWidth() / 2.f );
+            zSpieler->setY( (float)tunnel.z( i )->getZielY() - zSpieler->getHeight() / 2.f );
+            tunnel.z( i )->addBenutzung( this );
+        }
+    }
+}
+
+Team *Spiel::getTeam( int id ) const
+{
+    for( auto t = teams.getIterator(); t; t++ )
+    {
+        if( t->getTeamNummer() == id )
+            return (Team *)t->getThis();
+    }
+    return 0;
+}
+
+Spieler *Spiel::getSpieler( int id ) const
+{
+    for( auto s = spieler.getIterator(); s; s++ )
+    {
+        if( s->getId() == id )
+            return (Spieler *)s->getThis();
+    }
+    return 0;
+}
+
+Iterator<Spieler *> Spiel::getSpieler() const
+{
+    return spieler.getIterator();
+}
+
+Iterator<Bariere *> Spiel::getBarieren() const
+{
+    return barieren.getIterator();
+}
+
+Bariere *Spiel::getBariere( int id ) const
+{
+    for( auto b = barieren.getIterator(); b; b++ )
+    {
+        if( b->getId() == id )
+            return (Bariere *)b->getThis();
+    }
+    return 0;
+}
+
+Base *Spiel::getBase( int id ) const
+{
+    for( auto b = basen.getIterator(); b; b++ )
+    {
+        if( b->getId() == id )
+            return (Base *)b->getThis();
+    }
+    return 0;
+}
+
+Drop *Spiel::getDrop( int id ) const
+{
+    for( auto d = drops.getIterator(); d; d++ )
+    {
+        if( d->getId() == id )
+            return (Drop *)d->getThis();
+    }
+    return 0;
+}
+
+Schalter *Spiel::getSchalter( int id ) const
+{
+    for( auto s = schalter.getIterator(); s; s++ )
+    {
+        if( s->getId() == id )
+            return (Schalter *)s->getThis();
+    }
+    return 0;
+}
+
+Schiene *Spiel::getSchiene( int id ) const
+{
+    for( auto s = schienen.getIterator(); s; s++ )
+    {
+        if( s->getId() == id )
+            return (Schiene *)s->getThis();
+    }
+    return 0;
+}
+
+Timer *Spiel::getTimer( int id ) const
+{
+    for( auto t = timer.getIterator(); t; t++ )
+    {
+        if( t->getId() == id )
+            return (Timer *)t->getThis();
+    }
+    return 0;
+}
+
+Tunnel *Spiel::getTunnel( int id ) const
+{
+    for( auto t = tunnel.getIterator(); t; t++ )
+    {
+        if( t->getId() == id )
+            return (Tunnel *)t->getThis();
+    }
+    return 0;
+}
+
+Umlenkung *Spiel::getUmlenkung( int id ) const
+{
+    for( auto u = umlenkungen.getIterator(); u; u++ )
+    {
+        if( u->getId() == id )
+            return (Umlenkung *)u->getThis();
+    }
+    return 0;
+}
+
+Trigger *Spiel::getTrigger( int id ) const
+{
+    for( auto t = trigger.getIterator(); t; t++ )
+    {
+        if( t->getId() == id )
+            return (Trigger *)t->getThis();
+    }
+    return 0;
+}
+
+Variable *Spiel::getVariable( const char *name ) const
+{
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->getVariable();
+    }
+    return 0;
+}
+
+Variable *Spiel::zVariable( const char *name ) const
+{
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->zVariable();
+    }
+    return 0;
+}
+
+bool Spiel::istPausiert() const
+{
+    return pause;
+}
+
+void Spiel::activateShalter( int id )
+{
+    for( auto s = schalter.getIterator(); s; s++ )
+    {
+        if( s->getId() == id )
+            s->press( this );
+    }
+}
+
+void Spiel::throwEvent( Ereignis *e )
+{
+    for( auto t = trigger.getIterator(); t; t++ )
+    {
+        if( t->hatEreignis( e->getTyp() ) )
+        {
+            TriggerRun *tr = t->runTrigger( e->getThis(), this );
+            if( tr )
+                triggerRuns.add( tr );
+        }
+    }
+    e->release();
+}
+
+bool Spiel::needEvent( EreignisTyp typ ) const
+{
+    for( auto t = trigger.getIterator(); t; t++ )
+    {
+        if( t->hatEreignis( typ ) )
+            return 1;
+    }
+    return 0;
+}
+
+int Spiel::getNextId()
+{
+    return ++nextId;
+}
+
+double Spiel::getRand()
+{
+    return randG.rand();
+}
+
+int Spiel::getTickCount() const
+{
+    return gameTicks;
+}
+
+void Spiel::setEnde( Team *zGewinner )
+{
+    zWinner = zGewinner;
+    // TODO initialize ende dialog
+}
+
+Trigger *Spiel::getRandomTrigger()
+{
+    if( !trigger.getEintragAnzahl() )
+        return 0;
+    return trigger.get( (int)( randG.rand() * trigger.getEintragAnzahl() ) );
+}
+
+Trigger *Spiel::getLastRunnedTrigger() const
+{
+    return lastRunnedTrigger ? (Trigger *)lastRunnedTrigger->getThis() : 0;
+}
+
+Bariere *Spiel::getRandomBariere()
+{
+    return barieren.get( (int)( randG.rand() * barieren.getEintragAnzahl() ) );
+}
+
+void Spiel::setZuletztEingeschalteteBariere( Bariere *b )
+{
+    if( zuletztEingeschalteteBariere )
+        zuletztEingeschalteteBariere->release();
+    zuletztEingeschalteteBariere = b;
+}
+
+Bariere *Spiel::getZuletztEingeschalteteBariere() const
+{
+    return zuletztEingeschalteteBariere ? (Bariere *)zuletztEingeschalteteBariere->getThis() : 0;
+}
+
+void Spiel::setZuletztAusgeschalteteBariere( Bariere *b )
+{
+    if( zuletztAusgeschalteteBariere )
+        zuletztAusgeschalteteBariere->release();
+    zuletztAusgeschalteteBariere = b;
+}
+
+Bariere *Spiel::getZuletztAusgeschalteteBariere() const
+{
+    return zuletztAusgeschalteteBariere ? (Bariere *)zuletztAusgeschalteteBariere->getThis() : 0;
+}
+
+void Spiel::setZuletztBewegteBariere( Bariere *b )
+{
+    if( zuletztBewegteBariere )
+        zuletztBewegteBariere->release();
+    zuletztBewegteBariere = b;
+}
+
+Bariere *Spiel::getZuletztBewegteBariere() const
+{
+    return zuletztBewegteBariere ? (Bariere *)zuletztBewegteBariere->getThis() : 0;
+}
+
+Base *Spiel::getRandomBase()
+{
+    if( !basen.getEintragAnzahl() )
+        return 0;
+    return basen.get( (int)( randG.rand() * basen.getEintragAnzahl() ) );
+}
+
+void Spiel::setLastTeamChangedBase( Base *b )
+{
+    if( lastTeamChangedBase )
+        lastTeamChangedBase->release();
+    lastTeamChangedBase = b;
+}
+
+Base *Spiel::getLastTeamChangedBase() const
+{
+    return lastTeamChangedBase ? (Base *)lastTeamChangedBase->getThis() : 0;
+}
+
+Drop *Spiel::getRandomDrop()
+{
+    if( !drops.getEintragAnzahl() )
+        return 0;
+    return drops.get( (int)( randG.rand() * drops.getEintragAnzahl() ) );
+}
+
+void Spiel::setLastDrop( Drop *d )
+{
+    if( lastDropedDrop )
+        lastDropedDrop->release();
+    lastDropedDrop = d;
+}
+
+Drop *Spiel::getLastDrop() const
+{
+    return lastDropedDrop ? (Drop *)lastDropedDrop->getThis() : 0;
+}
+
+void Spiel::setItemZuletztAufgehoben( GegenstandTyp g )
+{
+    zuletztAufgehobenerGegenstand = g;
+}
+
+GegenstandTyp Spiel::getItemZuletztAufgehoben() const
+{
+    return zuletztAufgehobenerGegenstand;
+}
+
+void Spiel::setItemZuletztAktiviert( GegenstandTyp g )
+{
+    zuletztBenutzterGegenstand = g;
+}
+
+GegenstandTyp Spiel::getItemZuletztAktiviert() const
+{
+    return zuletztBenutzterGegenstand;
+}
+
+GegenstandTyp Spiel::getItemZuletztGedropt() const
+{
+    return zuletztGedropterGegenstand;
+}
+
+Geschoss *Spiel::getRandomGeschoss()
+{
+    if( !shots.getEintragAnzahl() )
+        return 0;
+    return shots.get( (int)( randG.rand() * shots.getEintragAnzahl() ) );
+}
+
+Geschoss *Spiel::getGeschossZuletztAbgefeuert() const
+{
+    return zuletztAbgefeuertesGeschoss ? (Geschoss *)zuletztAbgefeuertesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztUmgelenkt( Geschoss *g )
+{
+    if( zuletztUmgelenktesGeschoss )
+        zuletztUmgelenktesGeschoss->release();
+    zuletztUmgelenktesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztUmgelenkt() const
+{
+    return zuletztUmgelenktesGeschoss ? (Geschoss *)zuletztUmgelenktesGeschoss->getThis() : 0;
+}
+
+Geschoss *Spiel::getGeschossZuletztBariereGetroffen() const
+{
+    return zuletztBariereGetroffenesGeschoss ? (Geschoss *)zuletztBariereGetroffenesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztTunnelBenutzt( Geschoss *g )
+{
+    if( zuletztTunnelBenutztesGeschoss )
+        zuletztTunnelBenutztesGeschoss->release();
+    zuletztTunnelBenutztesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztTunnelBenutzt() const
+{
+    return zuletztTunnelBenutztesGeschoss ? (Geschoss *)zuletztTunnelBenutztesGeschoss->getThis() : 0;
+}
+
+void Spiel::setGeschossZuletztGeschossGetroffen( Geschoss *g )
+{
+    if( zuletztGeschossGetroffenesGeschoss )
+        zuletztGeschossGetroffenesGeschoss->release();
+    zuletztGeschossGetroffenesGeschoss = g;
+}
+
+Geschoss *Spiel::getGeschossZuletztGeschossGetroffen() const
+{
+    return zuletztGeschossGetroffenesGeschoss ? (Geschoss *)zuletztGeschossGetroffenesGeschoss->getThis() : 0;
+}
+
+Schalter *Spiel::getRandomSchalter()
+{
+    if( !schalter.getEintragAnzahl() )
+        return 0;
+    return schalter.get( (int)( randG.rand() * schalter.getEintragAnzahl() ) );
+}
+
+void Spiel::setSchalterZuletztAktiviert( Schalter *s )
+{
+    if( zuletztAktivierterSchalter )
+        zuletztAktivierterSchalter->release();
+    zuletztAktivierterSchalter = s;
+}
+
+Schalter *Spiel::getSchalterZuletztAktiviert() const
+{
+    return zuletztAktivierterSchalter ? (Schalter *)zuletztAktivierterSchalter->getThis() : 0;
+}
+
+Spieler *Spiel::getRandomSpieler()
+{
+    if( !spieler.getEintragAnzahl() )
+        return 0;
+    return spieler.get( (int)( randG.rand() * spieler.getEintragAnzahl() ) );
+}
+
+Spieler *Spiel::getRandomSpieler( Team *zTeam )
+{
+    if( !zTeam || !zTeam->getSpielerAnzahl() )
+        return 0;
+    int index = (int)( randG.rand() * zTeam->getSpielerAnzahl() );
+    for( auto s = spieler.getIterator(); s; s++ )
+    {
+        if( s->zTeam() == zTeam )
+        {
+            if( index-- <= 0 )
+                return (Spieler *)s->getThis();
+        }
+    }
+    return 0;
+}
+
+void Spiel::setSpielerZuletztSchadenGemacht( Spieler *s )
+{
+    if( zuletztSchadenGemachterSpieler )
+        zuletztSchadenGemachterSpieler->release();
+    zuletztSchadenGemachterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchadenGemacht() const
+{
+    return zuletztSchadenGemachterSpieler ? (Spieler *)zuletztSchadenGemachterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztSchadenGenommen( Spieler *s )
+{
+    if( zuletztSchadenGenommenerSpieler )
+        zuletztSchadenGenommenerSpieler->release();
+    zuletztSchadenGenommenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchadenGenommen() const
+{
+    return zuletztSchadenGenommenerSpieler ? (Spieler *)zuletztSchadenGenommenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGeheilt( Spieler *s )
+{
+    if( zuletztGeheilterSpieler )
+        zuletztGeheilterSpieler->release();
+    zuletztGeheilterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGeheilt() const
+{
+    return zuletztGeheilterSpieler ? (Spieler *)zuletztGeheilterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztLevelUp( Spieler *s )
+{
+    if( zuletztLevelUpSpieler )
+        zuletztLevelUpSpieler->release();
+    zuletztLevelUpSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztLevelUp() const
+{
+    return zuletztLevelUpSpieler ? (Spieler *)zuletztLevelUpSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztErfahrungBekommen( Spieler *s )
+{
+    if( zuletztErfahrungBekommenerSpieler )
+        zuletztErfahrungBekommenerSpieler->release();
+    zuletztErfahrungBekommenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztErfahrungBekommen() const
+{
+    return zuletztErfahrungBekommenerSpieler ? (Spieler *)zuletztErfahrungBekommenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGegenstandAktiviert( Spieler *s )
+{
+    if( zuletztGegenstandAktivierterSpieler )
+        zuletztGegenstandAktivierterSpieler->release();
+    zuletztGegenstandAktivierterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGegenstandAktiviert() const
+{
+    return zuletztGegenstandAktivierterSpieler ? (Spieler *)zuletztGegenstandAktivierterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGegenstandAufgehoben( Spieler *s )
+{
+    if( zuletztGegenstandAufgehobenerSpieler )
+        zuletztGegenstandAufgehobenerSpieler->release();
+    zuletztGegenstandAufgehobenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGegenstandAufgehoben() const
+{
+    return zuletztGegenstandAufgehobenerSpieler ? (Spieler *)zuletztGegenstandAufgehobenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztSchalterAktiviert( Spieler *s )
+{
+    if( zuletztSchalterAktivierterSpieler )
+        zuletztSchalterAktivierterSpieler->release();
+    zuletztSchalterAktivierterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztSchalterAktiviert() const
+{
+    return zuletztSchalterAktivierterSpieler ? (Spieler *)zuletztSchalterAktivierterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztTunnelBenutzt( Spieler *s )
+{
+    if( zuletztTunnelBenutzterSpieler )
+        zuletztTunnelBenutzterSpieler->release();
+    zuletztTunnelBenutzterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztTunnelBenutzt() const
+{
+    return zuletztTunnelBenutzterSpieler ? (Spieler *)zuletztTunnelBenutzterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGestorben( Spieler *s )
+{
+    if( zuletztGestorbenerSpieler )
+        zuletztGestorbenerSpieler->release();
+    zuletztGestorbenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGestorben() const
+{
+    return zuletztGestorbenerSpieler ? (Spieler *)zuletztGestorbenerSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztWiederbelebt( Spieler *s )
+{
+    if( zuletztWiederbelebterSpieler )
+        zuletztWiederbelebterSpieler->release();
+    zuletztWiederbelebterSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztWiederbelebt() const
+{
+    return zuletztWiederbelebterSpieler ? (Spieler *)zuletztWiederbelebterSpieler->getThis() : 0;
+}
+
+void Spiel::setSpielerZuletztGeschossen( Spieler *s )
+{
+    if( zuletztGeschossenerSpieler )
+        zuletztGeschossenerSpieler->release();
+    zuletztGeschossenerSpieler = s;
+}
+
+Spieler *Spiel::getSpielerZuletztGeschossen() const
+{
+    return zuletztGeschossenerSpieler ? (Spieler *)zuletztGeschossenerSpieler->getThis() : 0;
+}
+
+Team *Spiel::getRandomTeam()
+{
+    if( !teams.getEintragAnzahl() )
+        return 0;
+    return teams.get( (int)( randG.rand() * teams.getEintragAnzahl() ) );
+}
+
+Timer *Spiel::getRandomTimer()
+{
+    if( !timer.getEintragAnzahl() )
+        return 0;
+    return timer.get( (int)( randG.rand() * timer.getEintragAnzahl() ) );
+}
+
+void Spiel::setTimerZuletztAbgelaufen( Timer *t )
+{
+    if( zuletztAbgelaufenerTimer )
+        zuletztAbgelaufenerTimer->release();
+    zuletztAbgelaufenerTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztAbgelaufen() const
+{
+    return zuletztAbgelaufenerTimer ? (Timer *)zuletztAbgelaufenerTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztGestartet( Timer *t )
+{
+    if( zuletztGestarteterTimer )
+        zuletztGestarteterTimer->release();
+    zuletztGestarteterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztGestartet() const
+{
+    return zuletztGestarteterTimer ? (Timer *)zuletztGestarteterTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztPausiert( Timer *t )
+{
+    if( zuletztPausierterTimer )
+        zuletztPausierterTimer->release();
+    zuletztPausierterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztPausiert() const
+{
+    return zuletztPausierterTimer ? (Timer *)zuletztPausierterTimer->getThis() : 0;
+}
+
+void Spiel::setTimerZuletztFortgesetzt( Timer *t )
+{
+    if( zuletztFortgesetzterTimer )
+        zuletztFortgesetzterTimer->release();
+    zuletztFortgesetzterTimer = t;
+}
+
+Timer *Spiel::getTimerZuletztFortgesetzt() const
+{
+    return zuletztFortgesetzterTimer ? (Timer *)zuletztFortgesetzterTimer->getThis() : 0;
+}
+
+Tunnel *Spiel::getRandomTunnel()
+{
+    if( !tunnel.getEintragAnzahl() )
+        return 0;
+    return tunnel.get( (int)( randG.rand() * tunnel.getEintragAnzahl() ) );
+}
+
+void Spiel::setTunnelZuletztBenutzt( Tunnel *t )
+{
+    if( zuletztBenutzterTunnel )
+        zuletztBenutzterTunnel->release();
+    zuletztBenutzterTunnel = t;
+}
+
+Tunnel *Spiel::getTunnelZuletztBenutzt() const
+{
+    return zuletztBenutzterTunnel ? (Tunnel *)zuletztBenutzterTunnel->getThis() : 0;
+}
+
+Umlenkung *Spiel::getRandomUmlenkung()
+{
+    if( !umlenkungen.getEintragAnzahl() )
+        return 0;
+    return umlenkungen.get( (int)( randG.rand() * umlenkungen.getEintragAnzahl() ) );
+}
+
+void Spiel::setUmlenkungZuletztBenutzt( Umlenkung *t )
+{
+    if( zuletztBenutzteUmlenkung )
+        zuletztBenutzteUmlenkung->release();
+    zuletztBenutzteUmlenkung = t;
+}
+
+Umlenkung *Spiel::getUmlenkungZuletztBenutzt() const
+{
+    return zuletztBenutzteUmlenkung ? (Umlenkung *)zuletztBenutzteUmlenkung->getThis() : 0;
+}
+
+// Reference Counting 
+SpielV *Spiel::getThis()
+{
+    ref++;
+    return this;
+}
+
+SpielV *Spiel::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Spiel.h

@@ -0,0 +1,256 @@
+#ifndef SpielKlasse_H
+#define SpielKlasse_H
+
+#include "SpielV.h"
+#include "SpielChat.h"
+#include "Ende.h"
+#include "STKNachricht.h"
+#include <Bildschirm.h>
+#include <Kamera2D.h>
+#include <Random.h>
+#include "Spieler.h"
+#include "Bariere.h"
+#include "Base.h"
+#include "Drop.h"
+#include "Geschoss.h"
+#include "Schalter.h"
+#include "Schiene.h"
+#include "Trigger.h"
+#include "Tunnel.h"
+#include "Umlenkung.h"
+
+class SpielerGUI;
+class DeadPlayer;
+
+class Spiel : public SpielV
+{
+private:
+    RCArray< STKNachricht > *stkn;
+    int stkna;
+    Schrift *schrift;
+    KSGClient::InformationServerClient *infoKlient;
+    KSGClient::SpielServerClient *spielKlient;
+    Bildschirm *screen;
+    Kamera2D *kam;
+    Kamera2D *minimap;
+    Welt2D *welt;
+    SpielChat *chat;
+    Ende *end;
+    SpielerGUI *shipGUI;
+    RCArray< DeadPlayer > *deads;
+    RandomGenerator randG;
+    RCArray< VarPointer > variablen;
+    RCArray< Spieler > spieler;
+    RCArray< Team > teams;
+    RCArray< Bariere > barieren;
+    RCArray< Base > basen;
+    RCArray< Drop > drops;
+    RCArray< Gegenstand > items;
+    RCArray< Geschoss > shots;
+    RCArray< FeuerballTreffer > feuer;
+    RCArray< Schalter > schalter;
+    RCArray< Schiene > schienen;
+    RCArray< Timer > timer;
+    RCArray< Tunnel > tunnel;
+    RCArray< Umlenkung > umlenkungen;
+    RCArray< Trigger > trigger;
+    RCArray< TriggerRun > triggerRuns;
+    Punkt mapSize;
+    Team *zWinner;
+    Critical c;
+    Trigger *lastRunnedTrigger;
+    Bariere *zuletztEingeschalteteBariere;
+    Bariere *zuletztAusgeschalteteBariere;
+    Bariere *zuletztBewegteBariere;
+    Base *lastTeamChangedBase;
+    Drop *lastDropedDrop;
+    GegenstandTyp zuletztAufgehobenerGegenstand;
+    GegenstandTyp zuletztBenutzterGegenstand;
+    GegenstandTyp zuletztGedropterGegenstand;
+    Geschoss *zuletztAbgefeuertesGeschoss;
+    Geschoss *zuletztUmgelenktesGeschoss;
+    Geschoss *zuletztBariereGetroffenesGeschoss;
+    Geschoss *zuletztTunnelBenutztesGeschoss;
+    Geschoss *zuletztGeschossGetroffenesGeschoss;
+    Schalter *zuletztAktivierterSchalter;
+    Spieler *zuletztSchadenGemachterSpieler;
+    Spieler *zuletztSchadenGenommenerSpieler;
+    Spieler *zuletztGeheilterSpieler;
+    Spieler *zuletztLevelUpSpieler;
+    Spieler *zuletztErfahrungBekommenerSpieler;
+    Spieler *zuletztGegenstandAktivierterSpieler;
+    Spieler *zuletztGegenstandAufgehobenerSpieler;
+    Spieler *zuletztSchalterAktivierterSpieler;
+    Spieler *zuletztTunnelBenutzterSpieler;
+    Spieler *zuletztGestorbenerSpieler;
+    Spieler *zuletztWiederbelebterSpieler;
+    Spieler *zuletztGeschossenerSpieler;
+    Timer *zuletztAbgelaufenerTimer;
+    Timer *zuletztGestarteterTimer;
+    Timer *zuletztPausierterTimer;
+    Timer *zuletztFortgesetzterTimer;
+    Tunnel *zuletztBenutzterTunnel;
+    Umlenkung *zuletztBenutzteUmlenkung;
+    int nextId;
+    bool rendern;
+    double rZeit;
+    int gameTicks;
+    int spielerAnzahl;
+    int karteId;
+    int ladenProzent;
+    int spielerNummer;
+    char *tasten;
+    bool pause;
+    bool setKam;
+    int ref;
+
+    bool istAmLeben() const;
+    void goBackInTime( int zeit );
+    void goToPresence( int zeit );
+    void load();
+    void save();
+    void tick();
+
+public:
+    // Konstruktor
+    Spiel();
+    // Destruktor
+    ~Spiel();
+    // nicht constant
+    void lock();
+    void unlock();
+    void setSchrift( Schrift *schrift ) override; // call 4
+    void setBildschirm( Bildschirm *zScreen ) override; // call 3
+    void nachricht( int län, char *bytes ) override;
+    void setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient ) override; // call 2
+    void setKarteId( int karteId ) override; // call 1
+    void ladeDaten() override; // call 5
+    void doPublicMausEreignis( MausEreignis &me ) override;
+    void doTastaturEreignis( TastaturEreignis &te ) override;
+    void stknVerarbeitung();
+    bool tick( double zeit ) override;
+    void render( Bild &zRObj ) override;
+    void setMapSize( int width, int height );
+    void setPausiert( bool pausiert );
+    void addVariable( const char *name, Variable *var );
+    void setVariable( const char *name, Variable *var );
+    void addTeam( Team *team );
+    void addSpieler( Spieler *spieler );
+    void addBariere( Bariere *bariere );
+    void addBase( Base *base );
+    void addDrop( Drop *drop );
+    void addGegenstand( Gegenstand *gegenstand );
+    void addGeschoss( Geschoss *geschoss );
+    void addSchalter( Schalter *schalter );
+    void addSchiene( Schiene *schiene );
+    void addTimer( Timer *timer );
+    void addTunnel( Tunnel *tunnel );
+    void addUmlenkung( Umlenkung *umlenkung );
+    void addTrigger( Trigger *trigger );
+    void addTriggerRun( TriggerRun *tRun );
+    void spielerActivate( Spieler *zSpieler );
+    void activateShalter( int id );
+    void throwEvent( Ereignis *e );
+    Variable *getVariable( const char *name ) const;
+    Variable *zVariable( const char *name ) const;
+    bool istPausiert() const;
+    bool needEvent( EreignisTyp typ ) const;
+    Team *getTeam( int id ) const;
+    Spieler *getSpieler( int id ) const;
+    Iterator< Spieler * > getSpieler() const;
+    Iterator< Bariere * > getBarieren() const;
+    Bariere *getBariere( int id ) const;
+    Base *getBase( int id ) const;
+    Drop *getDrop( int id ) const;
+    Schalter *getSchalter( int id ) const;
+    Schiene *getSchiene( int id ) const;
+    Timer *getTimer( int id ) const;
+    Tunnel *getTunnel( int id ) const;
+    Umlenkung *getUmlenkung( int id ) const;
+    Trigger *getTrigger( int id ) const;
+    int getNextId();
+    double getRand();
+    int getTickCount() const;
+    void setEnde( Team *zGewinner );
+    Trigger *getRandomTrigger();
+    Trigger *getLastRunnedTrigger() const;
+    Bariere *getRandomBariere();
+    void setZuletztEingeschalteteBariere( Bariere *b );
+    Bariere *getZuletztEingeschalteteBariere() const;
+    void setZuletztAusgeschalteteBariere( Bariere *b );
+    Bariere *getZuletztAusgeschalteteBariere() const;
+    void setZuletztBewegteBariere( Bariere *b );
+    Bariere *getZuletztBewegteBariere() const;
+    Base *getRandomBase();
+    void setLastTeamChangedBase( Base *b );
+    Base *getLastTeamChangedBase() const;
+    Drop *getRandomDrop();
+    void setLastDrop( Drop *d );
+    Drop *getLastDrop() const;
+    void setItemZuletztAufgehoben( GegenstandTyp g );
+    GegenstandTyp getItemZuletztAufgehoben() const;
+    void setItemZuletztAktiviert( GegenstandTyp g );
+    GegenstandTyp getItemZuletztAktiviert() const;
+    GegenstandTyp getItemZuletztGedropt() const;
+    Geschoss *getRandomGeschoss();
+    Geschoss *getGeschossZuletztAbgefeuert() const;
+    void setGeschossZuletztUmgelenkt( Geschoss *g );
+    Geschoss *getGeschossZuletztUmgelenkt() const;
+    Geschoss *getGeschossZuletztBariereGetroffen() const;
+    void setGeschossZuletztTunnelBenutzt( Geschoss *g );
+    Geschoss *getGeschossZuletztTunnelBenutzt() const;
+    void setGeschossZuletztGeschossGetroffen( Geschoss *g );
+    Geschoss *getGeschossZuletztGeschossGetroffen() const;
+    Schalter *getRandomSchalter();
+    void setSchalterZuletztAktiviert( Schalter *s );
+    Schalter *getSchalterZuletztAktiviert() const;
+    Spieler *getRandomSpieler();
+    Spieler *getRandomSpieler( Team *zTeam );
+    void setSpielerZuletztSchadenGemacht( Spieler *s );
+    Spieler *getSpielerZuletztSchadenGemacht() const;
+    void setSpielerZuletztSchadenGenommen( Spieler *s );
+    Spieler *getSpielerZuletztSchadenGenommen() const;
+    void setSpielerZuletztGeheilt( Spieler *s );
+    Spieler *getSpielerZuletztGeheilt() const;
+    void setSpielerZuletztLevelUp( Spieler *s );
+    Spieler *getSpielerZuletztLevelUp() const;
+    void setSpielerZuletztErfahrungBekommen( Spieler *s );
+    Spieler *getSpielerZuletztErfahrungBekommen() const;
+    void setSpielerZuletztGegenstandAktiviert( Spieler *s );
+    Spieler *getSpielerZuletztGegenstandAktiviert() const;
+    void setSpielerZuletztGegenstandAufgehoben( Spieler *s );
+    Spieler *getSpielerZuletztGegenstandAufgehoben() const;
+    void setSpielerZuletztSchalterAktiviert( Spieler *s );
+    Spieler *getSpielerZuletztSchalterAktiviert() const;
+    void setSpielerZuletztTunnelBenutzt( Spieler *s );
+    Spieler *getSpielerZuletztTunnelBenutzt() const;
+    void setSpielerZuletztGestorben( Spieler *s );
+    Spieler *getSpielerZuletztGestorben() const;
+    void setSpielerZuletztWiederbelebt( Spieler *s );
+    Spieler *getSpielerZuletztWiederbelebt() const;
+    void setSpielerZuletztGeschossen( Spieler *s );
+    Spieler *getSpielerZuletztGeschossen() const;
+    Team *getRandomTeam();
+    Timer *getRandomTimer();
+    void setTimerZuletztAbgelaufen( Timer *t );
+    Timer *getTimerZuletztAbgelaufen() const;
+    void setTimerZuletztGestartet( Timer *t );
+    Timer *getTimerZuletztGestartet() const;
+    void setTimerZuletztPausiert( Timer *t );
+    Timer *getTimerZuletztPausiert() const;
+    void setTimerZuletztFortgesetzt( Timer *t );
+    Timer *getTimerZuletztFortgesetzt() const;
+    Tunnel *getRandomTunnel();
+    void setTunnelZuletztBenutzt( Tunnel *t );
+    Tunnel *getTunnelZuletztBenutzt() const;
+    Umlenkung *getRandomUmlenkung();
+    void setUmlenkungZuletztBenutzt( Umlenkung *t );
+    Umlenkung *getUmlenkungZuletztBenutzt() const;
+    // constant
+    int läuft() const override;
+    // Reference Counting
+    SpielV *getThis() override;
+    SpielV *release() override;
+};
+
+#endif

StickmanWorldOnline/SpielChat.cpp

@@ -0,0 +1,165 @@
+#include "SpielChat.h"
+#include <Rahmen.h>
+#include <MausEreignis.h>
+#include <TastaturEreignis.h>
+#include <Text.h>
+#include <Schrift.h>
+#include <Punkt.h>
+#include <Bild.h>
+
+// Inhalt der SpielChat Klasse aus Chat.h
+// Konstruktor
+SpielChat::SpielChat()
+{
+	rahmen = new LRahmen();
+	rahmen->setFarbe( 0xFF909090 );
+	rahmen->setRamenBreite( 1 );
+	rahmen->setSize( 450, 200 );
+	verlauf = new TextFeld();
+	verlauf->setStyle( TextFeld::Style::TextGebiet & ~( TextFeld::Style::Erlaubt | TextFeld::Style::Rahmen | TextFeld::Style::Hintergrund ) );
+	verlauf->setText( "" );
+	verlauf->setSchriftFarbe( 0xFFFFFFFF );
+	verlauf->setSchriftSize( 12 );
+	verlauf->setSize( 446, 174 );
+	nachricht = new TextFeld();
+	nachricht->setStyle( TextFeld::Style::TextFeld & ~TextFeld::Style::Buffered );
+	nachricht->setText( "Drücke TAB um die Bestenliste anzuzeigen.\n" );
+	nachricht->setSchriftFarbe( 0xFF909090 );
+	nachricht->setSchriftSize( 12 );
+	nachricht->setRahmenBreite( 1 );
+	nachricht->setRahmenFarbe( 0xFF909090 );
+	nachricht->setSize( 446, 20 );
+	ref = 1;
+}
+
+// Destruktor
+SpielChat::~SpielChat()
+{
+	rahmen->release();
+	verlauf->release();
+	nachricht->release();
+}
+
+// nicht constant
+void SpielChat::setSchrift( Schrift *zSchrift )
+{
+	verlauf->setSchriftZ( zSchrift->getThis() );
+	nachricht->setSchriftZ( zSchrift->getThis() );
+}
+
+void SpielChat::addNachricht( char *nachricht )
+{
+	verlauf->addZeile( nachricht, 0xFFFFFFFF );
+	verlauf->updateVScroll();
+}
+
+void SpielChat::addNachricht( char *nachricht, int farbe )
+{
+	verlauf->addZeile( nachricht, farbe );
+	verlauf->updateVScroll();
+}
+
+void SpielChat::doPublicMausEreignis( MausEreignis &me )
+{
+	bool vera = me.verarbeitet;
+	verlauf->doPublicMausEreignis( me );
+	nachricht->doPublicMausEreignis( me );
+	if( !vera && me.verarbeitet )
+	{
+		nachricht->setRahmenFarbe( 0xFFFFFFFF );
+		nachricht->setSchriftFarbe( 0xFFFFFFFF );
+		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+		rahmen->setFarbe( 0xFFFFFFFF );
+	}
+	else
+	{
+		nachricht->setRahmenFarbe( 0xFF909090 );
+		nachricht->setSchriftFarbe( 0xFF909090 );
+		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+		rahmen->setFarbe( 0xFF909090 );
+	}
+}
+
+void SpielChat::doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient )
+{
+	if( te.taste == T_Esc )
+		nachricht->removeStyle( TextFeld::Style::Fokus );
+	if( te.id == TE_Release && te.taste == T_Enter && !te.verarbeitet )
+	{
+		if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+		{
+			if( nachricht->zText()->getLength() )
+			{
+				short län = 1 + nachricht->zText()->getLength();
+				char *bytes = new char[ (__int64)län + 1 ];
+				*bytes = 3;
+				for( int i = 1; i <= län; i++ )
+					bytes[ i ] = nachricht->zText()->getText()[ i - 1 ];
+				nachricht->setText( "" );
+				nachricht->setAuswahl( 0, 0 );
+				nachricht->removeStyle( TextFeld::Style::Fokus );
+				zKlient->spielNachricht( län, bytes );
+				delete[] bytes;
+				te.verarbeitet = 1;
+			}
+		}
+		else
+		{
+			nachricht->addStyle( TextFeld::Style::Fokus );
+			nachricht->setAuswahl( 0, nachricht->zText()->getLength() );
+			te.verarbeitet = 1;
+		}
+	}
+	if( !te.verarbeitet )
+		nachricht->doTastaturEreignis( te );
+	if( nachricht->hatStyle( TextFeld::Style::Fokus ) )
+	{
+		nachricht->setRahmenFarbe( 0xFFFFFFFF );
+		nachricht->setSchriftFarbe( 0xFFFFFFFF );
+		verlauf->setVertikalScrollFarbe( 0xFF808080, 0 );
+		rahmen->setFarbe( 0xFFFFFFFF );
+	}
+	else
+	{
+		nachricht->setRahmenFarbe( 0xFF909090 );
+		nachricht->setSchriftFarbe( 0xFF909090 );
+		verlauf->setVertikalScrollFarbe( 0xFF404040, 0 );
+		rahmen->setFarbe( 0xFF909090 );
+	}
+}
+
+void SpielChat::tick( double z )
+{
+	nachricht->tick( z );
+}
+
+void SpielChat::render( Bild &zRObj )
+{
+    rahmen->setPosition( Punkt( 10, zRObj.getHeight() - 210 ) );
+    verlauf->setPosition( rahmen->getX() + 2, rahmen->getY() + 2 );
+    nachricht->setPosition( rahmen->getX() + 2, rahmen->getY() + 178 );
+	rahmen->render( zRObj );
+	verlauf->render( zRObj );
+	nachricht->render( zRObj );
+}
+
+// constant
+bool SpielChat::istAktiv() const
+{
+	return nachricht->hatStyle( TextFeld::Style::Fokus );
+}
+
+// Reference Counting
+SpielChat *SpielChat::getThis()
+{
+	ref++;
+	return this;
+}
+
+SpielChat *SpielChat::relese()
+{
+	ref--;
+	if( !ref )
+		delete this;
+	return 0;
+}

StickmanWorldOnline/SpielChat.h

@@ -0,0 +1,38 @@
+#ifndef Chat_H
+#define Chat_H
+
+#include <KSGNetwork.h>
+#include <TextFeld.h>
+#include <Rahmen.h>
+
+using namespace Framework;
+
+class SpielChat
+{
+private:
+	LRahmen *rahmen = 0;
+	TextFeld *verlauf;
+	TextFeld *nachricht;
+	int ref;
+
+public:
+	// Konstruktor
+	SpielChat();
+	// Destruktor
+	~SpielChat();
+	// nicht constant
+	void setSchrift( Schrift *zSchrift );
+	void addNachricht( char *nachricht );
+	void addNachricht( char *nachricht, int farbe );
+	void doPublicMausEreignis( MausEreignis &me );
+	void doTastaturEreignis( TastaturEreignis &te, KSGClient::SpielServerClient *zKlient );
+	void tick( double z );
+	void render( Bild &zRObj );
+	// constant
+	bool istAktiv() const;
+	// Reference Counting
+	SpielChat *getThis();
+	SpielChat *relese();
+};
+
+#endif

StickmanWorldOnline/SpielKlasse.h

@@ -1,98 +0,0 @@
-#ifndef SpielKlasse_H
-#define SpielKlasse_H
-
-#include "SpielV.h"
-#include "Spieler\Spieler.h"
-#include "Karte\Karte.h"
-#include "Chat\Chat.h"
-#include "Ende\Ende.h"
-#include "Bestenliste\Bestenliste.h"
-#include "..\Netzwerk\STKNachricht.h"
-#include "Schuss\Laser.h"
-#include <Bildschirm.h>
-#include "Objekt/SpielObjekt.h"
-#include <Kamera2D.h>
-#include "Asteroid/Asteroid.h"
-#include "Asteroid/Pixel.h"
-
-class SpielKlasse : public SpielV
-{
-private:
-    struct SaveData
-    {
-        int spielZeit;
-    };
-
-	RCArray< STKNachricht > *stkn;
-	int stkna;
-	Bestenliste *bestenliste;
-	Schrift *schrift;
-    KSGClient::InformationServerClient *infoKlient;
-    KSGClient::SpielServerClient *spielKlient;
-	RCArray< Spieler > *spieler;
-    RCArray< Asteroid > *asteroids;
-	RCArray< Team > *teams;
-	RCArray< SpielObjekt > *objekte;
-    RCArray< Laser > *schüsse;
-	Bildschirm *screen;
-	Karte *map;
-	Kamera2D *kam;
-    Kamera2D *minimap;
-    Welt2D *welt;
-	SpielChat *chat;                                                                                                   
-	Ende *end;
-	SpielerGUI *shipGUI;
-    Datei csv;
-    RCArray< DeadPlayer > *deads;
-    RCArray< Model2DData > *asteroidModels;
-    RCArray< Textur2D > *asteroidTextures;
-    RCArray< Pixel > *pixel;
-    Bild *speedBoost;
-    Bild *shieldBoost;
-	bool rendern;
-	int spielZeit;
-	double rZeit;
-	int spielerAnzahl;
-	int karteId;
-	int ladenProzent;
-	int spielerNummer;
-	char *tasten;
-	bool spielPause;
-    SaveData last;
-    bool setKam;
-	int ref;
-
-	bool istAmLeben() const;
-    void goBackInTime( int zeit );
-    void goToPresence( int zeit );
-    void load();
-    void save();
-    void tick();
-
-public:
-	// Konstruktor
-	SpielKlasse();
-	// Destruktor
-	~SpielKlasse();
-	// nicht constant
-	void lock();
-	void unlock();
-	void setSchrift( Schrift *schrift ) override; // call 4
-	void setBildschirm( Bildschirm *zScreen ) override; // call 3
-	void nachricht( int län, char *bytes ) override;
-	void setKlients( KSGClient::InformationServerClient *infoKlient, KSGClient::SpielServerClient *spielKlient ) override; // call 2
-	void setKarteId( int karteId ) override; // call 1
-	void ladeDaten() override; // call 5
-	void doPublicMausEreignis( MausEreignis &me ) override;
-	void doTastaturEreignis( TastaturEreignis &te ) override;
-	void stknVerarbeitung();
-	bool tick( double zeit ) override;
-	void render( Bild &zRObj ) override;
-	// constant
-	int läuft() const override;
-	// Reference Counting
-	SpielV *getThis() override;
-	SpielV *release() override;
-};
-
-#endif

StickmanWorldOnline/Spieler.cpp

@@ -0,0 +1,934 @@
+#include "Spieler.h"
+#include "Spiel.h"
+#include "BosheitRune.h"
+#include "Enterhaken.h"
+#include "Geist.h"
+#include "Leben.h"
+#include "LebenRune.h"
+#include "Rolle.h"
+#include "Schild.h"
+#include "Schuh.h"
+#include "StrengthRune.h"
+#include "Sturm.h"
+#include "TempoRune.h"
+
+
+Inventar::Inventar()
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        slots[ i ] = KEIN_GEGENSTAND;
+        anzahl[ i ] = 0;
+        abklingzeit[ i ] = 0;
+    }
+    selected = 0;
+}
+
+void Inventar::addItem( GegenstandTyp typ, int anzahl )
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == typ )
+        {
+            this->anzahl[ i ] += anzahl;
+            return;
+        }
+    }
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == KEIN_GEGENSTAND )
+        {
+            slots[ i ] = typ;
+            this->anzahl[ i ] = consumable( typ ) ? anzahl : 1;
+            return;
+        }
+    }
+}
+
+void Inventar::setSelected( int slot )
+{
+    selected = slot;
+    if( selected >= INVENTORY_SLOTS )
+        selected = INVENTORY_SLOTS - 1;
+}
+
+bool Inventar::hatAbklingzeit( GegenstandTyp typ ) const
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+        if( slots[ i ] == typ && abklingzeit[ i ] > 0 )
+            return 1;
+    return 0;
+}
+
+GegenstandTyp Inventar::useItem()
+{
+    if( slots[ selected ] != KEIN_GEGENSTAND && abklingzeit[ selected ] <= 0 )
+    {
+        if( consumable( slots[ selected ] ) )
+        {
+            if( !--anzahl[ selected ] )
+            {
+                GegenstandTyp typ = slots[ selected ];
+                slots[ selected ] = KEIN_GEGENSTAND;
+                return typ;
+            }
+        }
+        abklingzeit[ selected ] = ::abklingzeit( slots[ selected ] );
+        return slots[ selected ];
+    }
+    return KEIN_GEGENSTAND;
+}
+
+void Inventar::tick( double zeit )
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] != KEIN_GEGENSTAND && abklingzeit[ i ] > 0 )
+        {
+            abklingzeit[ i ] -= (float)zeit;
+            if( abklingzeit[ i ] < 0 )
+                abklingzeit[ i ] = 0;
+        }
+    }
+}
+
+bool Inventar::canAddItem( GegenstandTyp typ ) const
+{
+    if( !consumable( typ ) )
+    {
+        for( int i = 0; i < INVENTORY_SLOTS; i++ )
+        {
+            if( slots[ i ] == typ )
+                return 0;
+        }
+    }
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == KEIN_GEGENSTAND || ( slots[ i ] == typ && consumable( typ ) ) )
+            return 1;
+    }
+    return 0;
+}
+
+GegenstandTyp Inventar::selectedItem() const
+{
+    return slots[ selected ];
+}
+
+int Inventar::getItemAnzahl() const
+{
+    int sum = 0;
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+        sum += anzahl[ i ];
+    return sum;
+}
+
+int Inventar::getItemAnzahl( GegenstandTyp typ ) const
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == typ )
+            return anzahl[ i ];
+    }
+    return 0;
+}
+
+GegenstandTyp Inventar::getItemTyp( int index ) const
+{
+    if( index < 0 || index >= INVENTORY_SLOTS )
+        return KEIN_GEGENSTAND;
+    return slots[ index ];
+}
+
+void Inventar::removeItem( GegenstandTyp typ, int anzahl )
+{
+    for( int i = 0; i < INVENTORY_SLOTS; i++ )
+    {
+        if( slots[ i ] == typ )
+        {
+            this->anzahl[ i ] -= anzahl;
+            if( this->anzahl[ i ] < 0 )
+            {
+                slots[ i ] = KEIN_GEGENSTAND;
+                abklingzeit[ i ] = 0;
+            }
+        }
+    }
+}
+
+
+Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
+    : GameObject( SPIELER, spawnX, spawnY, 40, 50 )
+{
+    accountId = 0;
+    spielerNummer = id;
+    this->team = team;
+    amLeben = 1;
+    maxWiederbelebungsZeit = 2;
+    wiederbelebungsZeit = 0;
+    zuletztAufgehoben = KEIN_GEGENSTAND;
+    zuletztAktiviert = KEIN_GEGENSTAND;
+    this->leben = 300;
+    this->maxLeben = 300;
+    level = 1;
+    erfahrung = 0;
+    maxErfahrung = 5;
+    this->spawnX = spawnX;
+    this->spawnY = spawnY;
+    laufTempo = 30;
+    geschossTempo = 100;
+    armor = 0;
+    schadensBonus = 0;
+    lebensraub = 0;
+    lebensRegeneration = 1;
+    abklingZeitVerringerung = 0;
+    color = farbe;
+    kills = 0;
+    tode = 0;
+    treffer = 0;
+    getroffen = 0;
+    schadenGenommen = 0;
+    schadenGemacht = 0;
+    lebenGeheilt = 0;
+    erhalteneErfahrung = 0;
+    itemsAufgehoben = 0;
+    itemsVerwendet = 0;
+    tunnelBenutzt = 0;
+    schalterAktiviert = 0;
+    geschosseGeschossen = 0;
+    for( int i = 0; i < 256; i++ )
+        tastenStand[ i ] = 0;
+    ausrichtung = MITTE;
+}
+
+Spieler::~Spieler()
+{
+    if( team )
+        team->release();
+}
+
+bool Spieler::setTastenStand( unsigned char taste, bool pressed )
+{
+    bool ret = tastenStand[ (int)taste ] != pressed;
+    tastenStand[ (int)taste ] = pressed;
+    if( pressed )
+    {
+        if( taste == 'w' )
+            ausrichtung = OBEN;
+        if( taste == 'a' )
+            ausrichtung = LINKS;
+        if( taste == 's' )
+            ausrichtung = UNTEN;
+        if( taste == 'd' )
+            ausrichtung = RECHTS;
+    }
+    else
+    {
+        if( !tastenStand[ 'w' ] && !tastenStand[ 'a' ] && !tastenStand[ 's' ] && !tastenStand[ 'd' ] )
+            ausrichtung = MITTE;
+        else
+        {
+            if( ( ausrichtung == OBEN && taste == 'w' ) ||
+                ( ausrichtung == LINKS && taste == 'a' ) ||
+                ( ausrichtung == UNTEN && taste == 's' ) ||
+                ( ausrichtung == RECHTS && taste == 'd' ) )
+            {
+                if( tastenStand[ 'w' ] )
+                    ausrichtung = OBEN;
+                if( tastenStand[ 'a' ] )
+                    ausrichtung = LINKS;
+                if( tastenStand[ 's' ] )
+                    ausrichtung = UNTEN;
+                if( tastenStand[ 'd' ] )
+                    ausrichtung = RECHTS;
+            }
+        }
+    }
+    return ret;
+}
+
+void Spieler::setTeam( Team *team )
+{
+    if( this->team )
+        this->team->removeSpieler();
+    this->team->release();
+    this->team = team;
+    this->team->addSpieler();
+}
+
+void Spieler::setAccount( int id )
+{
+    this->accountId = id;
+}
+
+void Spieler::addEffekt( Effect *e )
+{
+    effekte.add( e );
+}
+
+void Spieler::setLaufTempo( float pps )
+{
+    laufTempo = pps;
+}
+
+void Spieler::addErfahrung( float anz, Spiel *zSpiel )
+{
+    erfahrung += anz;
+    zSpiel->setSpielerZuletztErfahrungBekommen( (Spieler *)getThis() );
+    Ereignis *e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    e->addParameter( "Wert", new Float( anz ) );
+    zSpiel->throwEvent( e );
+    while( erfahrung > maxErfahrung )
+        levelUp( zSpiel );
+    while( erfahrung < 0 )
+        levelDown( zSpiel );
+}
+
+void Spieler::levelUp( Spiel *zSpiel )
+{
+    level++;
+    erfahrung -= (float)maxErfahrung;
+    maxErfahrung += ( maxErfahrung / level ) + 2;
+    maxLeben += 20;
+    heilung( 20, zSpiel );
+    if( level <= 10 )
+    {
+        laufTempo += 2;
+        geschossTempo += 2;
+    }
+    if( level <= 50 )
+    {
+        armor += 1;
+        abklingZeitVerringerung += 1;
+    }
+    if( level <= 75 )
+    {
+        schadensBonus += 1;
+        lebensraub += 1;
+    }
+    if( level <= 100 )
+        lebensRegeneration += 0.25f;
+    zSpiel->setSpielerZuletztLevelUp( (Spieler *)getThis() );
+    Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    zSpiel->throwEvent( e );
+}
+
+void Spieler::levelDown( Spiel *zSpiel )
+{
+    if( level <= 100 )
+        lebensRegeneration -= 0.25f;
+    if( level <= 75 )
+    {
+        schadensBonus -= 1;
+        lebensraub -= 1;
+    }
+    if( level <= 50 )
+    {
+        armor -= 1;
+        abklingZeitVerringerung -= 1;
+    }
+    if( level <= 10 )
+    {
+        laufTempo -= 2;
+        geschossTempo -= 2;
+    }
+    maxLeben -= 20;
+    maxErfahrung -= ( maxErfahrung / level ) + 2;
+    erfahrung += (float)maxErfahrung;
+    level--;
+}
+
+void Spieler::addTunnelBenutzung( Spiel *zSpiel )
+{
+    tunnelBenutzt++;
+    zSpiel->setSpielerZuletztTunnelBenutzt( (Spieler *)getThis() );
+}
+
+void Spieler::addSchalterBenutzung( Spiel *zSpiel )
+{
+    schalterAktiviert++;
+    zSpiel->setSpielerZuletztSchalterAktiviert( (Spieler *)getThis() );
+}
+
+// aktualisiert auch die team statistik
+void Spieler::addKill()
+{
+    team->addKill();
+    kills++;
+}
+
+void Spieler::addTreffer( Spiel *zSpiel )
+{
+    addErfahrung( 2, zSpiel );
+    treffer++;
+}
+
+void Spieler::addGetroffen()
+{
+    getroffen++;
+}
+
+void Spieler::move( double zeit )
+{
+    if( istAmLeben() )
+    {
+        if( tastenStand[ 'w' ] && istBeweglich( OBEN ) )
+            y -= laufTempo * (float)zeit;
+        if( tastenStand[ 'a' ] && istBeweglich( LINKS ) )
+            x -= laufTempo * (float)zeit;
+        if( tastenStand[ 's' ] && istBeweglich( UNTEN ) )
+            y += laufTempo * (float)zeit;
+        if( tastenStand[ 'd' ] && istBeweglich( RECHTS ) )
+            x += laufTempo * (float)zeit;
+        for( auto e = effekte.getIterator(); e; e++ )
+            e->move( zeit );
+    }
+}
+
+void Spieler::wiederbelebung( Spiel *zSpiel )
+{
+    amLeben = 1;
+    leben = (float)maxLeben;
+    zSpiel->setSpielerZuletztWiederbelebt( (Spieler *)getThis() );
+    Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    zSpiel->throwEvent( e );
+}
+
+void Spieler::tick( double zeit, Spiel *zSpiel )
+{
+    if( istAmLeben() )
+    {
+        for( int i = 0; i < effekte.getEintragAnzahl(); i++ )
+        {
+            if( effekte.z( i )->tick( zeit, zSpiel ) && istAmLeben() )
+            {
+                effekte.remove( i );
+                i--;
+            }
+            if( !istAmLeben() )
+                break;
+        }
+        if( tastenStand[ ' ' ] )
+            useItem( zSpiel );
+        if( tastenStand[ 'e' ] )
+            zSpiel->spielerActivate( this );
+        heilung( lebensRegeneration * (float)zeit, zSpiel );
+    }
+    else
+    {
+        effekte.leeren();
+        wiederbelebungsZeit -= (float)zeit;
+        if( wiederbelebungsZeit <= 0 )
+        {
+            wiederbelebung( zSpiel );
+        }
+    }
+}
+
+void Spieler::useItem( Spiel *zSpiel )
+{
+    if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
+    {
+        zSpiel->setSpielerZuletztGegenstandAktiviert( (Spieler *)getThis() );
+        itemsVerwendet++;
+        GegenstandTyp typ = inv.useItem();
+        zSpiel->setItemZuletztAktiviert( typ );
+        switch( typ )
+        {
+        case PFEIL:
+            geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
+            break;
+        case LEBEN:
+            addEffekt( new LebenEffect( this ) );
+            break;
+        case SCHILD:
+            addEffekt( new SchildEffect( this ) );
+            break;
+        case SCHUH:
+            addEffekt( new SchuhEffect( this ) );
+            break;
+        case GEIST:
+            addEffekt( new GeistEffect( this ) );
+            break;
+        case KUGEL:
+            geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
+            break;
+        case ROLLE:
+            addEffekt( new RolleEffect( this, getAusrichtung() ) );
+            break;
+        case STURM:
+            addEffekt( new SturmEffect( this, getAusrichtung() ) );
+            break;
+        case DRACHENAUGE:
+            geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
+            break;
+        case FEUERBALL:
+            geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
+            break;
+        case ENTERHAKEN:
+            addEffekt( new EnterhakenEffect( this, getAusrichtung() ) );
+            break;
+        case MINE:
+            geschosseGeschossen++;
+            zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
+            zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x, (int)y, (Spieler *)getThis() ) );
+            break;
+        default:
+            break;
+        }
+        Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
+        e->addParameter( "Betroffener Spieler", getThis() );
+        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
+        zSpiel->throwEvent( e );
+    }
+}
+
+bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
+{
+    if( storable( typ ) )
+    {
+        if( inv.canAddItem( typ ) )
+        {
+            zSpiel->setItemZuletztAufgehoben( typ );
+            zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
+            itemsAufgehoben += anz;
+            inv.addItem( typ, anz );
+            Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
+            e->addParameter( "Betroffener Spieler", getThis() );
+            e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
+            e->addParameter( "Anzahl", new Integer( anz ) );
+            zSpiel->throwEvent( e );
+            return 1;
+        }
+    }
+    else
+    {
+        zSpiel->setItemZuletztAufgehoben( typ );
+        zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
+        itemsAufgehoben += anz;
+        Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
+        e->addParameter( "Betroffener Spieler", getThis() );
+        e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
+        e->addParameter( "Anzahl", new Integer( anz ) );
+        zSpiel->throwEvent( e );
+        for( int i = 0; i < anz; i++ )
+        {
+            Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
+            e->addParameter( "Betroffener Spieler", getThis() );
+            e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
+            zSpiel->throwEvent( e );
+            itemsVerwendet++;
+            switch( typ )
+            {
+            case RWEISHEIT:
+                addErfahrung( 2, zSpiel );
+                break;
+            case RSTRENGTH:
+                addEffekt( new StrengthRuneEffect( this ) );
+                break;
+            case RBOSHEIT:
+                addEffekt( new BosheitRuneEffect( this ) );
+                break;
+            case RLEBEN:
+                addEffekt( new LebenRuneEffect( this ) );
+                break;
+            case RTEMPO:
+                addEffekt( new TempoRuneEffect( this ) );
+                break;
+            default:
+                break;
+            }
+        }
+    }
+    return 0;
+}
+
+// heilt auch um den lebensraub prozentsatz
+void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
+{
+    zSpiel->setSpielerZuletztSchadenGemacht( (Spieler *)getThis() );
+    schadenGemacht += schaden;
+    heilung( schaden / 100 * lebensraub, zSpiel );
+    Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    e->addParameter( "Wert", new Float( schaden ) );
+    zSpiel->throwEvent( e );
+}
+
+// zieht die rüstung ab
+void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel )
+{
+    if( !isVerwundbar( r ) || !amLeben )
+        return;
+    if( zVerursacher )
+        schaden += schaden / 100 * zVerursacher->getSchadenBonus();
+    schaden -= schaden / 100 * armor;
+    schaden = leben < schaden ? leben : schaden;
+    schadenGenommen += schaden;
+    leben -= schaden;
+    zSpiel->setSpielerZuletztSchadenGenommen( (Spieler *)getThis() );
+    if( zVerursacher )
+        zVerursacher->addGemachterSchaden( schaden, zSpiel );
+    Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
+    e->addParameter( "Betroffener Spieler", getThis() );
+    e->addParameter( "Wert", new Float( schaden ) );
+    zSpiel->throwEvent( e );
+    if( leben == 0 )
+    {
+        wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
+        wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
+        team->addTod();
+        amLeben = 0;
+        tode++;
+        zSpiel->setSpielerZuletztGestorben( (Spieler *)getThis() );
+        if( zVerursacher )
+            zVerursacher->addKill();
+        Ereignis *e = new Ereignis( SPIELER_STIRBT );
+        e->addParameter( "Betroffener Spieler", getThis() );
+        zSpiel->throwEvent( e );
+    }
+}
+
+void Spieler::heilung( float heal, Spiel *zSpiel )
+{
+    if( amLeben )
+    {
+        lebenGeheilt += heal;
+        leben += heal;
+        zSpiel->setSpielerZuletztGeheilt( (Spieler *)getThis() );
+        Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
+        e->addParameter( "Betroffener Spieler", getThis() );
+        e->addParameter( "Wert", new Float( heal ) );
+        zSpiel->throwEvent( e );
+    }
+}
+
+void Spieler::setSchadenBonus( float bonus )
+{
+    schadensBonus = bonus;
+}
+
+void Spieler::setLebensRaub( float raub )
+{
+    lebensraub = raub;
+}
+
+void Spieler::setGeschossTempo( float tempo )
+{
+    geschossTempo = tempo;
+}
+
+void Spieler::setArmor( float armor )
+{
+    this->armor = armor;
+}
+
+void Spieler::setLebensRegeneration( float reg )
+{
+    lebensRegeneration = reg;
+}
+
+void Spieler::setName( const char *name )
+{
+    this->name = name;
+}
+
+void Spieler::setLevel( int level, Spiel *zSpiel )
+{
+    if( level < 0 || level > 100 )
+        return;
+    while( level > this->level )
+        levelUp( zSpiel );
+    while( level < this->level )
+        levelDown( zSpiel );
+    erfahrung = 0;
+}
+
+void Spieler::removeItem( GegenstandTyp typ, int anzahl )
+{
+    inv.removeItem( typ, anzahl );
+}
+
+void Spieler::setLeben( float leben )
+{
+    this->leben = leben;
+    if( this->leben < 0 )
+    {
+        this->leben = 0;
+        // the player is now undead :D
+    }
+    if( this->leben > maxLeben )
+        this->leben = (float)maxLeben;
+}
+
+void Spieler::setMaxLeben( int leben )
+{
+    maxLeben = leben;
+    if( maxLeben < 1 )
+        maxLeben = 1;
+    if( this->leben > maxLeben )
+        this->leben = (float)maxLeben;
+}
+
+void Spieler::setErfahrung( float erf, Spiel *zSpiel )
+{
+    erfahrung = erf;
+    while( erfahrung < 0 )
+        levelDown( zSpiel );
+    while( erfahrung >= maxErfahrung )
+        levelUp( zSpiel );
+}
+
+void Spieler::setMaxErfahrung( int erf )
+{
+    this->maxErfahrung = erf;
+}
+
+void Spieler::setAbklingZeitVerringerung( float verringerung )
+{
+    abklingZeitVerringerung = verringerung;
+}
+
+float Spieler::getLebensRegenneration() const
+{
+    return lebensRegeneration;
+}
+
+float Spieler::getArmor() const
+{
+    return armor;
+}
+
+float Spieler::getGeschossTempo() const
+{
+    return geschossTempo;
+}
+
+float Spieler::getLebensRaub() const
+{
+    return lebensraub;
+}
+
+float Spieler::getSchadenBonus() const
+{
+    return schadensBonus;
+}
+
+int Spieler::getSpielerNummer() const
+{
+    return spielerNummer;
+}
+
+Team *Spieler::zTeam() const
+{
+    return team;
+}
+
+Team *Spieler::getTeam() const
+{
+    return team ? (Team *)team->getThis() : 0;
+}
+
+int Spieler::getFarbe() const
+{
+    return color;
+}
+
+int Spieler::getAccountId() const
+{
+    return accountId;
+}
+
+int Spieler::getPunkte() const
+{
+    return kills - tode + ( treffer - getroffen ) / 2;
+}
+
+bool Spieler::istAmLeben() const
+{
+    return amLeben;
+}
+
+float Spieler::getLaufTempo() const
+{
+    return laufTempo;
+}
+
+bool Spieler::isVerwundbar( Richtung r ) const
+{
+    bool verwundbar = 1;
+    for( auto e = effekte.getIterator(); e; e++ )
+    {
+        verwundbar &= e->istSpielerVerwundbar( r );
+        if( !verwundbar )
+            return 0;
+    }
+    return 1;
+}
+
+bool Spieler::istBeweglich( Richtung r ) const
+{
+    bool beweglich = 1;
+    for( auto e = effekte.getIterator(); e; e++ )
+    {
+        beweglich &= e->istSpielerBeweglich( r );
+        if( !beweglich )
+            return 0;
+    }
+    return 1;
+}
+
+bool Spieler::istSichtbar( Team *zTeam ) const
+{
+    bool sichtbar = 1;
+    for( auto e = effekte.getIterator(); e; e++ )
+    {
+        sichtbar &= e->istSpielerSichtbar( zTeam );
+        if( !sichtbar )
+            return 0;
+    }
+    return 1;
+}
+
+bool Spieler::istGegenstandErlaubt( GegenstandTyp typ ) const
+{
+    bool erlaubt = !brauchtRichtung( typ ) || ausrichtung != MITTE;
+    for( auto e = effekte.getIterator(); e; e++ )
+    {
+        erlaubt &= e->istGegenstandErlaubt( typ );
+        if( !erlaubt )
+            return 0;
+    }
+    return !inv.hatAbklingzeit( typ );
+}
+
+Richtung Spieler::getAusrichtung() const
+{
+    return ausrichtung;
+}
+
+float Spieler::getAbklingZeitVerringerung() const
+{
+    return abklingZeitVerringerung;
+}
+
+int Spieler::getId() const
+{
+    return spielerNummer;
+}
+
+int Spieler::getLevel() const
+{
+    return level;
+}
+
+float Spieler::getLeben() const
+{
+    return leben;
+}
+
+int Spieler::getMaxLeben() const
+{
+    return maxLeben;
+}
+
+float Spieler::getErfahrung() const
+{
+    return erfahrung;
+}
+
+int Spieler::getMaxErfahrung() const
+{
+    return maxErfahrung;
+}
+
+int Spieler::getTode() const
+{
+    return tode;
+}
+
+int Spieler::getKills() const
+{
+    return kills;
+}
+
+int Spieler::getTreffer() const
+{
+    return treffer;
+}
+
+int Spieler::getGetroffen() const
+{
+    return getroffen;
+}
+
+float Spieler::getErlittenerSchaden() const
+{
+    return schadenGenommen;
+}
+
+float Spieler::getGemachterSchaden() const
+{
+    return schadenGemacht;
+}
+
+float Spieler::getGeheiltesLeben() const
+{
+    return lebenGeheilt;
+}
+
+int Spieler::getItemsAufgehoben() const
+{
+    return itemsAufgehoben;
+}
+
+int Spieler::getItemsVerwendet() const
+{
+    return itemsVerwendet;
+}
+
+int Spieler::getItemsInInventory() const
+{
+    return inv.getItemAnzahl();
+}
+
+int Spieler::getItemsInInventory( GegenstandTyp typ ) const
+{
+    return inv.getItemAnzahl( typ );
+}
+
+int Spieler::getTunnelBenutzt() const
+{
+    return tunnelBenutzt;
+}
+
+int Spieler::getSchalterAktiviert() const
+{
+    return schalterAktiviert;
+}
+
+int Spieler::getGeschossen() const
+{
+    return geschosseGeschossen;
+}
+
+GegenstandTyp Spieler::getInventorySlot( int index ) const
+{
+    return inv.getItemTyp( index );
+}
+
+const char *Spieler::getName() const
+{
+    return name;
+}

StickmanWorldOnline/Spieler.h

@@ -0,0 +1,163 @@
+#pragma once
+
+#include "Team.h"
+#include "Gegenstand.h"
+#include "Effect.h"
+#include <Array.h>
+
+class Spiel;
+
+#define INVENTORY_SLOTS 8
+
+class Inventar
+{
+private:
+    GegenstandTyp slots[ INVENTORY_SLOTS ];
+    int anzahl[ INVENTORY_SLOTS ];
+    float abklingzeit[ INVENTORY_SLOTS ];
+    int selected;
+
+public:
+    Inventar();
+    void addItem( GegenstandTyp typ, int anzahl );
+    void setSelected( int slot );
+    bool hatAbklingzeit( GegenstandTyp typ ) const;
+    GegenstandTyp useItem();
+    void tick( double zeit );
+    bool canAddItem( GegenstandTyp typ ) const;
+    GegenstandTyp selectedItem() const;
+    int getItemAnzahl() const;
+    int getItemAnzahl( GegenstandTyp typ ) const;
+    GegenstandTyp getItemTyp( int index ) const;
+    void removeItem( GegenstandTyp typ, int anzahl );
+};
+
+class Spieler : public GameObject
+{
+private:
+    RCArray< Effect > effekte;
+    int accountId;
+    int spielerNummer;
+    Team *team;
+    bool amLeben;
+    int maxWiederbelebungsZeit;
+    float wiederbelebungsZeit;
+    GegenstandTyp zuletztAufgehoben;
+    GegenstandTyp zuletztAktiviert;
+    float leben;
+    int maxLeben;
+    int level;
+    float erfahrung;
+    int maxErfahrung;
+    int spawnX;
+    int spawnY;
+    float laufTempo;
+    float geschossTempo;
+    float armor;
+    float schadensBonus;
+    float lebensraub;
+    float lebensRegeneration;
+    float abklingZeitVerringerung;
+    int color;
+    int kills;
+    int tode;
+    int treffer;
+    int getroffen;
+    float schadenGenommen;
+    float schadenGemacht;
+    float lebenGeheilt;
+    float erhalteneErfahrung;
+    int itemsAufgehoben;
+    int itemsVerwendet;
+    int tunnelBenutzt;
+    int schalterAktiviert;
+    int geschosseGeschossen;
+    bool tastenStand[ 256 ];
+    Text name;
+    Richtung ausrichtung;
+    Inventar inv;
+
+public:
+    Spieler( int id, Team *team, int spawnX, int spawnY, int farbe );
+    ~Spieler();
+    bool setTastenStand( unsigned char taste, bool pressed );
+    void setTeam( Team *team );
+    void setAccount( int id );
+    void addEffekt( Effect *e );
+    void setLaufTempo( float pps );
+    void addErfahrung( float anz, Spiel *zSpiel );
+    void levelUp( Spiel *zSpiel );
+    void levelDown( Spiel *zSpiel );
+    void addTunnelBenutzung( Spiel *zSpiel );
+    void addSchalterBenutzung( Spiel *zSpiel );
+    // aktualisiert auch die team statistik
+    void addKill();
+    void addTreffer( Spiel *zSpiel );
+    void addGetroffen();
+    void move( double zeit );
+    void wiederbelebung( Spiel *zSpiel );
+    void tick( double zeit, Spiel *zSpiel );
+    void useItem( Spiel *zSpiel );
+    bool addItem( GegenstandTyp typ, int anz, Spiel *zSpiel );
+    // heilt auch um den lebensraub prozentsatz
+    void addGemachterSchaden( float schaden, Spiel *zSpiel );
+    // zieht die rüstung ab
+    void nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel );
+    void heilung( float heal, Spiel *zSpiel );
+    void setSchadenBonus( float bonus );
+    void setLebensRaub( float raub );
+    void setGeschossTempo( float tempo );
+    void setArmor( float armor );
+    void setLebensRegeneration( float reg );
+    void setName( const char *name );
+    // setzt alle eigenschafften, die mit dem level gesetzt werden entsprechend
+    void setLevel( int level, Spiel *zSpiel );
+    void removeItem( GegenstandTyp typ, int anzahl );
+    void setLeben( float leben );
+    void setMaxLeben( int leben );
+    // steuert auch level up oder level downs bei negativer erfahrung
+    void setErfahrung( float erf, Spiel *zSpiel );
+    void setMaxErfahrung( int erf );
+    void setAbklingZeitVerringerung( float verringerung );
+    float getLebensRegenneration() const;
+    float getArmor() const;
+    float getGeschossTempo() const;
+    float getLebensRaub() const;
+    float getSchadenBonus() const;
+    int getSpielerNummer() const;
+    Team *zTeam() const;
+    Team *getTeam() const;
+    int getFarbe() const;
+    int getAccountId() const;
+    int getPunkte() const;
+    bool istAmLeben() const;
+    float getLaufTempo() const;
+    bool isVerwundbar( Richtung r ) const;
+    bool istBeweglich( Richtung r ) const;
+    bool istSichtbar( Team *zTeam ) const;
+    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/StickmanWorldOnline.vcxproj

@@ -19,26 +19,97 @@
     </ProjectConfiguration>
   </ItemGroup>
   <ItemGroup>
+    <ClCompile Include="Aktionen.cpp" />
+    <ClCompile Include="Bariere.cpp" />
+    <ClCompile Include="Base.cpp" />
+    <ClCompile Include="BosheitRune.cpp" />
+    <ClCompile Include="Brand.cpp" />
     <ClCompile Include="DLLStart.cpp" />
+    <ClCompile Include="DrachenAuge.cpp" />
+    <ClCompile Include="Drop.cpp" />
+    <ClCompile Include="Effect.cpp" />
+    <ClCompile Include="Ende.cpp" />
+    <ClCompile Include="Enterhaken.cpp" />
+    <ClCompile Include="Ereignis.cpp" />
+    <ClCompile Include="GameObjekt.cpp" />
+    <ClCompile Include="Gegenstand.cpp" />
+    <ClCompile Include="Geist.cpp" />
+    <ClCompile Include="Geschoss.cpp" />
     <ClCompile Include="Initialisierung.cpp" />
+    <ClCompile Include="Leben.cpp" />
+    <ClCompile Include="LebenRune.cpp" />
+    <ClCompile Include="Reader.cpp" />
+    <ClCompile Include="Rolle.cpp" />
+    <ClCompile Include="Schalter.cpp" />
+    <ClCompile Include="Schiene.cpp" />
+    <ClCompile Include="Schild.cpp" />
+    <ClCompile Include="Schuh.cpp" />
+    <ClCompile Include="Spiel.cpp" />
+    <ClCompile Include="SpielChat.cpp" />
+    <ClCompile Include="Spieler.cpp" />
     <ClCompile Include="StatistikChat.cpp" />
     <ClCompile Include="StatistikTabelle.cpp" />
+    <ClCompile Include="STKNachricht.cpp" />
+    <ClCompile Include="StrengthRune.cpp" />
+    <ClCompile Include="Sturm.cpp" />
+    <ClCompile Include="Team.cpp" />
+    <ClCompile Include="TempoRune.cpp" />
+    <ClCompile Include="Timer.cpp" />
+    <ClCompile Include="Trigger.cpp" />
+    <ClCompile Include="Tunnel.cpp" />
+    <ClCompile Include="Umlenkung.cpp" />
+    <ClCompile Include="Variablen.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="Aktionen.h" />
     <ClInclude Include="Aufzeichnung.h" />
+    <ClInclude Include="Bariere.h" />
+    <ClInclude Include="Base.h" />
+    <ClInclude Include="BosheitRune.h" />
+    <ClInclude Include="Brand.h" />
     <ClInclude Include="Dialog.h" />
+    <ClInclude Include="DrachenAuge.h" />
+    <ClInclude Include="Drop.h" />
     <ClInclude Include="Editor.h" />
     <ClInclude Include="EditorKarte.h" />
     <ClInclude Include="EditorKlient.h" />
+    <ClInclude Include="Effect.h" />
+    <ClInclude Include="Ende.h" />
+    <ClInclude Include="Enterhaken.h" />
+    <ClInclude Include="Ereignis.h" />
+    <ClInclude Include="GameObject.h" />
+    <ClInclude Include="Gegenstand.h" />
+    <ClInclude Include="Geist.h" />
+    <ClInclude Include="Geschoss.h" />
     <ClInclude Include="HistorieStatistik.h" />
     <ClInclude Include="Initialisierung.h" />
     <ClInclude Include="Interface.h" />
+    <ClInclude Include="Leben.h" />
+    <ClInclude Include="LebenRune.h" />
+    <ClInclude Include="Reader.h" />
     <ClInclude Include="RightTools.h" />
-    <ClInclude Include="SpielKlasse.h" />
+    <ClInclude Include="Rolle.h" />
+    <ClInclude Include="Schalter.h" />
+    <ClInclude Include="Schiene.h" />
+    <ClInclude Include="Schild.h" />
+    <ClInclude Include="Schuh.h" />
+    <ClInclude Include="SpielChat.h" />
+    <ClInclude Include="Spiel.h" />
+    <ClInclude Include="Spieler.h" />
     <ClInclude Include="SpielStatistik.h" />
     <ClInclude Include="SpielStatistikDaten.h" />
     <ClInclude Include="StatistikChat.h" />
     <ClInclude Include="StatistikTabelle.h" />
+    <ClInclude Include="STKNachricht.h" />
+    <ClInclude Include="StrengthRune.h" />
+    <ClInclude Include="Sturm.h" />
+    <ClInclude Include="Team.h" />
+    <ClInclude Include="TempoRune.h" />
+    <ClInclude Include="Timer.h" />
+    <ClInclude Include="Trigger.h" />
+    <ClInclude Include="Tunnel.h" />
+    <ClInclude Include="Umlenkung.h" />
+    <ClInclude Include="Variablen.h" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>15.0</VCProjectVersion>

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -1,87 +1,294 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Quelldateien">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Headerdateien">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;ipp;xsd</Extensions>
-    </Filter>
-    <Filter Include="Ressourcendateien">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-    <Filter Include="Headerdateien\Editor">
+    <Filter Include="Editor">
       <UniqueIdentifier>{11e31a9e-2489-407d-a303-c83976d905d1}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Headerdateien\Aufzeichnung">
+    <Filter Include="Aufzeichnung">
       <UniqueIdentifier>{26bdcc05-4e4c-4404-a042-011efeee9e28}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Headerdateien\Spiel">
+    <Filter Include="Statistik">
+      <UniqueIdentifier>{31c87e6a-c17a-4812-8869-8a9838337660}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel">
       <UniqueIdentifier>{cfc385f8-b6a4-49ce-90e7-39d76346152c}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Headerdateien\Statistik">
-      <UniqueIdentifier>{31c87e6a-c17a-4812-8869-8a9838337660}</UniqueIdentifier>
+    <Filter Include="Spiel\Auslöser">
+      <UniqueIdentifier>{2d885bf7-c43c-453d-968a-bf231ea5d721}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Effekte">
+      <UniqueIdentifier>{3ca782f2-08fd-43c0-a35e-dbcffd906dc8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Karte">
+      <UniqueIdentifier>{5e4f2ec9-5020-4f12-8ee5-fe9ccbf2fc34}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Spiel\Objekte">
+      <UniqueIdentifier>{8fe817ac-57bb-4131-bae3-65f2d7e56d8f}</UniqueIdentifier>
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="DLLStart.cpp">
-      <Filter>Quelldateien</Filter>
+    <ClCompile Include="Ende.cpp">
+      <Filter>Spiel</Filter>
     </ClCompile>
-    <ClCompile Include="Initialisierung.cpp">
-      <Filter>Quelldateien</Filter>
+    <ClCompile Include="SpielChat.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+    <ClCompile Include="STKNachricht.cpp">
+      <Filter>Spiel</Filter>
     </ClCompile>
     <ClCompile Include="StatistikChat.cpp">
-      <Filter>Quelldateien</Filter>
+      <Filter>Statistik</Filter>
     </ClCompile>
     <ClCompile Include="StatistikTabelle.cpp">
-      <Filter>Quelldateien</Filter>
+      <Filter>Statistik</Filter>
+    </ClCompile>
+    <ClCompile Include="DLLStart.cpp" />
+    <ClCompile Include="Initialisierung.cpp" />
+    <ClCompile Include="Aktionen.cpp">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClCompile>
+    <ClCompile Include="Ereignis.cpp">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClCompile>
+    <ClCompile Include="Trigger.cpp">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClCompile>
+    <ClCompile Include="Variablen.cpp">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClCompile>
+    <ClCompile Include="BosheitRune.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Brand.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="DrachenAuge.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Effect.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Enterhaken.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Geist.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Leben.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="LebenRune.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Rolle.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Schild.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Schuh.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="StrengthRune.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Sturm.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="TempoRune.cpp">
+      <Filter>Spiel\Effekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Reader.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
+    <ClCompile Include="Bariere.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Base.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Drop.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="GameObjekt.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Gegenstand.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Geschoss.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Schalter.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Schiene.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Spieler.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Team.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Timer.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Tunnel.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Umlenkung.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Spiel.cpp">
+      <Filter>Spiel</Filter>
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Initialisierung.h">
-      <Filter>Headerdateien</Filter>
-    </ClInclude>
     <ClInclude Include="Aufzeichnung.h">
-      <Filter>Headerdateien\Aufzeichnung</Filter>
+      <Filter>Aufzeichnung</Filter>
     </ClInclude>
     <ClInclude Include="Dialog.h">
-      <Filter>Headerdateien\Editor</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="Editor.h">
-      <Filter>Headerdateien\Editor</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="EditorKarte.h">
-      <Filter>Headerdateien\Editor</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="EditorKlient.h">
-      <Filter>Headerdateien\Editor</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="HistorieStatistik.h">
-      <Filter>Headerdateien\Statistik</Filter>
+      <Filter>Statistik</Filter>
     </ClInclude>
     <ClInclude Include="Interface.h">
-      <Filter>Headerdateien\Editor</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="RightTools.h">
-      <Filter>Headerdateien\Editor</Filter>
-    </ClInclude>
-    <ClInclude Include="SpielKlasse.h">
-      <Filter>Headerdateien\Spiel</Filter>
+      <Filter>Editor</Filter>
     </ClInclude>
     <ClInclude Include="SpielStatistik.h">
-      <Filter>Headerdateien\Statistik</Filter>
+      <Filter>Statistik</Filter>
     </ClInclude>
     <ClInclude Include="SpielStatistikDaten.h">
-      <Filter>Headerdateien\Statistik</Filter>
+      <Filter>Statistik</Filter>
     </ClInclude>
     <ClInclude Include="StatistikChat.h">
-      <Filter>Headerdateien\Statistik</Filter>
+      <Filter>Statistik</Filter>
     </ClInclude>
     <ClInclude Include="StatistikTabelle.h">
-      <Filter>Headerdateien\Statistik</Filter>
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="STKNachricht.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielChat.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="Ende.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="Initialisierung.h" />
+    <ClInclude Include="Aktionen.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Ereignis.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Trigger.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="Variablen.h">
+      <Filter>Spiel\Auslöser</Filter>
+    </ClInclude>
+    <ClInclude Include="BosheitRune.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Brand.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="DrachenAuge.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Effect.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Enterhaken.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Geist.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Leben.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="LebenRune.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Rolle.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Schild.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Schuh.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="StrengthRune.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Sturm.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="TempoRune.h">
+      <Filter>Spiel\Effekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Reader.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+    <ClInclude Include="Spiel.h">
+      <Filter>Spiel</Filter>
+    </ClInclude>
+    <ClInclude Include="Bariere.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Base.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Drop.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="GameObject.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Gegenstand.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Geschoss.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Schalter.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Schiene.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Spieler.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Team.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Timer.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Tunnel.h">
+      <Filter>Spiel\Objekte</Filter>
+    </ClInclude>
+    <ClInclude Include="Umlenkung.h">
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
   </ItemGroup>
 </Project>

StickmanWorldOnline/StrengthRune.cpp

@@ -0,0 +1,16 @@
+#include "StrengthRune.h"
+#include "Spieler.h"
+
+
+StrengthRuneEffect::StrengthRuneEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    zSpieler->setArmor( zSpieler->getArmor() + 7 );
+    zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() + 3 );
+}
+
+StrengthRuneEffect::~StrengthRuneEffect()
+{
+    zSpieler->setArmor( zSpieler->getArmor() - 7 );
+    zSpieler->setSchadenBonus( zSpieler->getSchadenBonus() - 3 );
+}

StickmanWorldOnline/StrengthRune.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Effect.h"
+
+class StrengthRuneEffect : public Effect
+{
+private:
+
+public:
+    StrengthRuneEffect( Spieler *zSpieler );
+    ~StrengthRuneEffect();
+};

StickmanWorldOnline/Sturm.cpp

@@ -0,0 +1,61 @@
+#include "Sturm.h"
+#include "Spieler.h"
+#include "Spiel.h"
+
+SturmEffect::SturmEffect( Spieler *zSpieler, Richtung r )
+    : Effect( zSpieler, 2.f + ( 2.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    this->r = r;
+}
+
+SturmEffect::~SturmEffect()
+{}
+
+bool SturmEffect::istSpielerBeweglich( Richtung r )
+{
+    return false;
+}
+
+bool SturmEffect::istSpielerVerwundbar( Richtung r )
+{
+    return r != this->r;
+}
+
+void SturmEffect::move( double time )
+{
+    switch( r )
+    {
+    case OBEN:
+        zSpieler->setY( zSpieler->getY() - ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case RECHTS:
+        zSpieler->setX( zSpieler->getX() + ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case UNTEN:
+        zSpieler->setY( zSpieler->getY() + ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    case LINKS:
+        zSpieler->setX( zSpieler->getX() - ( 75 + zSpieler->getLaufTempo() ) * (float)time );
+        break;
+    default:
+        break;
+    }
+}
+
+bool SturmEffect::tick( double time, Spiel *zSpiel )
+{
+    for( auto s = zSpiel->getSpieler(); s; s++ )
+    {
+        if( s->zTeam() != zSpieler->zTeam() )
+        {
+            if( s->intersectsWith( zSpieler ) )
+                s->nimmSchaden( 100 * (float)time, zSpieler, r, zSpiel );
+        }
+    }
+    return Effect::tick( time, zSpiel );
+}
+
+bool SturmEffect::istGegenstandErlaubt( GegenstandTyp typ )
+{
+    return typ != ROLLE && typ != ENTERHAKEN;
+}

StickmanWorldOnline/Sturm.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "Effect.h"
+
+class SturmEffect : public Effect
+{
+private:
+    Richtung r;
+
+public:
+    SturmEffect( Spieler *zSpieler, Richtung r );
+    ~SturmEffect();
+    bool istSpielerBeweglich( Richtung r ) override;
+    bool istSpielerVerwundbar( Richtung r ) override;
+    void move( double time ) override;
+    bool tick( double time, Spiel *zSpiel ) override;
+    bool istGegenstandErlaubt( GegenstandTyp typ ) override;
+};

StickmanWorldOnline/Team.cpp

@@ -0,0 +1,94 @@
+#include "Team.h"
+
+
+Team::Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit, int farbe, const char *name )
+    : Variable( TEAM )
+{
+    teamNummer = id;
+    this->maxSpielerAnzahl = maxSpielerAnzahl;
+    spielerAnzahl = 0;
+    this->punkte = punkte;
+    kills = 0;
+    tode = 0;
+    this->maxWiederbelebungsZeit = maxWiederbelebungsZeit;
+    this->farbe = farbe;
+    this->name = name;
+}
+
+void Team::setMaxWiederbelebungsZeit( float sekunden )
+{
+    this->maxWiederbelebungsZeit = sekunden;
+}
+
+void Team::addSpieler()
+{
+    spielerAnzahl++;
+}
+
+void Team::removeSpieler()
+{
+    spielerAnzahl--;
+}
+
+void Team::addTod()
+{
+    punkte -= 4;
+    maxWiederbelebungsZeit++;
+    tode++;
+}
+
+void Team::addKill()
+{
+    punkte += 2;
+    kills++;
+}
+
+void Team::addPunkte( int punkte )
+{
+    this->punkte += punkte;
+}
+
+void Team::setPunkte( int punkte )
+{
+    this->punkte = punkte;
+}
+
+Text Team::getName() const
+{
+    return name;
+}
+
+float Team::getMaxWiederbelebungsZeit() const
+{
+    return maxWiederbelebungsZeit;
+}
+
+int Team::getTode() const
+{
+    return tode;
+}
+
+int Team::getKills() const
+{
+    return kills;
+}
+
+int Team::getPunkte() const
+{
+    return punkte;
+}
+
+int Team::getTeamNummer() const
+{
+    return teamNummer;
+}
+
+int Team::getSpielerAnzahl() const
+{
+    return spielerAnzahl;
+}
+
+int Team::getFarbe() const
+{
+    return farbe;
+}

StickmanWorldOnline/Team.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "Variablen.h"
+
+class Team : public Variable
+{
+private:
+    float maxWiederbelebungsZeit;
+    int tode;
+    int kills;
+    int punkte;
+    int teamNummer;
+    int spielerAnzahl;
+    int maxSpielerAnzahl;
+    int farbe;
+    Text name;
+
+public:
+    Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit, int farbe, const char *name );
+    void setMaxWiederbelebungsZeit( float sekunden );
+    void addSpieler();
+    void removeSpieler();
+    void addTod();
+    void addKill();
+    void addPunkte( int punkte );
+    void setPunkte( int punkte );
+    Text getName() const;
+    float getMaxWiederbelebungsZeit() const;
+    int getTode() const;
+    int getKills() const;
+    int getPunkte() const;
+    int getTeamNummer() const;
+    int getSpielerAnzahl() const;
+    int getFarbe() const;
+};

StickmanWorldOnline/TempoRune.cpp

@@ -0,0 +1,16 @@
+#include "TempoRune.h"
+#include "Spieler.h"
+
+
+TempoRuneEffect::TempoRuneEffect( Spieler *zSpieler )
+    : Effect( zSpieler, 75.f + ( 75.f / 100.f ) * zSpieler->getAbklingZeitVerringerung() )
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() + 7 );
+    zSpieler->setGeschossTempo( zSpieler->getGeschossTempo() + 3 );
+}
+
+TempoRuneEffect::~TempoRuneEffect()
+{
+    zSpieler->setLaufTempo( zSpieler->getLaufTempo() - 7 );
+    zSpieler->setGeschossTempo( zSpieler->getGeschossTempo() - 3 );
+}

StickmanWorldOnline/TempoRune.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "Effect.h"
+
+class TempoRuneEffect : public Effect
+{
+private:
+
+public:
+    TempoRuneEffect( Spieler *zSpieler );
+    ~TempoRuneEffect();
+};

StickmanWorldOnline/Timer.cpp

@@ -0,0 +1,121 @@
+#include "Timer.h"
+#include "Spiel.h"
+
+Timer::Timer( int id, const char *name, int maxZeit, int x, int y, bool visible, bool autoWiederhohlung, bool runns, int farbe )
+    : GameObject( TIMER, x, y, 0, 0 )
+{
+    this->id = id;
+    this->name = name;
+    this->maxZeit = maxZeit;
+    currentTime = (float)maxZeit;
+    sichtbar = visible;
+    this->autoWiederhohlung = autoWiederhohlung;
+    this->runns = runns;
+    this->pause = 0;
+    this->farbe = farbe;
+}
+
+void Timer::start( Spiel *zSpiel, bool restart )
+{
+    if( runns && !restart )
+        return;
+    currentTime = (float)maxZeit;
+    runns = true;
+    pause = 0;
+    zSpiel->setTimerZuletztGestartet( (Timer *)getThis() );
+    Ereignis *e = new Ereignis( TIMER_BEGINNT );
+    e->addParameter( "Betroffener Timer", this->getThis() );
+    zSpiel->throwEvent( e );
+}
+
+void Timer::setPause( Spiel *zSpiel, bool pause )
+{
+    if( pause && !this->pause )
+        zSpiel->setTimerZuletztPausiert( (Timer *)getThis() );
+    if( !pause && this->pause )
+        zSpiel->setTimerZuletztFortgesetzt( (Timer *)getThis() );
+    this->pause = pause;
+}
+
+void Timer::setMaxZeit( int sekunden )
+{
+    this->maxZeit = maxZeit;
+}
+
+void Timer::setAutoWiederhohlung( bool wiederhohlung )
+{
+    this->autoWiederhohlung = autoWiederhohlung;
+}
+
+void Timer::setSichtbar( bool visible )
+{
+    this->sichtbar = sichtbar;
+}
+
+void Timer::setFarbe( int farbe )
+{
+    this->farbe = farbe;
+}
+
+void Timer::tick( double time, Spiel *zSpiel )
+{
+    if( runns && !pause )
+    {
+        currentTime -= (float)time;
+        if( currentTime <= 0 )
+        {
+            zSpiel->setTimerZuletztAbgelaufen( (Timer *)getThis() );
+            runns = 0;
+            Ereignis *e = new Ereignis( TIMER_RUNNS_OUT );
+            e->addParameter( "Betroffener Timer", this->getThis() );
+            zSpiel->throwEvent( e );
+            if( autoWiederhohlung )
+                start( zSpiel );
+        }
+    }
+}
+
+void Timer::setZeit( float zeit )
+{
+    currentTime = zeit;
+}
+
+float Timer::getTimeLeft() const
+{
+    return currentTime;
+}
+
+bool Timer::istSichtbar() const
+{
+    return sichtbar;
+}
+
+int Timer::getFarbe() const
+{
+    return farbe;
+}
+
+bool Timer::isRunning() const
+{
+    return runns;
+}
+
+bool Timer::istPausiert() const
+{
+    return pause;
+}
+
+int Timer::getMaxTime() const
+{
+    return maxZeit;
+}
+
+bool Timer::istAutoWiederhohlung() const
+{
+    return autoWiederhohlung;
+}
+
+int Timer::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Timer.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "GameObject.h"
+
+class Spiel;
+
+class Timer : public GameObject
+{
+private:
+    int id;
+    Text name;
+    bool runns;
+    bool pause;
+    int farbe;
+    int maxZeit;
+    float currentTime;
+    bool autoWiederhohlung;
+    bool sichtbar;
+
+public:
+    Timer( int id, const char *name, int maxZeit, int x, int y, bool visible = 1, bool autoWiederhohlung = 0, bool runns = 0, int farbe = 0xFFFFFFFF );
+    void start( Spiel *zSpiel, bool restart = 0 );
+    void setPause( Spiel *zSpiel, bool pause );
+    void setMaxZeit( int sekunden );
+    void setAutoWiederhohlung( bool wiederhohlung );
+    void setSichtbar( bool visible );
+    void setFarbe( int farbe );
+    void tick( double time, Spiel *zSpiel );
+    void setZeit( float zeit );
+    float getTimeLeft() const;
+    bool istSichtbar() const;
+    int getFarbe() const;
+    bool isRunning() const;
+    bool istPausiert() const;
+    int getMaxTime() const;
+    bool istAutoWiederhohlung() const;
+    int getId() const;
+};

StickmanWorldOnline/Trigger.cpp

@@ -0,0 +1,356 @@
+#include "Trigger.h"
+#include "Gegenstand.h"
+
+
+VarPointer::VarPointer( const char *name, Variable *var )
+{
+    this->name = name;
+    this->var = var;
+    ref = 1;
+}
+
+VarPointer::~VarPointer()
+{
+    if( var )
+        var->release();
+}
+
+Text VarPointer::getName() const
+{
+    return name;
+}
+
+void VarPointer::setVariable( Variable *var )
+{
+    if( this->var )
+        this->var->release();
+    this->var = var;
+}
+
+Variable *VarPointer::getVariable() const
+{
+    return var ? var->getThis() : 0;
+}
+
+Variable *VarPointer::zVariable() const
+{
+    return var;
+}
+
+VarPointer::operator Variable *( ) const
+{
+    return var;
+}
+
+VarPointer *VarPointer::getThis()
+{
+    ref++;
+    return this;
+}
+
+VarPointer *VarPointer::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+LocalMemory::LocalMemory()
+{
+    ref = 1;
+}
+
+LocalMemory::~LocalMemory()
+{}
+
+void LocalMemory::setVar( const char *name, Variable *var )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+        {
+            v->setVariable( var );
+            return;
+        }
+    }
+    vars.add( new VarPointer( name, var ) );
+}
+
+Variable *LocalMemory::getVariable( const char *name )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->getVariable();
+    }
+    return 0;
+}
+
+Variable *LocalMemory::zVariable( const char *name )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->zVariable();
+    }
+    return 0;
+}
+
+LocalMemory *LocalMemory::getThis()
+{
+    ref++;
+    return this;
+}
+
+LocalMemory *LocalMemory::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+ProgramCounter::ProgramCounter()
+{
+    current.add( 0 );
+    depth = 0;
+    ref = 1;
+}
+
+ProgramCounter::~ProgramCounter()
+{}
+
+void ProgramCounter::stepIn()
+{
+    depth++;
+    if( current.getEintragAnzahl() <= depth )
+        current.add( 0 );
+}
+
+void ProgramCounter::count()
+{
+    current.set( current.get( depth ) + 1, depth );
+    while( depth + 1 < current.getEintragAnzahl() )
+        current.remove( depth + 1 );
+}
+
+void ProgramCounter::stepOut()
+{
+    depth--;
+}
+
+Text ProgramCounter::getUniqueString() const
+{
+    Text ret = "__";
+    for( int i = 0; i < depth; i++ )
+        ret += Text( current.get( i ) ) + "__";
+    return ret;
+}
+
+int ProgramCounter::currentPosition() const
+{
+    return current.get( depth );
+}
+
+ProgramCounter *ProgramCounter::getThis()
+{
+    ref++;
+    return this;
+}
+
+ProgramCounter *ProgramCounter::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+Bedingung::Bedingung( Aktion *expression )
+{
+    this->expression = expression;
+    ref = 1;
+}
+
+Bedingung::~Bedingung()
+{
+    if( expression )
+        expression->release();
+}
+
+void Bedingung::setExpression( Aktion *expr )
+{
+    if( expression )
+        expression->release();
+    expression = expr;
+}
+
+bool Bedingung::check( Spiel *zSpiel, Ereignis *zEreignis )
+{
+    if( !expression )
+        return 1;
+    double wait;
+    ProgramCounter c;
+    LocalMemory m;
+    while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) );
+    Variable *var = m.zVariable( "__return__" );
+    return isTrue( var );
+}
+
+Bedingung *Bedingung::getThis()
+{
+    ref++;
+    return this;
+}
+
+Bedingung *Bedingung::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+Trigger::Trigger( int id, const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen )
+    : Variable( TRIGGER )
+{
+    this->id = id;
+    this->name = name;
+    this->ereignisAnzahl = ereignisAnzahl;
+    this->ereignisse = ereignisse;
+    this->bedingungen = bedingungen;
+    this->aktionen = aktionen;
+    aktiv = 1;
+    runCount = 0;
+}
+
+Trigger::~Trigger()
+{
+    delete[]ereignisse;
+    bedingungen->release();
+    aktionen->release();
+}
+
+void Trigger::setAktiv( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+bool Trigger::hatEreignis( EreignisTyp typ ) const
+{
+    for( int i = 0; i < ereignisAnzahl; i++ )
+    {
+        if( ereignisse[ i ] == typ )
+            return 1;
+    }
+    return 0;
+}
+
+int Trigger::getAktionAnzahl() const
+{
+    return aktionen->getEintragAnzahl();
+}
+
+Aktion *Trigger::zAktion( int index ) const
+{
+    return aktionen->z( index );
+}
+
+Aktion *Trigger::getAktion( int index ) const
+{
+    return aktionen->get( index );
+}
+
+// return: 0, falls die bedingungen nicht erfüllt sind
+TriggerRun *Trigger::runTrigger( Ereignis *e, Spiel *zSpiel )
+{
+    if( !aktiv )
+    {
+        e->release();
+        return 0;
+    }
+    for( auto b = bedingungen->getIterator(); b; b++ )
+    {
+        if( !b->check( zSpiel, e ) )
+        {
+            e->release();
+            return 0;
+        }
+    }
+    runCount++;
+    return new TriggerRun( (Trigger *)getThis(), e, zSpiel );
+}
+
+int Trigger::getId() const
+{
+    return id;
+}
+
+int Trigger::getRuns() const
+{
+    return runCount;
+}
+
+const char *Trigger::getName() const
+{
+    return name.getText();
+}
+
+bool Trigger::istAktiv() const
+{
+    return aktiv;
+}
+
+
+TriggerRun::TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel )
+{
+    trigger = trig;
+    ereignis = e;
+    this->zSpiel = zSpiel;
+    waitCount = 0;
+    ref = 1;
+}
+
+TriggerRun::~TriggerRun()
+{
+    trigger->release();
+    ereignis->release();
+}
+
+// gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
+bool TriggerRun::runNext( double t )
+{
+    if( waitCount > 0 )
+        waitCount -= t;
+    else
+    {
+        int current = counter.currentPosition();
+        if( current >= trigger->getAktionAnzahl() )
+            return 0;
+        Aktion *ak = trigger->zAktion( current );
+        if( !ak || ak->runNext( zSpiel, ereignis, &localMem, &counter, waitCount ) )
+            counter.count();
+        if( counter.currentPosition() >= trigger->getAktionAnzahl() )
+            return 0;
+    }
+    return 1;
+}
+
+Trigger *TriggerRun::getTrigger() const
+{
+    return (Trigger *)trigger->getThis();
+}
+
+TriggerRun *TriggerRun::getThis()
+{
+    ref++;
+    return this;
+}
+
+TriggerRun *TriggerRun::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Trigger.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include <Array.h>
+#include "Ereignis.h"
+#include "Aktionen.h"
+
+using namespace Framework;
+
+class TriggerRun;
+class Spiel;
+
+class VarPointer
+{
+private:
+    Variable *var;
+    Text name;
+    int ref;
+
+public:
+    VarPointer( const char *name, Variable *var );
+    ~VarPointer();
+    Text getName() const;
+    void setVariable( Variable *var );
+    Variable *getVariable() const;
+    Variable *zVariable() const;
+    operator Variable *( ) const;
+    VarPointer *getThis();
+    VarPointer *release();
+};
+
+class LocalMemory
+{
+private:
+    RCArray< VarPointer > vars;
+    int ref;
+
+public:
+    LocalMemory();
+    ~LocalMemory();
+    void setVar( const char *name, Variable *var );
+    Variable *getVariable( const char *name );
+    Variable *zVariable( const char *name );
+    LocalMemory *getThis();
+    LocalMemory *release();
+};
+
+class ProgramCounter
+{
+private:
+    Array< int > current;
+    int depth;
+    int ref;
+
+public:
+    ProgramCounter();
+    ~ProgramCounter();
+    void stepIn();
+    void count();
+    void stepOut();
+    Text getUniqueString() const;
+    int currentPosition() const;
+    ProgramCounter *getThis();
+    ProgramCounter *release();
+};
+
+class Bedingung
+{
+private:
+    Aktion *expression;
+    int ref;
+
+public:
+    Bedingung( Aktion *expression );
+    ~Bedingung();
+    void setExpression( Aktion *expr );
+    bool check( Spiel *zSpiel, Ereignis *zEreignis );
+    Bedingung *getThis();
+    Bedingung *release();
+};
+
+class Trigger : public Variable
+{
+private:
+    int id;
+    Text name;
+    int ereignisAnzahl;
+    EreignisTyp *ereignisse;
+    RCArray< Bedingung > *bedingungen;
+    RCArray< Aktion > *aktionen;
+    int runCount;
+    bool aktiv;
+
+public:
+    Trigger( int id, const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen );
+    ~Trigger();
+    void setAktiv( bool aktiv );
+    bool hatEreignis( EreignisTyp typ ) const;
+    int getAktionAnzahl() const;
+    Aktion *zAktion( int index ) const;
+    Aktion *getAktion( int index ) const;
+    // 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;
+    bool istAktiv() const;
+};
+
+class TriggerRun
+{
+private:
+    Trigger *trigger;
+    Ereignis *ereignis;
+    Spiel *zSpiel;
+    LocalMemory localMem;
+    ProgramCounter counter;
+    int programCounter;
+    double waitCount;
+    int ref;
+
+public:
+    TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel );
+    ~TriggerRun();
+    // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
+    bool runNext( double t );
+    Trigger *getTrigger() const;
+    TriggerRun *getThis();
+    TriggerRun *release();
+};

StickmanWorldOnline/Tunnel.cpp

@@ -0,0 +1,59 @@
+#include "Tunnel.h"
+#include "Spiel.h"
+
+
+Tunnel::Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv )
+    : GameObject( TUNNEL, x, y, width, height )
+{
+    this->id = id;
+    this->aktiv = aktiv;
+    benutzt = 0;
+    this->zielX = zielX;
+    this->zielY = zielY;
+}
+
+void Tunnel::setZielX( int x )
+{
+    zielX = x;
+}
+
+void Tunnel::setZielY( int y )
+{
+    zielY = y;
+}
+
+void Tunnel::addBenutzung( Spiel *zSpiel )
+{
+    zSpiel->setTunnelZuletztBenutzt( (Tunnel *)getThis() );
+    benutzt++;
+}
+
+void Tunnel::setAktiv( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+int Tunnel::getZielX() const
+{
+    return zielX;
+}
+
+int Tunnel::getZielY() const
+{
+    return zielY;
+}
+
+bool Tunnel::istAktiv() const
+{
+    return aktiv;
+}
+
+int Tunnel::getBenutzungen() const
+{
+    return benutzt;
+}
+
+int Tunnel::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Tunnel.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "GameObject.h"
+
+class Spiel;
+
+class Tunnel : public GameObject
+{
+private:
+    int id;
+    bool aktiv;
+    int benutzt;
+    int zielX;
+    int zielY;
+
+public:
+    Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv );
+    void setZielX( int x );
+    void setZielY( int y );
+    void addBenutzung( Spiel *zSpiel );
+    void setAktiv( bool aktiv );
+    int getZielX() const;
+    int getZielY() const;
+    bool istAktiv() const;
+    int getBenutzungen() const;
+    int getId() const;
+};

StickmanWorldOnline/Umlenkung.cpp

@@ -0,0 +1,107 @@
+#include "Umlenkung.h"
+#include "Spiel.h"
+
+
+Umlenkung::Umlenkung( int id, int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv )
+    : GameObject( UMLENKUNG, x, y, breite, height )
+{
+    this->id = id;
+    this->richtung = richtung;
+    this->maxAbklingzeit = maxAbklingzeit;
+    this->drehend = drehend;
+    this->aktiv = aktiv;
+    benutzt = 0;
+    abklingzeitVerbleibend = 0;
+}
+
+void Umlenkung::setMaxAbklingzeit( int sekunden )
+{
+    this->maxAbklingzeit = sekunden;
+}
+
+void Umlenkung::setAktiv( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+void Umlenkung::setDrehend( bool drehend )
+{
+    this->drehend = drehend;
+}
+
+void Umlenkung::setRichtung( Richtung r )
+{
+    this->richtung = r;
+}
+
+void Umlenkung::addBenutzt( Spiel *zSpiel )
+{
+    benutzt++;
+    if( drehend )
+    {
+        switch( richtung )
+        {
+        case OBEN:
+            richtung = RECHTS;
+            break;
+        case RECHTS:
+            richtung = UNTEN;
+            break;
+        case UNTEN:
+            richtung = LINKS;
+            break;
+        case LINKS:
+            richtung = OBEN;
+            break;
+        default:
+            break;
+        }
+    }
+    abklingzeitVerbleibend = (float)maxAbklingzeit;
+    zSpiel->setUmlenkungZuletztBenutzt( (Umlenkung *)getThis() );
+}
+
+void Umlenkung::tick( double time )
+{
+    if( abklingzeitVerbleibend > 0 )
+    {
+        abklingzeitVerbleibend -= (float)time;
+        if( abklingzeitVerbleibend < 0 )
+            abklingzeitVerbleibend = 0;
+    }
+}
+
+bool Umlenkung::isAktive() const
+{
+    return aktiv;
+}
+
+bool Umlenkung::hatAbklingzeit() const
+{
+    return abklingzeitVerbleibend > 0;
+}
+
+bool Umlenkung::istDrehend() const
+{
+    return drehend;
+}
+
+int Umlenkung::getMaxAbklingzeit() const
+{
+    return maxAbklingzeit;
+}
+
+Richtung Umlenkung::getRichtung() const
+{
+    return richtung;
+}
+
+int Umlenkung::getBenutzungen() const
+{
+    return benutzt;
+}
+
+int Umlenkung::getId() const
+{
+    return id;
+}

StickmanWorldOnline/Umlenkung.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "GameObject.h"
+
+class Spiel;
+
+class Umlenkung : public GameObject
+{
+private:
+    int id;
+    Richtung richtung;
+    bool drehend;
+    bool aktiv;
+    int benutzt;
+    int maxAbklingzeit;
+    float abklingzeitVerbleibend;
+
+public:
+    Umlenkung( int id, int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv );
+    void setMaxAbklingzeit( int sekunden );
+    void setAktiv( bool aktiv );
+    void setDrehend( bool drehend );
+    void setRichtung( Richtung r );
+    void addBenutzt( Spiel *zSpiel );
+    void tick( double time );
+    bool isAktive() const;
+    bool hatAbklingzeit() const;
+    bool istDrehend() const;
+    int getMaxAbklingzeit() const;
+    Richtung getRichtung() const;
+    int getBenutzungen() const;
+    int getId() const;
+};

StickmanWorldOnline/Variablen.cpp

@@ -0,0 +1,235 @@
+#include "Variablen.h"
+#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 )
+    {
+        return ( a == BARIERE || a == BASE || a == DROP || a == GEGENSTAND || a == GESCHOSS ||
+                 a == SCHALTER || a == SCHIENE || a == SPIELER || a == TIMER ||
+                 a == TUNNEL || a == UMLENKUNG || a == GAME_OBJEKT || a == ALLE ) &&
+                 ( b == BARIERE || b == BASE || b == DROP || b == GEGENSTAND || b == GESCHOSS ||
+                   b == SCHALTER || b == SCHIENE || b == SPIELER || b == TIMER || b == TUNNEL ||
+                   b == UMLENKUNG || b == GAME_OBJEKT || b == ALLE );
+    }
+    if( a == ALLE || b == ALLE )
+        return 1;
+    return (int)a == (int)b;
+}
+
+bool operator!=( VariableTyp a, VariableTyp b )
+{
+    return !( a == b );
+}
+
+
+Variable::Variable( VariableTyp typ )
+{
+    this->typ = typ;
+    ref = 1;
+}
+
+Variable::~Variable()
+{}
+
+VariableTyp Variable::getVariableTyp() const
+{
+    return typ;
+}
+
+Variable *Variable::getThis()
+{
+    ref++;
+    return this;
+}
+
+Variable *Variable::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+bool isTrue( Variable *v )
+{
+    if( !v )
+        return 0;
+    switch( v->getVariableTyp() )
+    {
+    case NICHTS:
+        return 0;
+    case INTEGER:
+        return ( (Integer *)v )->getValue() != 0;
+    case BOOLEAN:
+        return ( (Boolean *)v )->getValue();
+    case STRING:
+        return ( (String *)v )->getValue().getLength();
+    case FLOAT:
+        return ( (Float *)v )->getValue() != 0;
+    case TASTE:
+        return ( (Integer *)v )->getValue() != 0;
+    case GEGENSTAND_TYP:
+        return ( (GegenstandTypVar *)v )->getValue() != KEIN_GEGENSTAND;
+    default:
+        return 1;
+    }
+}
+
+
+Integer::Integer( int value, bool taste )
+    : Variable( taste ? TASTE : INTEGER )
+{
+    this->value = value;
+}
+
+void Integer::setValue( int value )
+{
+    this->value = value;
+}
+
+int Integer::getValue() const
+{
+    return value;
+}
+
+
+Boolean::Boolean( bool value )
+    : Variable( BOOLEAN )
+{
+    this->value = value;
+}
+
+void Boolean::setValue( bool value )
+{
+    this->value = value;
+}
+
+bool Boolean::getValue() const
+{
+    return value;
+}
+
+
+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;
+    default:
+        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;
+}
+
+const Text &String::getValue() const
+{
+    return value;
+}
+
+
+Float::Float( float value )
+    : Variable( FLOAT )
+{
+    this->value = value;
+}
+
+void Float::setValue( float value )
+{
+    this->value = value;
+}
+
+float Float::getValue() const
+{
+    return value;
+}

StickmanWorldOnline/Variablen.h

@@ -0,0 +1,127 @@
+#pragma once
+#include <Text.h>
+
+#define BOOLEAN _BOOLEAN
+#define FLOAT _FLOAT
+
+using namespace Framework;
+
+enum VariableTyp
+{
+    NICHTS,
+    INTEGER,
+    BOOLEAN,
+    STRING,
+    RICHTUNG,
+    FLOAT,
+    TASTE,
+    SPIELER,
+    TIMER,
+    TEAM,
+    BARIERE,
+    SCHALTER,
+    BASE,
+    DROP,
+    GEGENSTAND,
+    GEGENSTAND_TYP,
+    GESCHOSS,
+    GESCHOSS_TYP,
+    SCHIENE,
+    TUNNEL,
+    UMLENKUNG,
+    TRIGGER,
+    FEUERBALL_TREFFER,
+    AKTION,
+    GAME_OBJEKT,
+    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 );
+
+class Variable
+{
+private:
+    VariableTyp typ;
+    int ref;
+
+public:
+    Variable( VariableTyp typ );
+    virtual ~Variable();
+    VariableTyp getVariableTyp() const;
+    Variable *getThis();
+    Variable *release();
+};
+
+bool isTrue( Variable *v );
+
+class Integer : public Variable
+{
+private:
+    int value;
+
+public:
+    Integer( int value, bool taste = 0 );
+    void setValue( int value );
+    int getValue() const;
+};
+
+class Boolean : public Variable
+{
+private:
+    bool value;
+
+public:
+    Boolean( bool value );
+    void setValue( bool value );
+    bool getValue() const;
+};
+
+class String : public Variable
+{
+private:
+    Text value;
+
+public:
+    String( const char *value );
+    String( Richtung r );
+    String( GeschossTyp typ );
+    void setValue( Text value );
+    const Text &getValue() const;
+};
+
+class Float : public Variable
+{
+private:
+    float value;
+
+public:
+    Float( float value );
+    void setValue( float value );
+    float getValue() const;
+};