Alle Aktionen aus der Java version sind fertig implementiert

StickmanWorldOnline/Aktionen.cpp

@@ -2072,7 +2072,10 @@ TextConcat::TextConcat( RCArray< Aktion > *subActions )
 
 void TextConcat::run( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
 {
-    setReturn( new String( ( (String *)zParam( 0 ) )->getValue() + ( (String *)zParam( 1 ) )->getValue().getText() ) );
+    String *p1 = (String *)zParam( 0 );
+    String *p2 = (String *)zParam( 1 );
+    String *res = new String( p1->getValue().operator+( p2->getValue().getText() ) );
+    setReturn( res );
 }
 
 
@@ -2412,4 +2415,393 @@ BooleanSpielerKannItemBenutzen::BooleanSpielerKannItemBenutzen( RCArray< Aktion
 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/Reader.cpp

@@ -818,10 +818,10 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         EreignisTyp *ereignisse = new EreignisTyp[ ereignisAnzahl ];
         for( int j = 0; j < ereignisAnzahl; j++ )
             mapFile.lese( (char *)& ereignisse[ j ], 4 );
-        RCArray< Bedingung > * bedingungen = new RCArray< Bedingung >();
+        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 >();
+        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 ) );
@@ -876,7 +876,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
             char *value = new char[ (int)len + 1 ];
             mapFile.lese( (char *)& value, len );
             value[ (int)len ] = 0;
-            var = new String( value, 1 );
+            var = new String( getRichtungFromString( Text( value ) ) );
             delete[] value;
             break;
         }

StickmanWorldOnline/Trigger.h

@@ -103,6 +103,7 @@ public:
     int getId() const;
     int getRuns() const;
     const char *getName() const;
+    bool istAktiv() const;
 };
 
 class TriggerRun