AKtionen zum zugriff auf Spielelemente und zum Rechnen mit Integern implementiert

StickmanWorldOnline/Aktionen.cpp

@@ -3088,3 +3088,244 @@ bool GeschossSetType::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *
     zPC->stepOut();
     return 0;
 }
+
+
+TriggerZufall::TriggerZufall()
+    : Aktion( TRIGGER_ZUFALL )
+{}
+
+bool TriggerZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getRandomTrigger() );
+    return 1;
+}
+
+
+TriggerLastRunned::TriggerLastRunned()
+    : Aktion( TRIGGER_LAST_RUNNED )
+{}
+
+bool TriggerLastRunned::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getLastRunnedTrigger() );
+    return 1;
+}
+
+
+BariereZufall::BariereZufall()
+    : Aktion( BARIERE_ZUFALL )
+{}
+
+bool BariereZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getRandomBariere() );
+    return 1;
+}
+
+
+BariereZuletztEingeschaltet::BariereZuletztEingeschaltet()
+    : Aktion( BARIERE_ZULETZT_EINGESCHALTET )
+{}
+
+bool BariereZuletztEingeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getZuletztEingeschalteteBariere() );
+    return 1;
+}
+
+
+BariereZuletztAusgeschaltet::BariereZuletztAusgeschaltet()
+    : Aktion( BARIERE_ZULETZT_AUSGESCHALTET )
+{}
+
+bool BariereZuletztAusgeschaltet::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getZuletztAusgeschalteteBariere() );
+    return 1;
+}
+
+
+BariereZuletztBewegt::BariereZuletztBewegt()
+    : Aktion( BARIERE_ZULETZT_BEWEGT )
+{}
+
+bool BariereZuletztBewegt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getZuletztBewegteBariere() );
+    return 1;
+}
+
+
+BaseZufall::BaseZufall()
+    : Aktion( BASE_ZUFALL )
+{}
+
+bool BaseZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getRandomBase() );
+    return 1;
+}
+
+
+BaseZuletztBesitzerGewechselt::BaseZuletztBesitzerGewechselt()
+    : Aktion( BASE_ZULETZT_BESITZER_GEWECHSELT )
+{}
+
+bool BaseZuletztBesitzerGewechselt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getLastTeamChangedBase() );
+    return 1;
+}
+
+
+DropZufall::DropZufall()
+    : Aktion( DROP_ZUFALL )
+{}
+
+bool DropZufall::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getRandomDrop() );
+    return 1;
+}
+
+
+DropZuletztGedropt::DropZuletztGedropt()
+    : Aktion( DROP_ZULETZT_GEDROPT )
+{}
+
+bool DropZuletztGedropt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zMemory->setVar( "__return__", zSpiel->getLastDrop() );
+    return 1;
+}
+
+
+IntegerRechnen::IntegerRechnen( Aktion *left, Aktion *right, Operator op )
+    : Aktion( INTEGER_RECHNEN )
+{
+    this->left = left;
+    this->right = right;
+    this->op = op;
+}
+
+IntegerRechnen::~IntegerRechnen()
+{
+    left->release();
+    right->release();
+}
+
+bool IntegerRechnen::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    zPC->stepIn();
+    bool finished = 0;
+    if( zPC->currentPosition() == 0 )
+    {
+        if( left->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() );
+            if( !isBinary( op ) )
+                finished = 1;
+            else
+                zPC->count();
+        }
+    }
+    if( zPC->currentPosition() == 1 && waitCount <= 0 )
+    {
+        if( right->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+        {
+            Variable *t = zMemory->zVariable( "__return__" );
+            if( !t || t->getVariableTyp() != INTEGER )
+            {
+                zPC->stepOut();
+                return 1;
+            }
+            zMemory->setVar( zPC->getUniqueString() + "R1__", t->getThis() );
+            finished = 1;
+        }
+    }
+    if( finished )
+    {
+        Integer *l = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R0__" );
+        Integer *r = (Integer *)zMemory->zVariable( zPC->getUniqueString() + "R1__" );
+        switch( op )
+        {
+        case PLUS:
+            zMemory->setVar( "__return__", new Integer( l->getValue() + r->getValue() ) );
+            break;
+        case MINUS:
+            zMemory->setVar( "__return__", new Integer( l->getValue() - r->getValue() ) );
+            break;
+        case MAHL:
+            zMemory->setVar( "__return__", new Integer( l->getValue() * r->getValue() ) );
+            break;
+        case GETEILT:
+            zMemory->setVar( "__return__", new Integer( l->getValue() / r->getValue() ) );
+            break;
+        case HOCH:
+            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), r->getValue() ) ) );
+            break;
+        case WURZEL:
+            zMemory->setVar( "__return__", new Integer( (int)pow( l->getValue(), 1.0 / r->getValue() ) ) );
+            break;
+        case BIT_ODER:
+            zMemory->setVar( "__return__", new Integer( l->getValue() | r->getValue() ) );
+            break;
+        case BIT_UND:
+            zMemory->setVar( "__return__", new Integer( l->getValue() & r->getValue() ) );
+            break;
+        case BIT_XOR:
+            zMemory->setVar( "__return__", new Integer( l->getValue() ^ r->getValue() ) );
+            break;
+        case BIT_FLIP:
+            zMemory->setVar( "__return__", new Integer( ~l->getValue() ) );
+            break;
+        case BIT_SHIFT_LEFT:
+            zMemory->setVar( "__return__", new Integer( l->getValue() << r->getValue() ) );
+            break;
+        case BIT_SHIFT_RIGHT:
+            zMemory->setVar( "__return__", new Integer( l->getValue() >> r->getValue() ) );
+            break;
+        case INVERT_SIGN:
+            zMemory->setVar( "__return__", new Integer( -l->getValue() ) );
+            break;
+        case PLUS_PLUS_LEFT:
+            l->setValue( l->getValue() + 1 );
+            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+            break;
+        case PLUS_PLUS_RIGHT:
+        {
+            int tmp = l->getValue();
+            l->setValue( l->getValue() + 1 );
+            zMemory->setVar( "__return__", new Integer( tmp ) );
+            break;
+        }
+        case MINUS_MINUS_LEFT:
+            l->setValue( l->getValue() - 1 );
+            zMemory->setVar( "__return__", new Integer( l->getValue() ) );
+            break;
+        case MINUS_MINUS_RIGHT:
+        {
+            int tmp = l->getValue();
+            l->setValue( l->getValue() - 1 );
+            zMemory->setVar( "__return__", new Integer( tmp ) );
+            break;
+        }
+        case LOGARITHM:
+            zMemory->setVar( "__return__", new Integer( log( l->getValue() ) / log( r->getValue() ) ) );
+            break;
+        case MODULO:
+            zMemory->setVar( "__return__", new Integer( l->getValue() % r->getValue() ) );
+            break;
+        }
+        zPC->stepOut();
+        return 1;
+    }
+    zPC->stepOut();
+    return 0;
+}

StickmanWorldOnline/Aktionen.h

@@ -224,6 +224,40 @@ enum AktionTyp
     SEQUENZ
 };
 
+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
 {
 private:
@@ -1064,10 +1098,10 @@ class IntegerRechnen : public Aktion
 private:
     Aktion *left;
     Aktion *right;
-    char op;
+    Operator op;
 
 public:
-    IntegerRechnen( Aktion *left, Aktion *right, char op );
+    IntegerRechnen( Aktion *left, Aktion *right, Operator op );
     ~IntegerRechnen();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };

StickmanWorldOnline/Spiel.h

@@ -118,6 +118,16 @@ public:
     double getRand();
     int getTickCount() const;
     void setEnde( Team *zGewinner );
+    Trigger *getRandomTrigger() const;
+    Trigger *getLastRunnedTrigger() const;
+    Bariere *getRandomBariere() const;
+    Bariere *getZuletztEingeschalteteBariere() const;
+    Bariere *getZuletztAusgeschalteteBariere() const;
+    Bariere *getZuletztBewegteBariere() const;
+    Base *getRandomBase() const;
+    Base *getLastTeamChangedBase() const;
+    Drop *getRandomDrop() const;
+    Drop *getLastDrop() const;
     // constant
     StatistikV *getStatistik() const override;
     // Reference Counting