Timer, Tunnel und Umlenkungen fertig

StickmanWorldOnline/Bariere.h

@@ -19,7 +19,6 @@ public:
         const static int Aktiv = 0x40;
     };
 private:
-    static int nextId;
     int style;
     int autoSchaltungMaxTime;
     float autoSchaltungCurrentTime;
@@ -31,7 +30,7 @@ private:
     Team *team;
 
 public:
-    Bariere( int x, int y, int breite, int height, int style, int verschiebungWeite = 0, int autoSchaltungMaxTime = 0, Team *team = 0 );
+    Bariere( int id, int x, int y, int breite, int height, int style, int verschiebungWeite = 0, int autoSchaltungMaxTime = 0, Team *team = 0 );
     ~Bariere();
     void setStyle( int style, bool add );
     void setAutoVerschiebungWeite( int pixel );

StickmanWorldOnline/Base.h

@@ -8,7 +8,6 @@ class Spiel;
 class Base : public GameObject
 {
 private:
-    static int nextId;
     int id;
     Team *team;
     int maxTime;
@@ -17,7 +16,7 @@ private:
     float leftTime;
 
 public:
-    Base( int x, int y, int width, int height, int maxTime = 10, Team *team = 0 );
+    Base( int id, int x, int y, int width, int height, int maxTime = 10, Team *team = 0 );
     ~Base();
     void setTeam( Team *team );
     void tick( double time, Spiel *zSpiel );

StickmanWorldOnline/Ereignis.h

@@ -7,28 +7,28 @@ class VarPointer;
 
 enum EreignisTyp
 {
-    AUSLOESER_RUNNED,
+    AUSLOESER_RUNNED, // "Betroffener Auslöser"
     BARIERE_SWITCHED,
     BARIERE_WIRD_VERSCHOBEN,
     BASIS_BESITZERWECHSEL,
     GEGENSTAND_ERSCHEINT,
-    INITIALISIERUNG,
-    SCHALTER_AKTIVIERT,
+    INITIALISIERUNG, //
+    SCHALTER_AKTIVIERT, // "Betroffener Schalter"
     SPIELER_BENUTZT_GEGENSTAND,
-    SPIELER_KEY_PRESSED,
+    SPIELER_KEY_PRESSED, // "Betroffene Taste", "Ausführender Spieler"
     SPIELER_BEKOMMT_ERFAHRUNG,
     SPIELER_BEKOMMT_GEGENSTAND,
-    SPIELER_KEY_RELEASED,
+    SPIELER_KEY_RELEASED, // "Betroffene Taste", "Ausführender Spieler"
     SPIELER_LEVEL_UP,
     SPIELER_MACHT_SCHADEN,
     SPIELER_NIMMT_SCHADEN,
     SPIELER_STIRBT,
     SPIELER_WIEDERBELEBT,
     SPIELER_WIRD_GEHEILT,
-    TIMER_RUNNS_OUT,
-    TIMER_BEGINNT,
-    TUNNEL_BENUTZT,
-    UMLENKUNG_LENKT_UM
+    TIMER_RUNNS_OUT, // "Betroffener Timer"
+    TIMER_BEGINNT, // "Betroffener Timer"
+    TUNNEL_BENUTZT, // {"Betroffes Geschoss", "Betroffer Spieler"}, "Betroffer Tunnel"
+    UMLENKUNG_LENKT_UM // "Betroffes Geschoss", "Betroffe Umlenkung"
 };
 
 class Ereignis

StickmanWorldOnline/Gegenstand.h

@@ -25,14 +25,26 @@ enum GegenstandTyp
     ITEMANZAHL
 };
 
+class GegenstandTypVar : public Variable
+{
+private:
+    GegenstandTyp value;
+
+public:
+    GegenstandTypVar( GegenstandTyp value );
+    void setValue( GegenstandTyp value );
+    GegenstandTyp getValue() const;
+};
+
 class Gegenstand : public GameObject
 {
 private:
     GegenstandTyp typ;
     bool onMap;
+    int id;
 
 public:
-    Gegenstand( GegenstandTyp typ, bool onMap = 0, int x = 0, int y = 0, int w = 50, int h = 50 );
+    Gegenstand( int id, GegenstandTyp typ, bool onMap = 0, int x = 0, int y = 0, int w = 50, int h = 50 );
     ~Gegenstand();
     bool isOnMap() const;
 };

StickmanWorldOnline/Geschoss.h

@@ -21,9 +21,10 @@ private:
     int tunnelBenutzt;
     int umgelenkt;
     int geschosseGetroffen;
+    int id;
 
 public:
-    Geschoss( float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer );
+    Geschoss( int id, float speed, GeschossTyp typ, Richtung r, int x, int y, Spieler *besitzer );
     ~Geschoss();
     void invertDirection();
     void setRichtung( Richtung r );
@@ -37,11 +38,12 @@ public:
 class FeuerballTreffer : public GameObject
 {
 private:
+    int id;
     Spieler *besitzer;
     float timeLeft;
 
 public:
-    FeuerballTreffer( int x, int y, Spieler *besitzer, int maxZeit );
+    FeuerballTreffer( int id, int x, int y, Spieler *besitzer, int maxZeit );
     ~FeuerballTreffer();
     void tick( double zeit );
 };

StickmanWorldOnline/Reader.cpp

@@ -649,7 +649,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& verschiebungWeite, 4 );
         mapFile.lese( (char *)& autoSchaltungMaxTime, 4 );
         mapFile.lese( (char *)& team, 4 );
-        zSpiel->addBariere( new Bariere( x, y, breite, height, style, verschiebungWeite, autoSchaltungMaxTime, zSpiel->getTeam( team ) ) );
+        zSpiel->addBariere( new Bariere( zSpiel->getNextId(), x, y, breite, height, style, verschiebungWeite, autoSchaltungMaxTime, zSpiel->getTeam( team ) ) );
     }
     // Basen
     mapFile.lese( (char *)& anz, 4 );
@@ -667,7 +667,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& height, 4 );
         mapFile.lese( (char *)& maxTime, 4 );
         mapFile.lese( (char *)& team, 4 );
-        zSpiel->addBase( new Base( x, y, breite, height, maxTime, zSpiel->getTeam( team ) ) );
+        zSpiel->addBase( new Base( zSpiel->getNextId(), x, y, breite, height, maxTime, zSpiel->getTeam( team ) ) );
     }
     // Drops
     mapFile.lese( (char *)& anz, 4 );
@@ -710,7 +710,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& breite, 4 );
         mapFile.lese( (char *)& height, 4 );
         mapFile.lese( (char *)& aktive, 1 );
-        zSpiel->addSchalter( new Schalter( x, y, breite, height, aktive ) );
+        zSpiel->addSchalter( new Schalter( zSpiel->getNextId(), x, y, breite, height, aktive ) );
     }
     // Schiene
     mapFile.lese( (char *)& anz, 4 );
@@ -724,7 +724,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& y, 4 );
         mapFile.lese( (char *)& breite, 4 );
         mapFile.lese( (char *)& height, 4 );
-        zSpiel->addSchiene( new Schiene( x, y, breite, height ) );
+        zSpiel->addSchiene( new Schiene( zSpiel->getNextId(), x, y, breite, height ) );
     }
     // Timer
     mapFile.lese( (char *)& anz, 4 );
@@ -749,7 +749,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         char *name = new char[ (int)len + 1 ];
         mapFile.lese( (char *)& name, len );
         name[ (int)len ] = 0;
-        zSpiel->addTimer( new Timer( name, maxZeit, x, y, sichtbar, autoWiederhohlung, runns, farbe ) );
+        zSpiel->addTimer( new Timer( zSpiel->getNextId(), name, maxZeit, x, y, sichtbar, autoWiederhohlung, runns, farbe ) );
         delete[] name;
     }
     // Tunnel
@@ -770,7 +770,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& zielX, 4 );
         mapFile.lese( (char *)& zielY, 4 );
         mapFile.lese( (char *)& aktiv, 1 );
-        zSpiel->addTunnel( new Tunnel( x, y, breite, height, zielX, zielY, aktiv ) );
+        zSpiel->addTunnel( new Tunnel( zSpiel->getNextId(), x, y, breite, height, zielX, zielY, aktiv ) );
     }
     // Umlenkungen
     mapFile.lese( (char *)& anz, 4 );
@@ -792,7 +792,7 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         mapFile.lese( (char *)& maxAbklingzeit, 4 );
         mapFile.lese( (char *)& drehend, 1 );
         mapFile.lese( (char *)& aktiv, 1 );
-        zSpiel->addUmlenkung( new Umlenkung( x, y, breite, height, (Richtung)richtung, maxAbklingzeit, drehend, aktiv ) );
+        zSpiel->addUmlenkung( new Umlenkung( zSpiel->getNextId(), x, y, breite, height, (Richtung)richtung, maxAbklingzeit, drehend, aktiv ) );
     }
     // Trigger
     mapFile.lese( (char *)& anz, 4 );
@@ -821,11 +821,159 @@ void MapReader::ladeKarte( Spiel *zSpiel )
         zSpiel->addTrigger( new Trigger( name, ereignisAnzahl, ereignisse, bedingungen, aktionen ) );
         delete[] name;
     }
+    // Variablen
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        char len;
+        mapFile.lese( (char *)& len, 1 );
+        char *name = new char[ (int)len + 1 ];
+        mapFile.lese( (char *)& name, len );
+        name[ (int)len ] = 0;
+        char typ;
+        mapFile.lese( &typ, 1 );
+        Variable *var;
+        switch( typ )
+        {
+        case NICHTS:
+            var = new Variable( NICHTS );
+            break;
+        case INTEGER:
+        {
+            int val;
+            mapFile.lese( (char *)& val, 4 );
+            var = new Integer( val );
+            break;
+        }
+        case BOOLEAN:
+        {
+            bool val;
+            mapFile.lese( (char *)& val, 1 );
+            var = new Boolean( val );
+            break;
+        }
+        case STRING:
+        {
+            char len;
+            mapFile.lese( (char *)& len, 1 );
+            char *value = new char[ (int)len + 1 ];
+            mapFile.lese( (char *)& value, len );
+            value[ (int)len ] = 0;
+            var = new String( value );
+            delete[] value;
+            break;
+        }
+        case RICHTUNG:
+        {
+            char len;
+            mapFile.lese( (char *)& len, 1 );
+            char *value = new char[ (int)len + 1 ];
+            mapFile.lese( (char *)& value, len );
+            value[ (int)len ] = 0;
+            var = new String( value, 1 );
+            delete[] value;
+            break;
+        }
+        case FLOAT:
+        {
+            float val;
+            mapFile.lese( (char *)& val, 4 );
+            var = new Float( val );
+            break;
+        }
+        case TASTE:
+        {
+            char val;
+            mapFile.lese( &val, 1 );
+            var = new Integer( val, 1 );
+            break;
+        }
+        case SPIELER:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getSpieler( id );
+            break;
+        }
+        case TIMER:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getTimer( id );
+            break;
+        }
+        case TEAM:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getTeam( id );
+            break;
+        }
+        case BARIERE:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getBariere( id );
+            break;
+        }
+        case SCHALTER:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getSchalter( id );
+            break;
+        }
+        case BASE:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getBase( id );
+            break;
+        }
+        case GEGENSTAND:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = new GegenstandTypVar( (GegenstandTyp)id );
+            break;
+        }
+        case SCHIENE:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getSchiene( id );
+            break;
+        }
+        case TUNNEL:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getTunnel( id );
+            break;
+        }
+        case UMLENKUNG:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getUmlenkung( id );
+            break;
+        }
+        case TRIGGER:
+        {
+            int id;
+            mapFile.lese( (char *)& id, 4 );
+            var = zSpiel->getTrigger( id );
+            break;
+        }
+        }
+        zSpiel->addVariable( name, var );
+        delete[] name;
+    }
     mapFile.close();
 }
 
 // Reference Counting
-MapReader * MapReader::getThis()
+MapReader *MapReader::getThis()
 {
     ref++;
     return this;

StickmanWorldOnline/Schalter.h

@@ -5,13 +5,12 @@
 class Schalter : public GameObject
 {
 private:
-    static int nextId;
     int id;
     bool aktiv = true;
     int aktivierungen = 0;
 
 public:
-    Schalter( int x, int y, int width, int height, bool aktive );
+    Schalter( int id, int x, int y, int width, int height, bool aktive );
     ~Schalter();
     void setAktive() const;
     void press();

StickmanWorldOnline/Schiene.h

@@ -4,6 +4,8 @@
 
 class Schiene : public GameObject
 {
+private:
+    int id;
 public:
-    Schiene( int x, int y, int width, int height );
+    Schiene( int id, int x, int y, int width, int height );
 };

StickmanWorldOnline/Spiel.cpp

@@ -5,6 +5,7 @@
 // Konstruktor
 Spiel::Spiel()
 {
+    nextId = 0;
     isRunning = 0;
     log = 0;
     spielerAnzahl = 0;
@@ -136,6 +137,7 @@ void Spiel::run()
         if( tmp && tmp->zKlient() )
             tmp->zKlient()->sendeStart( gameTicks );
     }
+    throwEvent( new Ereignis( INITIALISIERUNG ) );
     double rZeit = 0;
     while( !ende )
     {
@@ -248,6 +250,11 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                     saveMSG = 0;
                     break;
                 }
+                Ereignis *e = new Ereignis( SPIELER_KEY_PRESSED );
+                char buff[] = { *bytes, 0 };
+                e->addParameter( "Betroffene Taste", new String( buff ) );
+                e->addParameter( "Ausführender Spieler", tmp->getThis() );
+                throwEvent( e );
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
                     Spieler *s = spieler.z( j );
@@ -271,6 +278,11 @@ void Spiel::nachricht( int accountId, int len, char *bytes )
                     saveMSG = 0;
                     break;
                 }
+                Ereignis *e = new Ereignis( SPIELER_KEY_RELEASED );
+                char buff[] = { *bytes, 0 };
+                e->addParameter( "Betroffene Taste", new String( buff ) );
+                e->addParameter( "Ausführender Spieler", tmp->getThis() );
+                throwEvent( e );
                 for( int j = 0; j < spielerAnzahl; j++ )
                 {
                     Spieler *s = spieler.z( j );
@@ -338,12 +350,15 @@ void Spiel::tick( double zeit )
     for( auto s = spieler.getIterator(); s; s++ )
     {
         s->tick( zeit );
-        for( auto b = barieren.getIterator(); b; b++ )
-        { // spieler - bariere intersection
-            if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
-                s->tick( -zeit );
-            else if( s->getX() < 0 || s->getY() < 0 || s->getX() + s->getWidth() >= mapSize.x || s->getY() + s->getHeight() >= mapSize.y )
-                s->tick( -zeit );
+        if( s->getX() < 0 || s->getY() < 0 || s->getX() + s->getWidth() >= mapSize.x || s->getY() + s->getHeight() >= mapSize.y )
+            s->tick( -zeit );
+        else
+        {
+            for( auto b = barieren.getIterator(); b; b++ )
+            { // spieler - bariere intersection
+                if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
+                    s->tick( -zeit );
+            }
         }
     }
     // barieren bewegung
@@ -382,7 +397,7 @@ void Spiel::tick( double zeit )
             case GESCHOSS_FEUERBALL:
                 if( intersectsWithBariere )
                 {
-                    feuer.add( new FeuerballTreffer( g->getX() - 70, g->getY() - 70, g->getBesitzer(), 10 ) );
+                    feuer.add( new FeuerballTreffer( ++nextId, g->getX() - 70, g->getY() - 70, g->getBesitzer(), 10 ) );
                     shots.remove( i );
                     i--;
                     removed = 1;
@@ -398,6 +413,10 @@ void Spiel::tick( double zeit )
             {
                 if( t->istAktiv() && t->intersectsWith( g ) )
                 {
+                    Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
+                    e->addParameter( "Betroffes Geschoss", g->getThis() );
+                    e->addParameter( "Betroffer Tunnel", t->getThis() );
+                    throwEvent( e );
                     g->setX( g->getX() + t->getZielX() - t->getX() );
                     g->setY( g->getY() + t->getZielY() - t->getY() );
                 }
@@ -423,8 +442,12 @@ void Spiel::tick( double zeit )
                 {
                     for( auto u = umlenkungen.getIterator(); u; u++ )
                     {
-                        if( u->isAktive() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
+                        if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
                         {
+                            Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
+                            e->addParameter( "Betroffes Geschoss", g->getThis() );
+                            e->addParameter( "Betroffe Umlenkung", u->getThis() );
+                            throwEvent( e );
                             g->setRichtung( u->getRichtung() );
                             u->addBenutzt();
                         }
@@ -439,18 +462,22 @@ void Spiel::tick( double zeit )
                         {
                         case GESCHOSS_PFEIL:
                         case GESCHOSS_KUGEL:
-                            s->nimmSchaden( 100 + ( g->zBesitzer() ? g->zBesitzer()->getSchadenBonus() : 0 ) );
+                        {
+                            double schaden = 100 + ( g->zBesitzer() ? g->zBesitzer()->getSchadenBonus() : 0 );
+                            s->nimmSchaden( schaden );
                             if( g->zBesitzer() )
                             {
-                                g->zBesitzer()->addGemachterSchaden( 100 + g->zBesitzer()->getSchadenBonus() );
+                                g->zBesitzer()->addGemachterSchaden( schaden );
                                 if( !s->istAmLeben() )
                                     g->zBesitzer()->addKill();
                             }
+                            break;
+                        }
                         case GESCHOSS_DRACHENAUGE:
                             s->addEffekt( new DrachenAugeEffekt( g->zBesitzer(), s._, 10 ) );
                             break;
                         case GESCHOSS_FEUERBALL:
-                            feuer.add( new FeuerballTreffer( g->getX() - 70, g->getY() - 70, g->getBesitzer(), 10 ) );
+                            feuer.add( new FeuerballTreffer( ++nextId, g->getX() - 70, g->getY() - 70, g->getBesitzer(), 10 ) );
                         }
                         if( g->zBesitzer() )
                             g->zBesitzer()->addTreffer();
@@ -480,6 +507,9 @@ void Spiel::tick( double zeit )
     {
         if( !triggerRuns.z( i )->runNext( zeit ) )
         {
+            Ereignis *e = new Ereignis( AUSLOESER_RUNNED );
+            e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
+            throwEvent( e );
             triggerRuns.remove( i );
             i--;
         }
@@ -623,7 +653,44 @@ bool Spiel::istPausiert() const
     return pause;
 }
 
-// constant
+void Spiel::activateShalter( int id )
+{
+    for( auto s = schalter.getIterator(); s; s++ )
+    {
+        if( s->getId() == id )
+        {
+            Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
+            e->addParameter( "Betroffener Schalter", s->getThis() );
+            throwEvent( e );
+        }
+    }
+}
+
+void Spiel::throwEvent( Ereignis *e )
+{
+    for( auto t = trigger.getIterator(); t; t++ )
+    {
+        if( t->hatEreignis( e->getTyp() ) )
+            triggerRuns.add( t->runTrigger( e->getThis(), this ) );
+    }
+    e->release();
+}
+
+bool Spiel::needEvent( EreignisTyp typ ) const
+{
+    for( auto t = trigger.getIterator(); t; t++ )
+    {
+        if( t->hatEreignis( typ ) )
+            return 1;
+    }
+    return 0;
+}
+
+int Spiel::getNextId()
+{
+    return ++nextId;
+}
+
 StatistikV *Spiel::getStatistik() const
 {
     return stat->getThis();

StickmanWorldOnline/Spiel.h

@@ -50,6 +50,7 @@ private:
     Critical c;
     Datei *log;
     Punkt mapSize;
+    int nextId;
     bool ende;
     int spielerAnzahl;
     int spielId;
@@ -96,10 +97,23 @@ public:
     void addTrigger( Trigger *trigger );
     void addTriggerRun( TriggerRun *tRun );
     void activateShalter( int id );
-    Team *getTeam( int id ) const;
+    void throwEvent( Ereignis *e );
     Variable *getVariable( const char *name ) const;
     Variable *zVariable( const char *name ) const;
     bool istPausiert() const;
+    bool needEvent( EreignisTyp typ ) const;
+    Team *getTeam( int id ) const;
+    Spieler *getSpieler( int id ) const;
+    Bariere *getBariere( int id ) const;
+    Base *getBase( int id ) const;
+    Drop *getDrop( int id ) const;
+    Schalter *getSchalter( int id ) const;
+    Schiene *getSchiene( int id ) const;
+    Timer *getTimer( int id ) const;
+    Tunnel *getTunnel( int id ) const;
+    Umlenkung *getUmlenkung( int id ) const;
+    Trigger *getTrigger( int id ) const;
+    int getNextId();
     // constant
     StatistikV *getStatistik() const override;
     // Reference Counting 

StickmanWorldOnline/Spieler.h

@@ -103,7 +103,7 @@ public:
     // heilt auch um den lebensraub prozentsatz
     void addGemachterSchaden( double schaden );
     // zieht die rüstung ab
-    void nimmSchaden( double schaden );
+    void nimmSchaden( double &schaden );
     int getSchadenBonus() const;
     Klient *zKlient() const;
     int getSpielerNummer() const;

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -80,6 +80,9 @@
     <ClCompile Include="DllStart.cpp" />
     <ClCompile Include="Reader.cpp" />
     <ClCompile Include="Spiel.cpp" />
+    <ClCompile Include="Timer.cpp" />
+    <ClCompile Include="Tunnel.cpp" />
+    <ClCompile Include="Umlenkung.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Aktionen.h" />

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -22,12 +22,12 @@
     <Filter Include="Spiel\Auslöser">
       <UniqueIdentifier>{16af4fff-5cf1-420e-a50f-65caeff7c2a3}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Spiel\System">
-      <UniqueIdentifier>{214ae990-4b8e-4fad-a428-7f6f31c33648}</UniqueIdentifier>
-    </Filter>
     <Filter Include="Spiel\Karte">
       <UniqueIdentifier>{22733a3e-50b6-403e-9144-ec2d224435cc}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Spiel\Objekte">
+      <UniqueIdentifier>{214ae990-4b8e-4fad-a428-7f6f31c33648}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="DllStart.cpp">
@@ -39,6 +39,15 @@
     <ClCompile Include="Reader.cpp">
       <Filter>Spiel\Karte</Filter>
     </ClCompile>
+    <ClCompile Include="Umlenkung.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Tunnel.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
+    <ClCompile Include="Timer.cpp">
+      <Filter>Spiel\Objekte</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="SpielKlasse.h">
@@ -63,34 +72,34 @@
       <Filter>Spiel</Filter>
     </ClInclude>
     <ClInclude Include="Umlenkung.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Tunnel.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Timer.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Team.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Schiene.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Schalter.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="GameObject.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Gegenstand.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Base.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Bariere.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Variablen.h">
       <Filter>Spiel\Auslöser</Filter>
@@ -102,16 +111,16 @@
       <Filter>Spiel\Auslöser</Filter>
     </ClInclude>
     <ClInclude Include="Drop.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Trigger.h">
       <Filter>Spiel\Auslöser</Filter>
     </ClInclude>
     <ClInclude Include="Spieler.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Geschoss.h">
-      <Filter>Spiel\System</Filter>
+      <Filter>Spiel\Objekte</Filter>
     </ClInclude>
     <ClInclude Include="Reader.h">
       <Filter>Spiel\Karte</Filter>

StickmanWorldOnline/Timer.cpp

@@ -0,0 +1,105 @@
+#include "Timer.h"
+#include "Spiel.h"
+
+Timer::Timer( int id, const char *name, int maxZeit, int x, int y, bool visible, bool autoWiederhohlung, bool runns, int farbe )
+    : GameObject( x, y, 0, 0 )
+{
+    this->id = id;
+    this->name = name;
+    this->maxZeit = maxZeit;
+    currentTime = (float)maxZeit;
+    sichtbar = visible;
+    this->autoWiederhohlung = autoWiederhohlung;
+    this->runns = runns;
+    this->pause = 0;
+    this->farbe = farbe;
+}
+
+void Timer::start( Spiel *zSpiel, bool restart )
+{
+    if( runns && !restart )
+        return;
+    Ereignis *e = new Ereignis( TIMER_BEGINNT );
+    e->addParameter( "Betroffener Timer", this->getThis() );
+    zSpiel->throwEvent( e );
+    currentTime = (float)maxZeit;
+    runns = true;
+    pause = 0;
+}
+
+void Timer::setPause( bool pause )
+{
+    this->pause = pause;
+}
+
+void Timer::setMaxZeit( int sekunden )
+{
+    this->maxZeit = maxZeit;
+}
+
+void Timer::setAutoWiederhohlung( bool wiederhohlung )
+{
+    this->autoWiederhohlung = autoWiederhohlung;
+}
+
+void Timer::setSichtbar( bool visible )
+{
+    this->sichtbar = sichtbar;
+}
+
+void Timer::setFarbe( int farbe )
+{
+    this->farbe = farbe;
+}
+
+void Timer::tick( double time, Spiel *zSpiel )
+{
+    if( runns && !pause )
+    {
+        currentTime -= (float)time;
+        if( currentTime <= 0 )
+        {
+            Ereignis *e = new Ereignis( TIMER_RUNNS_OUT );
+            e->addParameter( "Betroffener Timer", this->getThis() );
+            zSpiel->throwEvent( e );
+            runns = 0;
+            if( autoWiederhohlung )
+                start( zSpiel );
+        }
+    }
+}
+
+float Timer::getTimeLeft() const
+{
+    return currentTime;
+}
+
+bool Timer::istSichtbar() const
+{
+    return sichtbar;
+}
+
+int Timer::getFarbe() const
+{
+    return farbe;
+}
+
+bool Timer::isRunning() const
+{
+    return runns;
+}
+
+bool Timer::istPausiert() const
+{
+    return pause;
+}
+
+int Timer::getMaxTime() const
+{
+    return maxZeit;
+}
+
+bool Timer::istAutoWiederhohlung() const
+{
+    return autoWiederhohlung;
+}

StickmanWorldOnline/Timer.h

@@ -7,7 +7,6 @@ class Spiel;
 class Timer : public GameObject
 {
 private:
-    static int nextId;
     int id;
     Text name;
     bool runns;
@@ -19,14 +18,15 @@ private:
     bool sichtbar;
 
 public:
-    Timer( const char *name, int maxZeit, int x, int y, bool visible = 1, bool autoWiederhohlung = 0, bool runns = 0, int farbe = 0xFFFFFFFF );
-    void start( bool restart = 0 );
+    Timer( int id, const char *name, int maxZeit, int x, int y, bool visible = 1, bool autoWiederhohlung = 0, bool runns = 0, int farbe = 0xFFFFFFFF );
+    void start( Spiel *zSpiel, bool restart = 0 );
     void setPause( bool pause );
     void setMaxZeit( int sekunden );
     void setAutoWiederhohlung( bool wiederhohlung );
     void setSichtbar( bool visible );
     void setFarbe( int farbe );
     void tick( double time, Spiel *zSpiel );
+    float getTimeLeft() const;
     bool istSichtbar() const;
     int getFarbe() const;
     bool isRunning() const;

StickmanWorldOnline/Trigger.h

@@ -57,6 +57,7 @@ private:
 public:
     Trigger( const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen );
     ~Trigger();
+    bool hatEreignis( EreignisTyp typ ) const;
     int getAktionAnzahl() const;
     Aktion *zAktion( int index ) const;
     Aktion *getAktion( int index ) const;
@@ -81,6 +82,7 @@ public:
     ~TriggerRun();
     // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
     bool runNext( double t );
+    Trigger *getTrigger() const;
     TriggerRun *getThis();
     TriggerRun *release();
 };

StickmanWorldOnline/Tunnel.cpp

@@ -0,0 +1,52 @@
+#include "Tunnel.h"
+
+
+Tunnel::Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv )
+    : GameObject( x, y, width, height )
+{
+    this->id = id;
+    this->aktiv = aktiv;
+    benutzt = 0;
+    this->zielX = zielX;
+    this->zielY = zielY;
+}
+
+void Tunnel::setZielX( int x )
+{
+    zielX = x;
+}
+
+int Tunnel::setZielY( int y )
+{
+    zielY = y;
+}
+
+void Tunnel::addBenutzung()
+{
+    benutzt++;
+}
+
+void Tunnel::setAktiv( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+int Tunnel::getZielX() const
+{
+    return zielX;
+}
+
+int Tunnel::getZielY() const
+{
+    return zielY;
+}
+
+bool Tunnel::istAktiv() const
+{
+    return aktiv;
+}
+
+int Tunnel::getBenutzungen() const
+{
+    return benutzt;
+}

StickmanWorldOnline/Tunnel.h

@@ -5,7 +5,6 @@
 class Tunnel : public GameObject
 {
 private:
-    static int nextId;
     int id;
     bool aktiv;
     int benutzt;
@@ -13,7 +12,7 @@ private:
     int zielY;
 
 public:
-    Tunnel( int x, int y, int width, int height, int zielX, int zielY, bool aktiv );
+    Tunnel( int id, int x, int y, int width, int height, int zielX, int zielY, bool aktiv );
     void setZielX( int x );
     int setZielY( int y );
     void addBenutzung();
@@ -21,4 +20,5 @@ public:
     int getZielX() const;
     int getZielY() const;
     bool istAktiv() const;
+    int getBenutzungen() const;
 };

StickmanWorldOnline/Umlenkung.cpp

@@ -0,0 +1,92 @@
+#include "Umlenkung.h"
+
+
+Umlenkung::Umlenkung( int id, int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv )
+    : GameObject( x, y, breite, height )
+{
+    this->id = id;
+    this->richtung = richtung;
+    this->maxAbklingzeit = maxAbklingzeit;
+    this->drehend = drehend;
+    this->aktiv = aktiv;
+    benutzt = 0;
+    abklingzeitVerbleibend = 0;
+}
+
+void Umlenkung::setMaxAbklingzeit( int sekunden )
+{
+    this->maxAbklingzeit = sekunden;
+}
+
+void Umlenkung::setAktiv( bool aktiv )
+{
+    this->aktiv = aktiv;
+}
+
+void Umlenkung::setDrehend( bool drehend )
+{
+    this->drehend = drehend;
+}
+
+void Umlenkung::setRichtung( Richtung r )
+{
+    this->richtung = r;
+}
+
+void Umlenkung::addBenutzt()
+{
+    benutzt++;
+    if( drehend )
+    {
+        switch( richtung )
+        {
+        case OBEN:
+            richtung = RECHTS;
+            break;
+        case RECHTS:
+            richtung = UNTEN;
+            break;
+        case UNTEN:
+            richtung = LINKS;
+            break;
+        case LINKS:
+            richtung = OBEN;
+        }
+    }
+    abklingzeitVerbleibend = maxAbklingzeit;
+}
+
+void Umlenkung::tick( double time )
+{
+    if( abklingzeitVerbleibend > 0 )
+    {
+        abklingzeitVerbleibend -= time;
+        if( abklingzeitVerbleibend < 0 )
+            abklingzeitVerbleibend = 0;
+    }
+}
+
+bool Umlenkung::isAktive() const
+{
+    return aktiv;
+}
+
+bool Umlenkung::hatAbklingzeit() const
+{
+    return abklingzeitVerbleibend > 0;
+}
+
+bool Umlenkung::istDrehend() const
+{
+    return drehend;
+}
+
+int Umlenkung::getMaxAbklingzeit() const
+{
+    return maxAbklingzeit;
+}
+
+Richtung Umlenkung::getRichtung() const
+{
+    return richtung;
+}

StickmanWorldOnline/Umlenkung.h

@@ -5,7 +5,6 @@
 class Umlenkung : public GameObject
 {
 private:
-    static int nextId;
     int id;
     Richtung richtung;
     bool drehend;
@@ -15,7 +14,7 @@ private:
     float abklingzeitVerbleibend;
 
 public:
-    Umlenkung( int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv );
+    Umlenkung( int id, int x, int y, int breite, int height, Richtung richtung, int maxAbklingzeit, bool drehend, bool aktiv );
     void setMaxAbklingzeit( int sekunden );
     void setAktiv( bool aktiv );
     void setDrehend( bool drehend );

StickmanWorldOnline/Variablen.h

@@ -35,7 +35,7 @@ private:
 public:
     Variable( VariableTyp typ );
     virtual ~Variable();
-    VariableTyp getTyp() const;
+    VariableTyp getVariableTyp() const;
     Variable *getThis();
     Variable *release();
 };
@@ -46,7 +46,7 @@ private:
     int value;
 
 public:
-    Integer( bool taste = 0 );
+    Integer( int value, bool taste = 0 );
     void setValue( int value );
     int getValue() const;
 };
@@ -57,7 +57,7 @@ private:
     bool value;
 
 public:
-    Boolean();
+    Boolean( bool value );
     void setValue( bool value );
     bool getValue() const;
 };
@@ -68,7 +68,7 @@ private:
     Text value;
 
 public:
-    String( bool richtung = 0 );
+    String( const char *value, bool richtung = 0 );
     void setValue( Text value );
     const Text &getValue() const;
 };
@@ -79,7 +79,7 @@ private:
     float value;
 
 public:
-    Float();
+    Float( float value );
     void setValue( float value );
     float getValue() const;
 };