Vererbung von Game Objekten in die Trigger implementiert um den code zu vereinfachen

StickmanWorldOnline/Aktionen.cpp

@@ -663,73 +663,6 @@ bool SpielerRemoveItem::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory
 }
 
 
-SpielerSetPosition::SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler )
-    : Aktion( SPIELER_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->spieler = spieler;
-}
-
-SpielerSetPosition::~SpielerSetPosition()
-{
-    x->release();
-    y->release();
-    spieler->release();
-}
-
-bool SpielerSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SPIELER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Spieler *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Spieler *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 SpielerSetLeben::SpielerSetLeben( Aktion *leben, Aktion *spieler )
     : Aktion( SPIELER_SET_LEBEN )
 {
@@ -1582,22 +1515,22 @@ bool BariereSetEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, Local
 }
 
 
-BariereSetPosition::BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere )
-    : Aktion( BARIERE_SET_POSITION )
+GameObjektSetPosition::GameObjektSetPosition( Aktion *x, Aktion *y, Aktion *objekt )
+    : Aktion( GAME_OBJEKT_SET_POSITION )
 {
     this->x = x;
     this->y = y;
-    this->bariere = bariere;
+    this->objekt = objekt;
 }
 
-BariereSetPosition::~BariereSetPosition()
+GameObjektSetPosition::~GameObjektSetPosition()
 {
     x->release();
     y->release();
-    bariere->release();
+    objekt->release();
 }
 
-bool BariereSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+bool GameObjektSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
     if( zPC->currentPosition() == 0 )
@@ -1630,7 +1563,7 @@ bool BariereSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemor
     }
     if( zPC->currentPosition() == 2 && waitCount <= 0 )
     {
-        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
             if( !t || t->getVariableTyp() != BARIERE )
@@ -1638,8 +1571,8 @@ bool BariereSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemor
                 zPC->stepOut();
                 return 1;
             }
-            ( (Bariere *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Bariere *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
+            ( (GameObject *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
+            ( (GameObject *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
             zPC->stepOut();
             return 1;
         }
@@ -1649,28 +1582,30 @@ bool BariereSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemor
 }
 
 
-BariereSetTeam::BariereSetTeam( Aktion *team, Aktion *bariere )
-    : Aktion( BARIERE_SET_TEAM )
+GameObjektSetSize::GameObjektSetSize( Aktion *x, Aktion *y, Aktion *objekt )
+    : Aktion( GAME_OBJEKT_SET_SIZE )
 {
-    this->team = team;
-    this->bariere = bariere;
+    this->x = x;
+    this->y = y;
+    this->objekt = objekt;
 }
 
-BariereSetTeam::~BariereSetTeam()
+GameObjektSetSize::~GameObjektSetSize()
 {
-    team->release();
-    bariere->release();
+    x->release();
+    y->release();
+    objekt->release();
 }
 
-bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+bool GameObjektSetSize::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
     if( zPC->currentPosition() == 0 )
     {
-        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TEAM )
+            if( !t || t->getVariableTyp() != FLOAT )
             {
                 zPC->stepOut();
                 return 1;
@@ -1681,7 +1616,21 @@ bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *z
     }
     if( zPC->currentPosition() == 1 && waitCount <= 0 )
     {
-        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        {
+            Variable *t = zMemory->zVariable( "__return__" );
+            if( !t || t->getVariableTyp() != FLOAT )
+            {
+                zPC->stepOut();
+                return 1;
+            }
+            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
+            zPC->count();
+        }
+    }
+    if( zPC->currentPosition() == 2 && waitCount <= 0 )
+    {
+        if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
             if( !t || t->getVariableTyp() != BARIERE )
@@ -1689,7 +1638,8 @@ bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *z
                 zPC->stepOut();
                 return 1;
             }
-            ( (Bariere *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
+            ( (GameObject *)t )->setWidth( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
+            ( (GameObject *)t )->setHeight( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
             zPC->stepOut();
             return 1;
         }
@@ -1699,30 +1649,28 @@ bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *z
 }
 
 
-SchalterSetPosition::SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter )
-    : Aktion( SCHALTER_SET_POSITION )
+BariereSetTeam::BariereSetTeam( Aktion *team, Aktion *bariere )
+    : Aktion( BARIERE_SET_TEAM )
 {
-    this->x = x;
-    this->y = y;
-    this->schalter = schalter;
+    this->team = team;
+    this->bariere = bariere;
 }
 
-SchalterSetPosition::~SchalterSetPosition()
+BariereSetTeam::~BariereSetTeam()
 {
-    x->release();
-    y->release();
-    schalter->release();
+    team->release();
+    bariere->release();
 }
 
-bool SchalterSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+bool BariereSetTeam::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
     zPC->stepIn();
     if( zPC->currentPosition() == 0 )
     {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( team->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
+            if( !t || t->getVariableTyp() != TEAM )
             {
                 zPC->stepOut();
                 return 1;
@@ -1733,30 +1681,15 @@ bool SchalterSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemo
     }
     if( zPC->currentPosition() == 1 && waitCount <= 0 )
     {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( schalter->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        if( bariere->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
         {
             Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != SCHALTER )
+            if( !t || t->getVariableTyp() != BARIERE )
             {
                 zPC->stepOut();
                 return 1;
             }
-            ( (Schalter *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Schalter *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
+            ( (Bariere *)t )->setTeam( ( (Team *)zMemory->getVariable( zPC->getUniqueString() + "R0__" ) ) );
             zPC->stepOut();
             return 1;
         }
@@ -1844,73 +1777,6 @@ bool SchalterAktivieren::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemor
 }
 
 
-TunnelSetPosition::TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel )
-    : Aktion( TUNNEL_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->tunnel = tunnel;
-}
-
-TunnelSetPosition::~TunnelSetPosition()
-{
-    x->release();
-    y->release();
-    tunnel->release();
-}
-
-bool TunnelSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TUNNEL )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Tunnel *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Tunnel *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 TunnelSetZielPosition::TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel )
     : Aktion( TUNNEL_SET_ZIEL_POSITION )
 {
@@ -2028,73 +1894,6 @@ bool TunnelSetErlaubt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory
 }
 
 
-UmlenkungSetPosition::UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung )
-    : Aktion( UMLENKUNG_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->umlenkung = umlenkung;
-}
-
-UmlenkungSetPosition::~UmlenkungSetPosition()
-{
-    x->release();
-    y->release();
-    umlenkung->release();
-}
-
-bool UmlenkungSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( umlenkung->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != UMLENKUNG )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Umlenkung *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Umlenkung *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 UmlenkungSetRichtung::UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung )
     : Aktion( UMLENKUNG_SET_RICHTUNG )
 {
@@ -2245,73 +2044,6 @@ bool UmlenkungSetEnabled::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemo
 }
 
 
-BaseSetPosition::BaseSetPosition( Aktion *x, Aktion *y, Aktion *base )
-    : Aktion( BASE_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->base = base;
-}
-
-BaseSetPosition::~BaseSetPosition()
-{
-    x->release();
-    y->release();
-    base->release();
-}
-
-bool BaseSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( base->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != BASE )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Base *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Base *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 BaseSetTeam::BaseSetTeam( Aktion *team, Aktion *base )
     : Aktion( BASE_SET_TEAM )
 {
@@ -2490,73 +2222,6 @@ bool TeamSetPunkte::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zM
 }
 
 
-TimerSetPosition::TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer )
-    : Aktion( TIMER_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->timer = timer;
-}
-
-TimerSetPosition::~TimerSetPosition()
-{
-    x->release();
-    y->release();
-    timer->release();
-}
-
-bool TimerSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( timer->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != TIMER )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Timer *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Timer *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 TimerSetPause::TimerSetPause( Aktion *pause, Aktion *timer )
     : Aktion( TIMER_SET_PAUSE )
 {
@@ -2823,73 +2488,6 @@ bool GeschossNeu::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMem
 }
 
 
-GeschossSetPosition::GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss )
-    : Aktion( GESCHOSS_SET_POSITION )
-{
-    this->x = x;
-    this->y = y;
-    this->geschoss = geschoss;
-}
-
-GeschossSetPosition::~GeschossSetPosition()
-{
-    x->release();
-    y->release();
-    geschoss->release();
-}
-
-bool GeschossSetPosition::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
-{
-    zPC->stepIn();
-    if( zPC->currentPosition() == 0 )
-    {
-        if( x->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 1 && waitCount <= 0 )
-    {
-        if( y->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != FLOAT )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
-            zPC->count();
-        }
-    }
-    if( zPC->currentPosition() == 2 && waitCount <= 0 )
-    {
-        if( geschoss->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
-        {
-            Variable *t = zMemory->zVariable( "__return__" );
-            if( !t || t->getVariableTyp() != GESCHOSS )
-            {
-                zPC->stepOut();
-                return 1;
-            }
-            ( (Geschoss *)t )->setX( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue() );
-            ( (Geschoss *)t )->setY( ( (Float *)zMemory->zVariable( zPC->getUniqueString() + "R1__" ) )->getValue() );
-            zPC->stepOut();
-            return 1;
-        }
-    }
-    zPC->stepOut();
-    return 0;
-}
-
-
 GeschossSetSpeed::GeschossSetSpeed( Aktion *speed, Aktion *geschoss )
     : Aktion( GESCHOSS_SET_SPEED )
 {
@@ -3211,7 +2809,8 @@ IntegerRechnen::IntegerRechnen( Aktion *left, Aktion *right, Operator op )
 IntegerRechnen::~IntegerRechnen()
 {
     left->release();
-    right->release();
+    if( right )
+        right->release();
 }
 
 bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
@@ -3317,11 +2916,13 @@ bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *z
             break;
         }
         case LOGARITHM:
-            zMemory->setVar( "__return__", new Integer( log( l->getValue() ) / log( r->getValue() ) ) );
+            zMemory->setVar( "__return__", new Integer( (int)( log( l->getValue() ) / log( r->getValue() ) ) ) );
             break;
         case MODULO:
             zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
             break;
+        default:
+            break;
         }
         zPC->stepOut();
         return 1;
@@ -3329,3 +2930,142 @@ bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *z
     zPC->stepOut();
     return 0;
 }
+
+
+IntegerZufall::IntegerZufall( Aktion *min, Aktion *max )
+    : Aktion( INTEGER_ZUFALL )
+{
+    this->min = 0;
+    this->max = 0;
+}
+
+IntegerZufall::~IntegerZufall()
+{
+    min->release();
+    max->release();
+}
+
+bool IntegerZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zPC->stepIn();
+    if( zPC->currentPosition() == 0 )
+    {
+        if( min->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        {
+            Variable *t = zMemory->zVariable( "__return__" );
+            if( !t || t->getVariableTyp() != INTEGER )
+            {
+                zPC->stepOut();
+                return 1;
+            }
+            zMemory->setVar( zPC->getUniqueString() + "R0__", t->getThis() );
+            zPC->count();
+        }
+    }
+    if( zPC->currentPosition() == 1 && waitCount <= 0 )
+    {
+        if( max->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        {
+            Variable *t = zMemory->zVariable( "__return__" );
+            if( !t || t->getVariableTyp() != INTEGER )
+            {
+                zPC->stepOut();
+                return 1;
+            }
+            int mi = ( (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" ) )->getValue();
+            int ma = ( (Integer *)t )->getValue();
+            zMemory->setVar( "__return__", new Integer( (int)( zSpiel->getRand() * ( ma - mi ) + mi ) ) );
+            zPC->stepOut();
+            return 1;
+        }
+    }
+    zPC->stepOut();
+    return 0;
+}
+
+
+IntegerAusText::IntegerAusText( Aktion *text )
+    : Aktion( INTEGER_AUS_TEXT )
+{
+    this->text = text;
+}
+
+IntegerAusText::~IntegerAusText()
+{
+    this->text->release();
+}
+
+bool IntegerAusText::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( text->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != STRING )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (String *)t )->getValue() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+FloatXVonGameObjekt::FloatXVonGameObjekt( Aktion *objekt )
+    : Aktion( FLOAT_X_VON_GAME_OBJEKT )
+{
+    this->objekt = objekt;
+}
+
+FloatXVonGameObjekt::~FloatXVonGameObjekt()
+{
+    objekt->release();
+}
+
+bool FloatXVonGameObjekt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != GAME_OBJEKT )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Float( ( (GameObject *)t )->getX() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+FloatYVonGameObjekt::FloatYVonGameObjekt( Aktion *objekt )
+    : Aktion( FLOAT_Y_VON_GAME_OBJEKT )
+{
+    this->objekt = objekt;
+}
+
+FloatYVonGameObjekt::~FloatYVonGameObjekt()
+{
+    objekt->release();
+}
+
+bool FloatYVonGameObjekt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( objekt->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != GAME_OBJEKT )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Float( ( (GameObject *)t )->getY() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}

StickmanWorldOnline/Aktionen.h

@@ -12,13 +12,13 @@ enum AktionTyp
 {
     BARIERE_BEWEGUNG,
     BARIERE_SET_EINGESCHALTET,
-    BARIERE_SET_POSITION,
+    GAME_OBJEKT_SET_POSITION,
+    GAME_OBJEKT_SET_SIZE,
     BARIERE_SET_TEAM,
     BARIERE_ZUFALL,
     BARIERE_ZULETZT_AUSGESCHALTET,
     BARIERE_ZULETZT_BEWEGT,
     BARIERE_ZULETZT_EINGESCHALTET,
-    BASE_SET_POSITION,
     BASE_SET_TEAM,
     BASE_ZUFALL,
     BASE_ZULETZT_BESITZER_GEWECHSELT,
@@ -54,7 +54,6 @@ enum AktionTyp
     DROP_ZULETZT_GEDROPT,
     GESCHOSS_NEU,
     GESCHOSS_SET_PLAYER,
-    GESCHOSS_SET_POSITION,
     GESCHOSS_SET_RICHTUNG,
     GESCHOSS_SET_SPEED,
     GESCHOSS_SET_TYPE,
@@ -65,8 +64,8 @@ enum AktionTyp
     GESCHOSS_ZULETZT_TUNNEL_BENUTZT,
     GESCHOSS_ZULETZT_UMGELENKT,
     INTEGER_AUS_TEXT,
-    INTEGER_BARIERE_BREITE,
-    INTEGER_BARIERE_HEIGHT,
+    FLOAT_GAME_OBJEKT_BREITE,
+    FLOAT_GAME_OBJEKT_HEIGHT,
     INTEGER_BARIERE_SCHALTUNGEN,
     INTEGER_BARIERE_VERSCHIEBUNGEN,
     INTEGER_DROP_MAX_ZEIT,
@@ -113,24 +112,10 @@ enum AktionTyp
     INTEGER_TRIGGER_RUNNS,
     INTEGER_TUNNEL_BENUTZUNGEN,
     INTEGER_UMLENKUNG_BENUTZUNGEN,
-    INTEGER_X_VON_BARIERE,
-    INTEGER_X_VON_BASE,
-    INTEGER_X_VON_GESCHOSS,
-    INTEGER_X_VON_SCHALTER,
-    INTEGER_X_VON_SPIELER,
-    INTEGER_X_VON_TIMER,
-    INTEGER_X_VON_TUNNEL,
+    FLOAT_X_VON_GAME_OBJEKT,
+    FLOAT_Y_VON_GAME_OBJEKT,
     INTEGER_X_VON_TUNNEL_ZIEL,
-    INTEGER_X_VON_UMLENKUNG,
-    INTEGER_Y_VON_BARIERE,
-    INTEGER_Y_VON_BASE,
-    INTEGER_Y_VON_GESCHOSS,
-    INTEGER_Y_VON_SCHALTER,
-    INTEGER_Y_VON_SPIELER,
-    INTEGER_Y_VON_TIMER,
-    INTEGER_Y_VON_TUNNEL,
     INTEGER_Y_VON_TUNNEL_ZIEL,
-    INTEGER_Y_VON_UMLENKUNG,
     INTEGER_ZUFALL,
     ITEM_SPIELER_INVENTAR,
     ITEM_ZULETZT_AUFGEHOBEN,
@@ -146,7 +131,6 @@ enum AktionTyp
     RICHTUNG_ZUFALL,
     SCHALTER_AKTIVIEREN,
     SCHALTER_SET_ERLAUBT,
-    SCHALTER_SET_POSITION,
     SCHALTER_ZUFALL,
     SCHALTER_ZULETZT_AKTIVIERT,
     SET_VARIABLE,
@@ -162,7 +146,6 @@ enum AktionTyp
     SPIELER_SET_LEBENSREGENERATION,
     SPIELER_SET_LEVEL,
     SPIELER_SET_MAX_ERFAHRUNG,
-    SPIELER_SET_POSITION,
     SPIELER_SET_SCHADEN_BONUS,
     SPIELER_SET_TEMPO,
     SPIELER_SET_GESCHOSS_TEMPO,
@@ -194,7 +177,6 @@ enum AktionTyp
     TEXT_TEIL_VON_TEXT,
     TEXT_TRIGGER_NAME,
     TIMER_SET_PAUSE,
-    TIMER_SET_POSITION,
     TIMER_SET_SICHTBAR,
     TIMER_SET_ZEIT,
     TIMER_START,
@@ -209,13 +191,11 @@ enum AktionTyp
     TRIGGER_SET_ENABLED,
     TRIGGER_ZUFALL,
     TUNNEL_SET_ERLAUBT,
-    TUNNEL_SET_POSITION,
     TUNNEL_SET_ZIEL_POSITION,
     TUNNEL_ZUFALL,
     TUNNEL_ZULETZT_BENUTZT,
     UMLENKUNG_SET_ERLAUBT,
     UMLENKUNG_SET_MAX_ABK,
-    UMLENKUNG_SET_POSITION,
     UMLENKUNG_SET_RICHTUNG,
     UMLENKUNG_ZUFALL,
     UMLENKUNG_ZULETZT_BENUTZT,
@@ -462,19 +442,6 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetPosition : public Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *spieler;
-
-public:
-    SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler );
-    ~SpielerSetPosition();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
 class SpielerSetLeben : public Aktion
 {
 private:
@@ -680,16 +647,29 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class BariereSetPosition : public Aktion
+class GameObjektSetPosition : public Aktion
 {
 private:
     Aktion *x;
     Aktion *y;
-    Aktion *bariere;
+    Aktion *objekt;
+
+public:
+    GameObjektSetPosition( Aktion *x, Aktion *y, Aktion *objekt );
+    ~GameObjektSetPosition();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class GameObjektSetSize : public Aktion
+{
+private:
+    Aktion *x;
+    Aktion *y;
+    Aktion *objekt;
 
 public:
-    BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere );
-    ~BariereSetPosition();
+    GameObjektSetSize( Aktion *x, Aktion *y, Aktion *objekt );
+    ~GameObjektSetSize();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1129,91 +1109,25 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerXVonSpieler : public Aktion
-{
-private:
-    Aktion *spieler;
-
-public:
-    IntegerXVonSpieler( Aktion *spieler );
-    ~IntegerXVonSpieler();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonSpieler : public Aktion
-{
-private:
-    Aktion *spieler;
-
-public:
-    IntegerYVonSpieler( Aktion *spieler );
-    ~IntegerYVonSpieler();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerXVonBariere : public Aktion
-{
-private:
-    Aktion *bariere;
-
-public:
-    IntegerXVonBariere( Aktion *bariere );
-    ~IntegerXVonBariere();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonBariere : public Aktion
-{
-private:
-    Aktion *bariere;
-
-public:
-    IntegerYVonBariere( Aktion *bariere );
-    ~IntegerYVonBariere();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerXVonSchalter : public Aktion
-{
-private:
-    Aktion *schalter;
-
-public:
-    IntegerXVonSchalter( Aktion *schalter );
-    ~IntegerXVonSchalter();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonSchalter : public Aktion
-{
-private:
-    Aktion *schalter;
-
-public:
-    IntegerYVonSchalter( Aktion *schalter );
-    ~IntegerYVonSchalter();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerXVonTunnel : public Aktion
+class FloatXVonGameObjekt : public Aktion
 {
 private:
-    Aktion *tunnel;
+    Aktion *objekt;
 
 public:
-    IntegerXVonTunnel( Aktion *tunnel );
-    ~IntegerXVonTunnel();
+    FloatXVonGameObjekt( Aktion *objekt );
+    ~FloatXVonGameObjekt();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerYVonTunnel : public Aktion
+class FloatYVonGameObjekt : public Aktion
 {
 private:
-    Aktion *tunnel;
+    Aktion *objekt;
 
 public:
-    IntegerYVonTunnel( Aktion *tunnel );
-    ~IntegerYVonTunnel();
+    FloatYVonGameObjekt( Aktion *objekt );
+    ~FloatYVonGameObjekt();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1239,28 +1153,6 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerXVonUmlenkung : public Aktion
-{
-private:
-    Aktion *umlenkung;
-
-public:
-    IntegerXVonUmlenkung( Aktion *umlenkung );
-    ~IntegerXVonUmlenkung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonUmlenkung : public Aktion
-{
-private:
-    Aktion *umlenkung;
-
-public:
-    IntegerYVonUmlenkung( Aktion *umlenkung );
-    ~IntegerYVonUmlenkung();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
 class IntegerMinXVonDrop : public Aktion
 {
 private:
@@ -1305,72 +1197,6 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerXVonBase : public Aktion
-{
-private:
-    Aktion *base;
-
-public:
-    IntegerXVonBase( Aktion *base );
-    ~IntegerXVonBase();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonBase : public Aktion
-{
-private:
-    Aktion *base;
-
-public:
-    IntegerYVonBase( Aktion *base );
-    ~IntegerYVonBase();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerXVonTimer : public Aktion
-{
-private:
-    Aktion *timer;
-
-public:
-    IntegerXVonTimer( Aktion *timer );
-    ~IntegerXVonTimer();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonTimer : public Aktion
-{
-private:
-    Aktion *timer;
-
-public:
-    IntegerYVonTimer( Aktion *timer );
-    ~IntegerYVonTimer();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerXVonGeschoss : public Aktion
-{
-private:
-    Aktion *geschoss;
-
-public:
-    IntegerXVonGeschoss( Aktion *geschoss );
-    ~IntegerXVonGeschoss();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
-class IntegerYVonGeschoss : public Aktion
-{
-private:
-    Aktion *geschoss;
-
-public:
-    IntegerYVonGeschoss( Aktion *geschoss );
-    ~IntegerYVonGeschoss();
-    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
-
 class IntegerSpielerLevel : public Aktion
 {
 private:
@@ -1680,25 +1506,25 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerBariereBreite : public Aktion
+class FloatGameObjektBreite : public Aktion
 {
 private:
-    Aktion *bariere;
+    Aktion *objekt;
 
 public:
-    IntegerBariereBreite( Aktion *bariere );
-    ~IntegerBariereBreite();
+    FloatGameObjektBreite( Aktion *objekt );
+    ~FloatGameObjektBreite();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerBariereHeight : public Aktion
+class FloatGameObjektHeight : public Aktion
 {
 private:
-    Aktion *bariere;
+    Aktion *objekt;
 
 public:
-    IntegerBariereHeight( Aktion *bariere );
-    ~IntegerBariereHeight();
+    FloatGameObjektHeight( Aktion *objekt );
+    ~FloatGameObjektHeight();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 

StickmanWorldOnline/Reader.cpp

@@ -45,8 +45,10 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new BariereBewegung( params[ 0 ] );
     case BARIERE_SET_EINGESCHALTET:
         return new BariereSetEingeschaltet( params[ 0 ], params[ 1 ] );
-    case BARIERE_SET_POSITION:
-        return new BariereSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case GAME_OBJEKT_SET_POSITION:
+        return new GameObjektSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case GAME_OBJEKT_SET_SIZE:
+        return new GameObjektSetSize( params[ 0 ], params[ 1 ], params[ 2 ] );
     case BARIERE_SET_TEAM:
         return new BariereSetTeam( params[ 0 ], params[ 1 ] );
     case BARIERE_ZUFALL:
@@ -57,8 +59,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new BariereZuletztBewegt();
     case BARIERE_ZULETZT_EINGESCHALTET:
         return new BariereZuletztEingeschaltet();
-    case BASE_SET_POSITION:
-        return new BaseSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case BASE_SET_TEAM:
         return new BaseSetTeam( params[ 0 ], params[ 1 ] );
     case BASE_ZUFALL:
@@ -129,8 +129,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new GeschossNeu( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ] );
     case GESCHOSS_SET_PLAYER:
         return new GeschossSetPlayer( params[ 0 ], params[ 1 ] );
-    case GESCHOSS_SET_POSITION:
-        return new GeschossSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case GESCHOSS_SET_RICHTUNG:
         return new GeschossSetRichtung( params[ 0 ], params[ 1 ] );
     case GESCHOSS_SET_SPEED:
@@ -151,10 +149,10 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new GeschossZuletztUmgelenkt();
     case INTEGER_AUS_TEXT:
         return new IntegerAusText( params[ 0 ] );
-    case INTEGER_BARIERE_BREITE:
-        return new IntegerBariereBreite( params[ 0 ] );
-    case INTEGER_BARIERE_HEIGHT:
-        return new IntegerBariereHeight( params[ 0 ] );
+    case FLOAT_GAME_OBJEKT_BREITE:
+        return new FloatGameObjektBreite( params[ 0 ] );
+    case FLOAT_GAME_OBJEKT_HEIGHT:
+        return new FloatGameObjektHeight( params[ 0 ] );
     case INTEGER_BARIERE_SCHALTUNGEN:
         return new IntegerBariereSchaltungen( params[ 0 ] );
     case INTEGER_BARIERE_VERSCHIEBUNGEN:
@@ -175,7 +173,7 @@ Aktion *MapReader::readAktion( Datei &dat )
     {
         char op;
         dat.lese( &op, 1 );
-        return new IntegerRechnen( params[ 0 ], params[ 1 ], op );
+        return new IntegerRechnen( params[ 0 ], params[ 1 ], (Operator)op );
     }
     case INTEGER_SCHALTER_AKTIVIERUNGEN:
         return new IntegerSchalterAktivierungen( params[ 0 ] );
@@ -251,42 +249,14 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new IntegerTunnelBenutzungen( params[ 0 ] );
     case INTEGER_UMLENKUNG_BENUTZUNGEN:
         return new IntegerUmlenkungBenutzungen( params[ 0 ] );
-    case INTEGER_X_VON_BARIERE:
-        return new IntegerXVonBariere( params[ 0 ] );
-    case INTEGER_X_VON_BASE:
-        return new IntegerXVonBase( params[ 0 ] );
-    case INTEGER_X_VON_GESCHOSS:
-        return new IntegerXVonGeschoss( params[ 0 ] );
-    case INTEGER_X_VON_SCHALTER:
-        return new IntegerXVonSchalter( params[ 0 ] );
-    case INTEGER_X_VON_SPIELER:
-        return new IntegerXVonSpieler( params[ 0 ] );
-    case INTEGER_X_VON_TIMER:
-        return new IntegerXVonTimer( params[ 0 ] );
-    case INTEGER_X_VON_TUNNEL:
-        return new IntegerXVonTunnel( params[ 0 ] );
+    case FLOAT_X_VON_GAME_OBJEKT:
+        return new FloatXVonGameObjekt( params[ 0 ] );
+    case FLOAT_Y_VON_GAME_OBJEKT:
+        return new FloatYVonGameObjekt( params[ 0 ] );
     case INTEGER_X_VON_TUNNEL_ZIEL:
         return new IntegerXVonTunnelZiel( params[ 0 ] );
-    case INTEGER_X_VON_UMLENKUNG:
-        return new IntegerXVonUmlenkung( params[ 0 ] );
-    case INTEGER_Y_VON_BARIERE:
-        return new IntegerYVonBariere( params[ 0 ] );
-    case INTEGER_Y_VON_BASE:
-        return new IntegerYVonBase( params[ 0 ] );
-    case INTEGER_Y_VON_GESCHOSS:
-        return new IntegerYVonGeschoss( params[ 0 ] );
-    case INTEGER_Y_VON_SCHALTER:
-        return new IntegerYVonSchalter( params[ 0 ] );
-    case INTEGER_Y_VON_SPIELER:
-        return new IntegerYVonSpieler( params[ 0 ] );
-    case INTEGER_Y_VON_TIMER:
-        return new IntegerYVonTimer( params[ 0 ] );
-    case INTEGER_Y_VON_TUNNEL:
-        return new IntegerYVonTunnel( params[ 0 ] );
     case INTEGER_Y_VON_TUNNEL_ZIEL:
         return new IntegerYVonTunnelZiel( params[ 0 ] );
-    case INTEGER_Y_VON_UMLENKUNG:
-        return new IntegerYVonUmlenkung( params[ 0 ] );
     case INTEGER_ZUFALL:
         return new IntegerZufall( params[ 0 ], params[ 1 ] );
     case ITEM_SPIELER_INVENTAR:
@@ -347,8 +317,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new SchalterAktivieren( params[ 0 ] );
     case SCHALTER_SET_ERLAUBT:
         return new SchalterSetErlaubt( params[ 0 ], params[ 1 ] );
-    case SCHALTER_SET_POSITION:
-        return new SchalterSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case SCHALTER_ZUFALL:
         return new SchalterZufall();
     case SCHALTER_ZULETZT_AKTIVIERT:
@@ -388,8 +356,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new SpielerSetLevel( params[ 0 ], params[ 1 ] );
     case SPIELER_SET_MAX_ERFAHRUNG:
         return new SpielerSetMaxErfahrung( params[ 0 ], params[ 1 ] );
-    case SPIELER_SET_POSITION:
-        return new SpielerSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case SPIELER_SET_SCHADEN_BONUS:
         return new SpielerSetSchadenBonus( params[ 0 ], params[ 1 ] );
     case SPIELER_SET_TEMPO:
@@ -452,8 +418,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new TextTriggerName( params[ 0 ] );
     case TIMER_SET_PAUSE:
         return new TimerSetPause( params[ 0 ], params[ 1 ] );
-    case TIMER_SET_POSITION:
-        return new TimerSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case TIMER_SET_SICHTBAR:
         return new TimerSetSichtbar( params[ 0 ], params[ 1 ] );
     case TIMER_SET_ZEIT:
@@ -482,8 +446,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new TriggerZufall();
     case TUNNEL_SET_ERLAUBT:
         return new TunnelSetErlaubt( params[ 0 ], params[ 1 ] );
-    case TUNNEL_SET_POSITION:
-        return new TunnelSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case TUNNEL_SET_ZIEL_POSITION:
         return new TunnelSetZielPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case TUNNEL_ZUFALL:
@@ -494,8 +456,6 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new UmlenkungSetEnabled( params[ 0 ], params[ 1 ] );
     case UMLENKUNG_SET_MAX_ABK:
         return new UmlenkungSetMaxAbk( params[ 0 ], params[ 1 ] );
-    case UMLENKUNG_SET_POSITION:
-        return new UmlenkungSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
     case UMLENKUNG_SET_RICHTUNG:
         return new UmlenkungSetRichtung( params[ 0 ], params[ 1 ] );
     case UMLENKUNG_ZUFALL:

StickmanWorldOnline/Variablen.cpp

@@ -2,6 +2,28 @@
 #include "Gegenstand.h"
 
 
+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;
@@ -29,7 +51,6 @@ Variable *Variable::release()
     return 0;
 }
 
-
 bool isTrue( Variable *v )
 {
     if( !v )
@@ -90,8 +111,8 @@ bool Boolean::getValue() const
 }
 
 
-String::String( const char *value, bool richtung )
-    : Variable( richtung ? RICHTUNG : STRING )
+String::String( const char *value, bool richtung, bool geschossTyp = 0 )
+    : Variable( richtung ? RICHTUNG : ( geschossTyp ? GESCHOSS_TYP : STRING ) )
 {
     this->value = value;
 }

StickmanWorldOnline/Variablen.h

@@ -29,9 +29,14 @@ enum VariableTyp
     UMLENKUNG,
     TRIGGER,
     FEUERBALL_TREFFER,
-    AKTION
+    AKTION,
+    GAME_OBJEKT,
+    ALLE
 };
 
+bool operator==( VariableTyp a, VariableTyp b );
+bool operator!=( VariableTyp a, VariableTyp b );
+
 class Variable
 {
 private: