Trigger implementiert

StickmanWorldOnline/Aktionen.h

@@ -219,7 +219,8 @@ enum AktionTyp
     UMLENKUNG_ZUFALL,
     UMLENKUNG_ZULETZT_BENUTZT,
     WARTEN,
-    WENN_DANN_SONST
+    WENN_DANN_SONST,
+    SEQUENZ
 };
 
 class Aktion
@@ -231,6 +232,7 @@ private:
 public:
     Aktion( AktionTyp typ );
     virtual ~Aktion();
+    // gibt 1 zurück, wenn die aktion vollständig ausgeführt wurde
     virtual bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) = 0;
     Aktion *getThis();
     Aktion *release();
@@ -465,27 +467,27 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetErfahrunNextg : public Aktion
+class SpielerSetErfahrung : public Aktion
 {
 private:
     Aktion *erfahrunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetErfahrunNextg( Aktion *erfahrunNextg, Aktion *spieler );
-    ~SpielerSetErfahrunNextg();
+    SpielerSetErfahrung( Aktion *erfahrunNextg, Aktion *spieler );
+    ~SpielerSetErfahrung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetMaxErfahrunNextg : public Aktion
+class SpielerSetMaxErfahrung : public Aktion
 {
 private:
     Aktion *erfahrunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetMaxErfahrunNextg( Aktion *erfahrunNextg, Aktion *spieler );
-    ~SpielerSetMaxErfahrunNextg();
+    SpielerSetMaxErfahrung( Aktion *erfahrunNextg, Aktion *spieler );
+    ~SpielerSetMaxErfahrung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -561,15 +563,15 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerSetAbklingzeitverringerunNextg : public Aktion
+class SpielerSetAbklingzeitverringerung : public Aktion
 {
 private:
     Aktion *verringerunNextg;
     Aktion *spieler;
 
 public:
-    SpielerSetAbklingzeitverringerunNextg( Aktion *verringerunNextg, Aktion *spieler );
-    ~SpielerSetAbklingzeitverringerunNextg();
+    SpielerSetAbklingzeitverringerung( Aktion *verringerunNextg, Aktion *spieler );
+    ~SpielerSetAbklingzeitverringerung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1370,25 +1372,25 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerErfahrunNextg : public Aktion
+class IntegerSpielerErfahrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerErfahrunNextg( Aktion *spieler );
-    ~IntegerSpielerErfahrunNextg();
+    IntegerSpielerErfahrung( Aktion *spieler );
+    ~IntegerSpielerErfahrung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerMaxErfahrunNextg : public Aktion
+class IntegerSpielerMaxErfahrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerMaxErfahrunNextg( Aktion *spieler );
-    ~IntegerSpielerMaxErfahrunNextg();
+    IntegerSpielerMaxErfahrung( Aktion *spieler );
+    ~IntegerSpielerMaxErfahrung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1458,14 +1460,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSpielerAbklingzeitverringerrunNextg : public Aktion
+class IntegerSpielerAbklingzeitVerringerung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerAbklingzeitverringerrunNextg( Aktion *spieler );
-    ~IntegerSpielerAbklingzeitverringerrunNextg();
+    IntegerSpielerAbklingzeitVerringerung( Aktion *spieler );
+    ~IntegerSpielerAbklingzeitVerringerung();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1690,14 +1692,14 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class IntegerSchalterAktivierunNextgen : public Aktion
+class IntegerSchalterAktivierungen : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
-    IntegerSchalterAktivierunNextgen( Aktion *schalter );
-    ~IntegerSchalterAktivierunNextgen();
+    IntegerSchalterAktivierungen( Aktion *schalter );
+    ~IntegerSchalterAktivierungen();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
@@ -1982,10 +1984,10 @@ public:
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 
-class SpielerZuletztErfahrunNextgBekommen : public Aktion
+class SpielerZuletztErfahrungBekommen : public Aktion
 {
 public:
-    SpielerZuletztErfahrunNextgBekommen();
+    SpielerZuletztErfahrungBekommen();
     bool runNext( Spiel *zSpiel, Ereignis *zEreignis, LocalMemory *zMemory, ProgramCounter *zPC, double &waitCount ) override;
 };
 

StickmanWorldOnline/Reader.cpp

@@ -180,7 +180,7 @@ Aktion *MapReader::readAktion( Datei &dat )
     case INTEGER_SCHALTER_AKTIVIERUNGEN:
         return new IntegerSchalterAktivierungen( params[ 0 ] );
     case INTEGER_SPIELER_ABKLINGZEITVERRINGERUNG:
-        return new IntegerSpielerAbklingzeitverringerrung( params[ 0 ] );
+        return new IntegerSpielerAbklingzeitVerringerung( params[ 0 ] );
     case INTEGER_SPIELER_ARMOR:
         return new IntegerSpielerArmor( params[ 0 ] );
     case INTEGER_SPIELER_ERFAHRUNG:
@@ -506,6 +506,13 @@ Aktion *MapReader::readAktion( Datei &dat )
         return new Warten( params[ 0 ] );
     case WENN_DANN_SONST:
         return new WennDannSonst( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case SEQUENZ:
+    {
+        RCArray< Aktion > *actions = new RCArray< Aktion >();
+        for( int i = 0; i < pAnz; i++ )
+            actions->add( params[ 0 ] );
+        return new Sequenz( actions );
+    }
     }
     return new KonstantNichts();
 }

StickmanWorldOnline/Spiel.cpp

@@ -603,7 +603,7 @@ void Spiel::addVariable( const char *name, Variable * var )
     bool found = 0;
     for( auto v = variablen.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
         {
             found = 1;
             break;
@@ -620,7 +620,7 @@ void Spiel::setVariable( const char *name, Variable * var )
     bool found = 0;
     for( auto v = variablen.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
         {
             v->setVariable( var );
             break;
@@ -827,7 +827,7 @@ Variable *Spiel::getVariable( const char *name ) const
 {
     for( auto v = variablen.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
             return v->getVariable();
     }
     return 0;
@@ -837,7 +837,7 @@ Variable *Spiel::zVariable( const char *name ) const
 {
     for( auto v = variablen.getIterator(); v; v++ )
     {
-        if( v->zName()->istGleich( name ) )
+        if( v->getName().istGleich( name ) )
             return v->zVariable();
     }
     return 0;

StickmanWorldOnline/Trigger.cpp

@@ -55,6 +55,110 @@ VarPointer *VarPointer::release()
     return 0;
 }
 
+
+LocalMemory::LocalMemory()
+{
+    ref = 1;
+}
+
+LocalMemory::~LocalMemory()
+{}
+
+void LocalMemory::setVar( const char *name, Variable *var )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+        {
+            v->setVariable( var );
+            return;
+        }
+    }
+    vars.add( new VarPointer( name, var ) );
+}
+
+Variable *LocalMemory::getVariable( const char *name )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->getVariable();
+    }
+    return 0;
+}
+
+Variable *LocalMemory::zVariable( const char *name )
+{
+    for( auto v = vars.getIterator(); v; v++ )
+    {
+        if( v->getName().istGleich( name ) )
+            return v->zVariable();
+    }
+    return 0;
+}
+
+LocalMemory *LocalMemory::getThis()
+{
+    ref++;
+    return this;
+}
+
+LocalMemory *LocalMemory::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
+ProgramCounter::ProgramCounter()
+{
+    current.add( 0 );
+    depth = 0;
+    ref = 1;
+}
+
+ProgramCounter::~ProgramCounter()
+{}
+
+void ProgramCounter::stepInto()
+{
+    depth++;
+    if( current.getEintragAnzahl() <= depth )
+        current.add( 0 );
+}
+
+void ProgramCounter::count()
+{
+    current.set( current.get( depth ) + 1, depth );
+    while( depth + 1 < current.getEintragAnzahl() )
+        current.remove( depth + 1 );
+}
+
+void ProgramCounter::stepOut()
+{
+    depth--;
+}
+
+int ProgramCounter::currentPosition() const
+{
+    return current.get( depth );
+}
+
+ProgramCounter *ProgramCounter::getThis()
+{
+    ref++;
+    return this;
+}
+
+ProgramCounter *ProgramCounter::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}
+
+
 Bedingung::Bedingung( Aktion *expression )
 {
     this->expression = expression;
@@ -81,30 +185,28 @@ bool Bedingung::check( Spiel *zSpiel, Ereignis *zEreignis )
     double wait;
     ProgramCounter c;
     LocalMemory m;
-    while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) )
+    while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) );
+    Variable *var = m.zVariable( "__return__" );
+    if( !var )
+        return 0;
+    switch( var->getVariableTyp() )
     {
-        Variable *var = m.zVariable( "__return__" );
-        if( !var )
-            return 0;
-        switch( var->getVariableTyp() )
-        {
-        case NICHTS:
-            return 0;
-        case INTEGER:
-            return ( (Integer *)var )->getValue() != 0;
-        case BOOLEAN:
-            return ( (Boolean *)var )->getValue();
-        case STRING:
-            return ( (String *)var )->getValue().getLength();
-        case FLOAT:
-            return ( (Float *)var )->getValue() != 0;
-        case TASTE:
-            return ( (Integer *)var )->getValue() != 0;
-        case GEGENSTAND_TYP:
-            return ( (GegenstandTypVar *)var )->getValue() != KEIN_GEGENSTAND;
-        default:
-            return 1;
-        }
+    case NICHTS:
+        return 0;
+    case INTEGER:
+        return ( (Integer *)var )->getValue() != 0;
+    case BOOLEAN:
+        return ( (Boolean *)var )->getValue();
+    case STRING:
+        return ( (String *)var )->getValue().getLength();
+    case FLOAT:
+        return ( (Float *)var )->getValue() != 0;
+    case TASTE:
+        return ( (Integer *)var )->getValue() != 0;
+    case GEGENSTAND_TYP:
+        return ( (GegenstandTypVar *)var )->getValue() != KEIN_GEGENSTAND;
+    default:
+        return 1;
     }
 }
 
@@ -120,3 +222,111 @@ Bedingung *Bedingung::release()
         delete this;
     return 0;
 }
+
+
+Trigger::Trigger( int id, const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen )
+    : Variable( TRIGGER )
+{
+    this->id = id;
+    this->name = name;
+    this->ereignisAnzahl = ereignisAnzahl;
+    this->ereignisse = ereignisse;
+    this->bedingungen = bedingungen;
+    this->aktionen = aktionen;
+}
+
+Trigger::~Trigger()
+{
+    delete[]ereignisse;
+    bedingungen->release();
+    aktionen->release();
+}
+
+bool Trigger::hatEreignis( EreignisTyp typ ) const
+{
+    for( int i = 0; i < ereignisAnzahl; i++ )
+    {
+        if( ereignisse[ i ] == typ )
+            return 1;
+    }
+    return 0;
+}
+
+int Trigger::getAktionAnzahl() const
+{
+    return aktionen->getEintragAnzahl();
+}
+
+Aktion *Trigger::zAktion( int index ) const
+{
+    return aktionen->z( index );
+}
+
+Aktion *Trigger::getAktion( int index ) const
+{
+    return aktionen->get( index );
+}
+
+// return: 0, falls die bedingungen nicht erfüllt sind
+TriggerRun *Trigger::runTrigger( Ereignis *e, Spiel *zSpiel )
+{
+    return new TriggerRun( (Trigger *)getThis(), e, zSpiel );
+}
+
+int Trigger::getId() const
+{
+    return id;
+}
+
+
+TriggerRun::TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel )
+{
+    trigger = trig;
+    ereignis = e;
+    this->zSpiel = zSpiel;
+    waitCount = 0;
+    ref = 1;
+}
+
+TriggerRun::~TriggerRun()
+{
+    trigger->release();
+    ereignis->release();
+}
+
+// gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
+bool TriggerRun::runNext( double t )
+{
+    if( waitCount > 0 )
+        waitCount -= t;
+    else
+    {
+        int current = counter.currentPosition();
+        if( current >= trigger->getAktionAnzahl() )
+            return 0;
+        Aktion *ak = trigger->zAktion( current );
+        if( !ak || ak->runNext( zSpiel, ereignis, &localMem, &counter, waitCount ) )
+            counter.count();
+        if( counter.currentPosition() >= trigger->getAktionAnzahl() )
+            return 0;
+    }
+    return 1;
+}
+
+Trigger *TriggerRun::getTrigger() const
+{
+    return (Trigger *)trigger->getThis();
+}
+
+TriggerRun *TriggerRun::getThis()
+{
+    ref++;
+    return this;
+}
+
+TriggerRun *TriggerRun::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Trigger.h

@@ -94,8 +94,6 @@ public:
     int getAktionAnzahl() const;
     Aktion *zAktion( int index ) const;
     Aktion *getAktion( int index ) const;
-    // prüft ob der auslöser von einem bestimmten ereignis ausgelößt wird
-    bool wirdGetriggertVon( EreignisTyp typ ) const;
     // return: 0, falls die bedingungen nicht erfüllt sind
     TriggerRun *runTrigger( Ereignis *e, Spiel *zSpiel );
     int getId() const;
@@ -106,15 +104,15 @@ class TriggerRun
 private:
     Trigger *trigger;
     Ereignis *ereignis;
-    Spiel *spiel;
-    LocalMemory *localMem;
+    Spiel *zSpiel;
+    LocalMemory localMem;
     ProgramCounter counter;
     int programCounter;
     double waitCount;
     int ref;
 
 public:
-    TriggerRun( Trigger *trig, Ereignis *e, Spiel *spiel );
+    TriggerRun( Trigger *trig, Ereignis *e, Spiel *zSpiel );
     ~TriggerRun();
     // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
     bool runNext( double t );