Unterscheidung zwischen ints und floats im triggersystem korrigiert

StickmanWorldOnline/Aktionen.cpp

@@ -3069,3 +3069,235 @@ bool FloatYVonGameObjekt::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemo
     }
     return 0;
 }
+
+
+IntegerXVonTunnelZiel::IntegerXVonTunnelZiel( Aktion *tunnel )
+    : Aktion( INTEGER_X_VON_TUNNEL_ZIEL )
+{
+    this->tunnel = tunnel;
+}
+
+IntegerXVonTunnelZiel::~IntegerXVonTunnelZiel()
+{
+    tunnel->release();
+}
+
+bool IntegerXVonTunnelZiel::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+{
+    if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != TUNNEL )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Tunnel *)t )->getZielX() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerYVonTunnelZiel::IntegerYVonTunnelZiel( Aktion *tunnel )
+    : Aktion( INTEGER_Y_VON_TUNNEL_ZIEL )
+{
+    this->tunnel = tunnel;
+}
+
+IntegerYVonTunnelZiel::~IntegerYVonTunnelZiel()
+{
+    tunnel->release();
+}
+
+bool IntegerYVonTunnelZiel::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( tunnel->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != TUNNEL )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Tunnel *)t )->getZielY() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerMinXVonDrop::IntegerMinXVonDrop( Aktion *drop )
+    : Aktion( INTEGER_MIN_X_VON_DROP )
+{
+    this->drop = drop;
+}
+
+IntegerMinXVonDrop::~IntegerMinXVonDrop()
+{
+    drop->release();
+}
+
+bool IntegerMinXVonDrop::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+{
+    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != DROP )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMinX() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerMinYVonDrop::IntegerMinYVonDrop( Aktion *drop )
+    : Aktion( INTEGER_MIN_Y_VON_DROP )
+{
+    this->drop = drop;
+}
+
+IntegerMinYVonDrop::~IntegerMinYVonDrop()
+{
+    drop->release();
+}
+
+bool IntegerMinYVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != DROP )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMinY() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerMaxXVonDrop::IntegerMaxXVonDrop( Aktion *drop )
+    : Aktion( INTEGER_MAX_X_VON_DROP )
+{
+    this->drop = drop;
+}
+
+IntegerMaxXVonDrop::~IntegerMaxXVonDrop()
+{
+    drop->release();
+}
+
+bool IntegerMaxXVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != DROP )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMaxX() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerMaxYVonDrop::IntegerMaxYVonDrop( Aktion *drop )
+    : Aktion( INTEGER_MAX_Y_VON_DROP )
+{
+    this->drop = drop;
+}
+
+IntegerMaxYVonDrop::~IntegerMaxYVonDrop()
+{
+    drop->release();
+}
+
+bool IntegerMaxYVonDrop::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( drop->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != DROP )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Drop *)t )->getMaxY() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+IntegerSpielerLevel::IntegerSpielerLevel( Aktion *spieler )
+    : Aktion( INTEGER_SPIELER_LEVEL )
+{
+    this->spieler = spieler;
+}
+
+IntegerSpielerLevel::~IntegerSpielerLevel()
+{
+    spieler->release();
+}
+
+bool IntegerSpielerLevel::runNext( Spiel * zSpiel, Ereignis * zEreignis, LocalMemory * zMemory, ProgramCounter * zPC, double &waitCount )
+{
+    if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != SPIELER )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Integer( ( (Spieler *)t )->getLevel() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}
+
+
+FloatSpielerLeben::FloatSpielerLeben( Aktion *spieler )
+    : Aktion( FLOAT_SPIELER_LEBEN )
+{
+    this->spieler = spieler;
+}
+
+FloatSpielerLeben::~FloatSpielerLeben()
+{
+    spieler->release();
+}
+
+bool FloatSpielerLeben::runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount )
+{
+    if( spieler->runNext( zSpiel, zEreignis, zMemory, zPC, waitCount ) )
+    {
+        Variable *t = zMemory->zVariable( "__return__" );
+        if( !t || t->getVariableTyp() != SPIELER )
+        {
+            zPC->stepOut();
+            return 1;
+        }
+        zMemory->setVar( "__return__", new Float( ( (Spieler *)t )->getLeben() ) );
+        zPC->stepOut();
+        return 1;
+    }
+    return 0;
+}

StickmanWorldOnline/Aktionen.h

@@ -69,36 +69,36 @@ enum AktionTyp
     INTEGER_BARIERE_SCHALTUNGEN,
     INTEGER_BARIERE_VERSCHIEBUNGEN,
     INTEGER_DROP_MAX_ZEIT,
-    INTEGER_DROP_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,
-    INTEGER_SPIELER_ABKLINGZEITVERRINGERUNG,
-    INTEGER_SPIELER_ARMOR,
-    INTEGER_SPIELER_ERFAHRUNG,
-    INTEGER_SPIELER_ERLITTENER_SCHADEN,
-    INTEGER_SPIELER_GEHEILTES_LEBEN,
+    FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG,
+    FLOAT_SPIELER_ARMOR,
+    FLOAT_SPIELER_ERFAHRUNG,
+    FLOAT_SPIELER_ERLITTENER_SCHADEN,
+    FLOAT_SPIELER_GEHEILTES_LEBEN,
     INTEGER_SPIELER_GESCHOSSEN,
-    INTEGER_SPIELER_GESCHOSS_TEMPO,
+    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,
-    INTEGER_SPIELER_LEBEN,
-    INTEGER_SPIELER_LEBENSRAUB,
-    INTEGER_SPIELER_LEBENSREGENERATION,
+    FLOAT_SPIELER_LEBEN,
+    FLOAT_SPIELER_LEBENSRAUB,
+    FLOAT_SPIELER_LEBENSREGENERATION,
     INTEGER_SPIELER_LEVEL,
     INTEGER_SPIELER_MAX_ERFAHRUNG,
     INTEGER_SPIELER_MAX_LEBEN,
-    INTEGER_SPIELER_SCHADEN,
-    INTEGER_SPIELER_SCHADEN_BONUS,
+    FLOAT_SPIELER_SCHADEN,
+    FLOAT_SPIELER_SCHADEN_BONUS,
     INTEGER_SPIELER_SCHALTER_AKTIVIERT,
-    INTEGER_SPIELER_TEMPO,
+    FLOAT_SPIELER_TEMPO,
     INTEGER_SPIELER_TODE,
     INTEGER_SPIELER_TREFFER,
     INTEGER_SPIELER_TUNNEL_BENUTZT,
@@ -106,8 +106,8 @@ enum AktionTyp
     INTEGER_TEAM_PUNKTE,
     INTEGER_TEAM_SPIELERANZAHL,
     INTEGER_TEAM_TODE,
-    INTEGER_TEAM_WIEDERBELEBUNGSZEIT,
-    INTEGER_TIMER_AKTUELLE_ZEIT,
+    FLOAT_TEAM_WIEDERBELEBUNGSZEIT,
+    FLOAT_TIMER_AKTUELLE_ZEIT,
     INTEGER_TIMER_MAX_ZEIT,
     INTEGER_TRIGGER_RUNNS,
     INTEGER_TUNNEL_BENUTZUNGEN,
@@ -170,7 +170,7 @@ enum AktionTyp
     TEAM_ZUFALL,
     TEXT_AUS_BOOLEAN,
     TEXT_AUS_RICHTUNG,
-    TEXT_AUS_ZAHL,
+    TEXT_AUS_INTEGER,
     TEXT_CONCAT,
     TEXT_ITEM_NAME,
     TEXT_SPIELER_NAME,
@@ -201,7 +201,13 @@ enum AktionTyp
     UMLENKUNG_ZULETZT_BENUTZT,
     WARTEN,
     WENN_DANN_SONST,
-    SEQUENZ
+    SEQUENZ,
+    FLOAT_RECHNUNG,
+    FLOAT_AUS_INTEGER,
+    FLOAT_AUS_TEXT,
+    TEXT_AUS_FLOAT,
+    FLOAT_ZUFALL,
+    INTEGER_AUS_FLOAT
 };
 
 enum Operator
@@ -1208,14 +1214,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerLeben : public Aktion
+class FloatSpielerLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerLeben( Aktion *spieler );
-    ~IntegerSpielerLeben();
+    FloatSpielerLeben( Aktion *spieler );
+    ~FloatSpielerLeben();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1230,14 +1236,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerErfahrung : public Aktion
+class FloatSpielerErfahrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerErfahrung( Aktion *spieler );
-    ~IntegerSpielerErfahrung();
+    FloatSpielerErfahrung( Aktion *spieler );
+    ~FloatSpielerErfahrung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1252,80 +1258,80 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerTempo : public Aktion
+class FloatSpielerTempo : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerTempo( Aktion *spieler );
-    ~IntegerSpielerTempo();
+    FloatSpielerTempo( Aktion *spieler );
+    ~FloatSpielerTempo();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerGeschossTempo : public Aktion
+class FloatSpielerGeschossTempo : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerGeschossTempo( Aktion *spieler );
-    ~IntegerSpielerGeschossTempo();
+    FloatSpielerGeschossTempo( Aktion *spieler );
+    ~FloatSpielerGeschossTempo();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerArmor : public Aktion
+class FloatSpielerArmor : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerArmor( Aktion *spieler );
-    ~IntegerSpielerArmor();
+    FloatSpielerArmor( Aktion *spieler );
+    ~FloatSpielerArmor();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerSchadenBonus : public Aktion
+class FloatSpielerSchadenBonus : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerSchadenBonus( Aktion *spieler );
-    ~IntegerSpielerSchadenBonus();
+    FloatSpielerSchadenBonus( Aktion *spieler );
+    ~FloatSpielerSchadenBonus();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerLebensraub : public Aktion
+class FloatSpielerLebensraub : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerLebensraub( Aktion *spieler );
-    ~IntegerSpielerLebensraub();
+    FloatSpielerLebensraub( Aktion *spieler );
+    ~FloatSpielerLebensraub();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerLebensregeneration : public Aktion
+class FloatSpielerLebensregeneration : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerLebensregeneration( Aktion *spieler );
-    ~IntegerSpielerLebensregeneration();
+    FloatSpielerLebensregeneration( Aktion *spieler );
+    ~FloatSpielerLebensregeneration();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerAbklingzeitVerringerung : public Aktion
+class FloatSpielerAbklingzeitVerringerung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerAbklingzeitVerringerung( Aktion *spieler );
-    ~IntegerSpielerAbklingzeitVerringerung();
+    FloatSpielerAbklingzeitVerringerung( Aktion *spieler );
+    ~FloatSpielerAbklingzeitVerringerung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1373,36 +1379,36 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerErlittenerSchaden : public Aktion
+class FloatSpielerErlittenerSchaden : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerErlittenerSchaden( Aktion *spieler );
-    ~IntegerSpielerErlittenerSchaden();
+    FloatSpielerErlittenerSchaden( Aktion *spieler );
+    ~FloatSpielerErlittenerSchaden();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerSchaden : public Aktion
+class FloatSpielerSchaden : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerSchaden( Aktion *spieler );
-    ~IntegerSpielerSchaden();
+    FloatSpielerSchaden( Aktion *spieler );
+    ~FloatSpielerSchaden();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerGeheiltesLeben : public Aktion
+class FloatSpielerGeheiltesLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerGeheiltesLeben( Aktion *spieler );
-    ~IntegerSpielerGeheiltesLeben();
+    FloatSpielerGeheiltesLeben( Aktion *spieler );
+    ~FloatSpielerGeheiltesLeben();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1484,14 +1490,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerDropZeit : public Aktion
+class FloatDropZeit : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
-    IntegerDropZeit( Aktion *drop );
-    ~IntegerDropZeit();
+    FloatDropZeit( Aktion *drop );
+    ~FloatDropZeit();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1616,14 +1622,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerTeamWiederbelegungszeit : public Aktion
+class FloatTeamWiederbelegungszeit : public Aktion
 {
 private:
     Aktion *team;
 
 public:
-    IntegerTeamWiederbelegungszeit( Aktion *team );
-    ~IntegerTeamWiederbelegungszeit();
+    FloatTeamWiederbelegungszeit( Aktion *team );
+    ~FloatTeamWiederbelegungszeit();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1638,14 +1644,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerTimerAktuelleZeit : public Aktion
+class FloatTimerAktuelleZeit : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
-    IntegerTimerAktuelleZeit( Aktion *timer );
-    ~IntegerTimerAktuelleZeit();
+    FloatTimerAktuelleZeit( Aktion *timer );
+    ~FloatTimerAktuelleZeit();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1910,14 +1916,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class TextAusZahl : public Aktion
+class TextAusInteger : public Aktion
 {
 private:
     Aktion *zahl;
 
 public:
-    TextAusZahl( Aktion *zahl );
-    ~TextAusZahl();
+    TextAusInteger( Aktion *zahl );
+    ~TextAusInteger();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -2341,4 +2347,73 @@ public:
     Sequenz( RCArray< Aktion > *aktions );
     ~Sequenz();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
-};
+};
+
+class FloatRechnung : public Aktion
+{
+private:
+    Aktion *left;
+    Aktion *right;
+    Operator op;
+
+public:
+    FloatRechnung( Aktion *left, Aktion *right, Operator op );
+    ~FloatRechnung();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatAusInteger : public Aktion
+{
+private:
+    Aktion *integer;
+
+public:
+    FloatAusInteger( Aktion *integer );
+    ~FloatAusInteger();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatAusText : public Aktion
+{
+private:
+    Aktion *text;
+
+public:
+    FloatAusText( Aktion *text );
+    ~FloatAusText();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class TextAusFloat : public Aktion
+{
+private:
+    Aktion *f;
+
+public:
+    TextAusFloat( Aktion *f );
+    ~TextAusFloat();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class FloatZufall : public Aktion
+{
+private:
+    Aktion *min;
+    Aktion *max;
+
+public:
+    FloatZufall( Aktion *min, Aktion *max );
+    ~FloatZufall();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};
+
+class IntegerAusFloat : public Aktion
+{
+private:
+    Aktion *f;
+
+public:
+    IntegerAusFloat( Aktion *f );
+    ~IntegerAusFloat();
+    bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
+};

StickmanWorldOnline/Reader.cpp

@@ -159,8 +159,8 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new IntegerBariereVerschiebungen( params[ 0 ] );
     case INTEGER_DROP_MAX_ZEIT:
         return new IntegerDropMaxZeit( params[ 0 ] );
-    case INTEGER_DROP_ZEIT:
-        return new IntegerDropZeit( params[ 0 ] );
+    case FLOAT_DROP_ZEIT:
+        return new FloatDropZeit( params[ 0 ] );
     case INTEGER_MAX_X_VON_DROP:
         return new IntegerMaxXVonDrop( params[ 0 ] );
     case INTEGER_MAX_Y_VON_DROP:
@@ -177,20 +177,20 @@ Aktion *MapReader::readAktion( Datei &dat )
     }
     case INTEGER_SCHALTER_AKTIVIERUNGEN:
         return new IntegerSchalterAktivierungen( params[ 0 ] );
-    case INTEGER_SPIELER_ABKLINGZEITVERRINGERUNG:
-        return new IntegerSpielerAbklingzeitVerringerung( params[ 0 ] );
-    case INTEGER_SPIELER_ARMOR:
-        return new IntegerSpielerArmor( params[ 0 ] );
-    case INTEGER_SPIELER_ERFAHRUNG:
-        return new IntegerSpielerErfahrung( params[ 0 ] );
-    case INTEGER_SPIELER_ERLITTENER_SCHADEN:
-        return new IntegerSpielerErlittenerSchaden( params[ 0 ] );
-    case INTEGER_SPIELER_GEHEILTES_LEBEN:
-        return new IntegerSpielerGeheiltesLeben( params[ 0 ] );
+    case FLOAT_SPIELER_ABKLINGZEITVERRINGERUNG:
+        return new FloatSpielerAbklingzeitVerringerung( params[ 0 ] );
+    case FLOAT_SPIELER_ARMOR:
+        return new FloatSpielerArmor( params[ 0 ] );
+    case FLOAT_SPIELER_ERFAHRUNG:
+        return new FloatSpielerErfahrung( params[ 0 ] );
+    case FLOAT_SPIELER_ERLITTENER_SCHADEN:
+        return new FloatSpielerErlittenerSchaden( params[ 0 ] );
+    case FLOAT_SPIELER_GEHEILTES_LEBEN:
+        return new FloatSpielerGeheiltesLeben( params[ 0 ] );
     case INTEGER_SPIELER_GESCHOSSEN:
         return new IntegerSpielerGeschossen( params[ 0 ] );
-    case INTEGER_SPIELER_GESCHOSS_TEMPO:
-        return new IntegerSpielerGeschossTempo( params[ 0 ] );
+    case FLOAT_SPIELER_GESCHOSS_TEMPO:
+        return new FloatSpielerGeschossTempo( params[ 0 ] );
     case INTEGER_SPIELER_GETROFFEN:
         return new IntegerSpielerGetroffen( params[ 0 ] );
     case INTEGER_SPIELER_ITEMS_AUFGEHOBEN:
@@ -203,26 +203,26 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new IntegerSpielerItemsVerwendet( params[ 0 ] );
     case INTEGER_SPIELER_KILLS:
         return new IntegerSpielerKills( params[ 0 ] );
-    case INTEGER_SPIELER_LEBEN:
-        return new IntegerSpielerLeben( params[ 0 ] );
-    case INTEGER_SPIELER_LEBENSRAUB:
-        return new IntegerSpielerLebensraub( params[ 0 ] );
-    case INTEGER_SPIELER_LEBENSREGENERATION:
-        return new IntegerSpielerLebensregeneration( params[ 0 ] );
+    case FLOAT_SPIELER_LEBEN:
+        return new FloatSpielerLeben( params[ 0 ] );
+    case FLOAT_SPIELER_LEBENSRAUB:
+        return new FloatSpielerLebensraub( params[ 0 ] );
+    case FLOAT_SPIELER_LEBENSREGENERATION:
+        return new FloatSpielerLebensregeneration( params[ 0 ] );
     case INTEGER_SPIELER_LEVEL:
         return new IntegerSpielerLevel( params[ 0 ] );
     case INTEGER_SPIELER_MAX_ERFAHRUNG:
         return new IntegerSpielerMaxErfahrung( params[ 0 ] );
     case INTEGER_SPIELER_MAX_LEBEN:
         return new IntegerSpielerMaxLeben( params[ 0 ] );
-    case INTEGER_SPIELER_SCHADEN:
-        return new IntegerSpielerSchaden( params[ 0 ] );
-    case INTEGER_SPIELER_SCHADEN_BONUS:
-        return new IntegerSpielerSchadenBonus( params[ 0 ] );
+    case FLOAT_SPIELER_SCHADEN:
+        return new FloatSpielerSchaden( params[ 0 ] );
+    case FLOAT_SPIELER_SCHADEN_BONUS:
+        return new FloatSpielerSchadenBonus( params[ 0 ] );
     case INTEGER_SPIELER_SCHALTER_AKTIVIERT:
         return new IntegerSpielerSchalterAktiviert( params[ 0 ] );
-    case INTEGER_SPIELER_TEMPO:
-        return new IntegerSpielerTempo( params[ 0 ] );
+    case FLOAT_SPIELER_TEMPO:
+        return new FloatSpielerTempo( params[ 0 ] );
     case INTEGER_SPIELER_TODE:
         return new IntegerSpielerTode( params[ 0 ] );
     case INTEGER_SPIELER_TREFFER:
@@ -237,10 +237,10 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new IntegerTeamSpieleranzahl( params[ 0 ] );
     case INTEGER_TEAM_TODE:
         return new IntegerTeamTode( params[ 0 ] );
-    case INTEGER_TEAM_WIEDERBELEBUNGSZEIT:
-        return new IntegerTeamWiederbelegungszeit( params[ 0 ] );
-    case INTEGER_TIMER_AKTUELLE_ZEIT:
-        return new IntegerTimerAktuelleZeit( params[ 0 ] );
+    case FLOAT_TEAM_WIEDERBELEBUNGSZEIT:
+        return new FloatTeamWiederbelegungszeit( params[ 0 ] );
+    case FLOAT_TIMER_AKTUELLE_ZEIT:
+        return new FloatTimerAktuelleZeit( params[ 0 ] );
     case INTEGER_TIMER_MAX_ZEIT:
         return new IntegerTimerMaxZeit( params[ 0 ] );
     case INTEGER_TRIGGER_RUNNS:
@@ -404,8 +404,8 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new TextAusBoolean( params[ 0 ] );
     case TEXT_AUS_RICHTUNG:
         return new TextAusRichtung( params[ 0 ] );
-    case TEXT_AUS_ZAHL:
-        return new TextAusZahl( params[ 0 ] );
+    case TEXT_AUS_INTEGER:
+        return new TextAusInteger( params[ 0 ] );
     case TEXT_CONCAT:
         return new TextConcat( params[ 0 ], params[ 1 ] );
     case TEXT_ITEM_NAME:
@@ -473,6 +473,22 @@ Aktion *MapReader::readAktion( Datei &dat )
             actions->add( params[ 0 ] );
         return new Sequenz( actions );
     }
+    case FLOAT_RECHNUNG:
+    {
+        char op;
+        dat.lese( &op, 1 );
+        return new FloatRechnung( params[ 0 ], params[ 1 ], (Operator)op );
+    }
+    case FLOAT_AUS_INTEGER:
+        return new FloatAusInteger( params[ 0 ] );
+    case FLOAT_AUS_TEXT:
+        return new FloatAusText( params[ 0 ] );
+    case TEXT_AUS_FLOAT:
+        return new TextAusFloat( params[ 0 ] );
+    case FLOAT_ZUFALL:
+        return new FloatZufall( params[ 0 ], params[ 0 ] );
+    case INTEGER_AUS_FLOAT:
+        return new IntegerAusFloat( params[ 0 ] );
     }
     return new KonstantNichts();
 }

StickmanWorldOnline/Spieler.h

@@ -130,4 +130,6 @@ public:
     Richtung getAusrichtung() const;
     float getAbklingZeitVerringerung() const;
     int getId() const;
+    int getLevel() const;
+    float getLeben() const;
 };