Kartenleser fertig

StickmanWorldOnline/Aktionen.h

@@ -2,18 +2,234 @@
 
 #include "Variablen.h"
 
-class Memory;
+class Spiel;
 class Ereignis;
 
+enum AktionTyp
+{
+    BARIERE_BEWEGUNG,
+    BARIERE_SET_EINGESCHALTET,
+    BARIERE_SET_POSITION,
+    BARIERE_SET_TEAM,
+    BARIERE_ZUFALL,
+    BARIERE_ZULETZT_AUSGESCHALTET,
+    BARIERE_ZULETZT_BEWEGT,
+    BARIERE_ZULETZT_EINGESCHALTET,
+    BASE_SET_POSITION,
+    BASE_SET_TEAM,
+    BASE_ZUFALL,
+    BASE_ZULETZT_BESITZER_GEWECHSELT,
+    BOOLEAN_AUS_TEXT,
+    BOOLEAN_BARIERE_BEWEGT_SICH,
+    BOOLEAN_BARIERE_IST_AKTIV,
+    BOOLEAN_BARIERE_IST_SCHALTEND,
+    BOOLEAN_BASE_IST_NEUTRAL,
+    BOOLEAN_GLEICH,
+    BOOLEAN_NICHT,
+    BOOLEAN_ODER,
+    BOOLEAN_SCHALTER_IST_AKTIV,
+    BOOLEAN_SPIELER_AM_LEBEN,
+    BOOLEAN_SPIELER_HAT_GEGENSTAND,
+    BOOLEAN_SPIELER_IN_TEAM,
+    BOOLEAN_SPIELER_IST_VERWUNDBAR,
+    BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN,
+    BOOLEAN_SPIEL_PAUSIERT,
+    BOOLEAN_TIMER_IS_RUNNING,
+    BOOLEAN_TIMER_IST_SICHTBAR,
+    BOOLEAN_TRIGGER_IST_AKTIV,
+    BOOLEAN_TUNNEL_IST_AKTIV,
+    BOOLEAN_UMLENKUNG_HAT_ABK,
+    BOOLEAN_UMLENKUNG_IST_DREHEND,
+    BOOLEAN_UND,
+    BOOLEAN_ZUFALL,
+    DISPLAY_TEXT,
+    DROP_DO_DROP,
+    DROP_SET_AREA,
+    DROP_SET_MAX_TIME,
+    DROP_SET_TIME,
+    DROP_ZUFALL,
+    DROP_ZULETZT_GEDROPT,
+    GESCHOSS_NEU,
+    GESCHOSS_SET_PLAYER,
+    GESCHOSS_SET_POSITION,
+    GESCHOSS_SET_RICHTUNG,
+    GESCHOSS_SET_SPEED,
+    GESCHOSS_SET_TYPE,
+    GESCHOSS_ZUFALL,
+    GESCHOSS_ZULETZT_ABGEFEUERT,
+    GESCHOSS_ZULETZT_BARIERE_GETROFFEN,
+    GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN,
+    GESCHOSS_ZULETZT_TUNNEL_BENUTZT,
+    GESCHOSS_ZULETZT_UMGELENKT,
+    INTEGER_AUS_TEXT,
+    INTEGER_BARIERE_BREITE,
+    INTEGER_BARIERE_HEIGHT,
+    INTEGER_BARIERE_SCHALTUNGEN,
+    INTEGER_BARIERE_VERSCHIEBUNGEN,
+    INTEGER_DROP_MAX_ZEIT,
+    INTEGER_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,
+    INTEGER_SPIELER_GESCHOSSEN,
+    INTEGER_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,
+    INTEGER_SPIELER_LEVEL,
+    INTEGER_SPIELER_MAX_ERFAHRUNG,
+    INTEGER_SPIELER_MAX_LEBEN,
+    INTEGER_SPIELER_SCHADEN,
+    INTEGER_SPIELER_SCHADEN_BONUS,
+    INTEGER_SPIELER_SCHALTER_AKTIVIERT,
+    INTEGER_SPIELER_TEMPO,
+    INTEGER_SPIELER_TODE,
+    INTEGER_SPIELER_TREFFER,
+    INTEGER_SPIELER_TUNNEL_BENUTZT,
+    INTEGER_TEAM_KILLS,
+    INTEGER_TEAM_PUNKTE,
+    INTEGER_TEAM_SPIELERANZAHL,
+    INTEGER_TEAM_TODE,
+    INTEGER_TEAM_WIEDERBELEBUNGSZEIT,
+    INTEGER_TIMER_AKTUELLE_ZEIT,
+    INTEGER_TIMER_MAX_ZEIT,
+    INTEGER_TRIGGER_RUNNS,
+    INTEGER_TUNNEL_BENUTZUNGEN,
+    INTEGER_UMLENKUNG_BENUTZUNGEN,
+    INTEGER_X_VON_BARIERE,
+    INTEGER_X_VON_BASE,
+    INTEGER_X_VON_GESCHOSS,
+    INTEGER_X_VON_SCHALTER,
+    INTEGER_X_VON_SPIELER,
+    INTEGER_X_VON_TIMER,
+    INTEGER_X_VON_TUNNEL,
+    INTEGER_X_VON_TUNNEL_ZIEL,
+    INTEGER_X_VON_UMLENKUNG,
+    INTEGER_Y_VON_BARIERE,
+    INTEGER_Y_VON_BASE,
+    INTEGER_Y_VON_GESCHOSS,
+    INTEGER_Y_VON_SCHALTER,
+    INTEGER_Y_VON_SPIELER,
+    INTEGER_Y_VON_TIMER,
+    INTEGER_Y_VON_TUNNEL,
+    INTEGER_Y_VON_TUNNEL_ZIEL,
+    INTEGER_Y_VON_UMLENKUNG,
+    INTEGER_ZUFALL,
+    ITEM_SPIELER_INVENTAR,
+    ITEM_ZULETZT_AUFGEHOBEN,
+    ITEM_ZULETZT_GEDROPT,
+    KONSTANT_BOOLEAN,
+    KONSTANT_FLOAT,
+    KONSTANT_INTEGER,
+    KONSTANT_NICHTS,
+    KONSTANT_STRING,
+    KONSTANT_VARIABLE,
+    RICHTUNG_VON_GESCHOSS,
+    RICHTUNG_VON_UMLENKUNG,
+    RICHTUNG_ZUFALL,
+    SCHALTER_AKTIVIEREN,
+    SCHALTER_SET_ERLAUBT,
+    SCHALTER_SET_POSITION,
+    SCHALTER_ZUFALL,
+    SCHALTER_ZULETZT_AKTIVIERT,
+    SET_VARIABLE,
+    SPIEL_ENDE,
+    SPIELER_GIVE_ITEM,
+    SPIELER_NACHRICHT,
+    SPIELER_REMOVE_ITEM,
+    SPIELER_SET_ABKLINGZEITVERRINGERUNG,
+    SPIELER_SET_ARMOR,
+    SPIELER_SET_ERFAHRUNG,
+    SPIELER_SET_LEBEN,
+    SPIELER_SET_LEBENSRAUB,
+    SPIELER_SET_LEBENSREGENERATION,
+    SPIELER_SET_LEVEL,
+    SPIELER_SET_MAX_ERFAHRUNG,
+    SPIELER_SET_POSITION,
+    SPIELER_SET_SCHADEN_BONUS,
+    SPIELER_SET_TEMPO,
+    SPIELER_SET_GESCHOSS_TEMPO,
+    SPIELER_ZUFALL,
+    SPIELER_ZUFALL_AUS_TEAM,
+    SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN,
+    SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT,
+    SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN,
+    SPIELER_ZULETZT_GEHEILT,
+    SPIELER_ZULETZT_GESCHOSSEN,
+    SPIELER_ZULETZT_GESTORBEN,
+    SPIELER_ZULETZT_LEVEL_UP,
+    SPIELER_ZULETZT_SCHADEN_GEMACHT,
+    SPIELER_ZULETZT_SCHADEN_GENOMMEN,
+    SPIELER_ZULETZT_SCHALTER_AKTIVIERT,
+    SPIELER_ZULETZT_TUNNEL_BENUTZT,
+    SPIELER_ZULETZT_WIEDERBELEBT,
+    SPIEL_PAUSE,
+    TEAM_SET_PUNKTE,
+    TEAM_VON_BARIERE,
+    TEAM_VON_SPIELER,
+    TEAM_ZUFALL,
+    TEXT_AUS_BOOLEAN,
+    TEXT_AUS_RICHTUNG,
+    TEXT_AUS_ZAHL,
+    TEXT_CONCAT,
+    TEXT_ITEM_NAME,
+    TEXT_SPIELER_NAME,
+    TEXT_TEIL_VON_TEXT,
+    TEXT_TRIGGER_NAME,
+    TIMER_SET_PAUSE,
+    TIMER_SET_POSITION,
+    TIMER_SET_SICHTBAR,
+    TIMER_SET_ZEIT,
+    TIMER_START,
+    TIMER_ZUFALL,
+    TIMER_ZULETZT_ABGELAUFEN,
+    TIMER_ZULETZT_FOTOGRAFIERT,
+    TIMER_ZULETZT_GESTARTET,
+    TIMER_ZULETZT_PAUSIERT,
+    TRIGGER_AKTION,
+    TRIGGER_LAST_RUNNED,
+    TRIGGER_RUN_START,
+    TRIGGER_SET_ENABLED,
+    TRIGGER_ZUFALL,
+    TUNNEL_SET_ERLAUBT,
+    TUNNEL_SET_POSITION,
+    TUNNEL_SET_ZIEL_POSITION,
+    TUNNEL_ZUFALL,
+    TUNNEL_ZULETZT_BENUTZT,
+    UMLENKUNG_SET_ERLAUBT,
+    UMLENKUNG_SET_MAX_ABK,
+    UMLENKUNG_SET_POSITION,
+    UMLENKUNG_SET_RICHTUNG,
+    UMLENKUNG_ZUFALL,
+    UMLENKUNG_ZULETZT_BENUTZT,
+    WARTEN,
+    WENN_DANN_SONST
+};
+
 class Aktion
 {
 private:
+    AktionTyp typ;
     int ref;
 
 public:
-    Aktion();
+    Aktion( AktionTyp typ );
     virtual ~Aktion();
-    virtual Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) = 0;
+    virtual Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) = 0;
     Aktion *getThis();
     Aktion *release();
 };
@@ -22,7 +238,7 @@ class KonstantNichts : public Aktion
 {
 public:
     KonstantNichts();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
 class KonstantInteger : public Aktion
@@ -32,7 +248,7 @@ private:
 
 public:
     KonstantInteger( int val );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
 class KonstantBoolean : public Aktion
@@ -42,7 +258,7 @@ private:
 
 public:
     KonstantBoolean( bool val );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
 class KonstantString : public Aktion
@@ -52,7 +268,7 @@ private:
 
 public:
     KonstantString( Text val );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
 class KonstantFloat : public Aktion
@@ -62,7 +278,7 @@ private:
 
 public:
     KonstantFloat( float val );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
 class KonstantVariable : public Aktion
@@ -72,20 +288,20 @@ private:
 
 public:
     KonstantVariable( Text name );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class Warten : Aktion
+class Warten : public Aktion
 {
 private:
     Aktion *seconds;
 
 public:
     Warten( Aktion *seconds );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SetVariable : Aktion
+class SetVariable : public Aktion
 {
 private:
     Text name;
@@ -93,10 +309,10 @@ private:
 
 public:
     SetVariable( Text name, Aktion *value );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class WennDannSonst : Aktion
+class WennDannSonst : public Aktion
 {
 private:
     Aktion *condition;
@@ -105,10 +321,10 @@ private:
 
 public:
     WennDannSonst( Aktion *condition, Aktion *wahr, Aktion *falsch );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TriggerAktion : Aktion
+class TriggerAktion : public Aktion
 {
 private:
     Aktion *number;
@@ -116,10 +332,10 @@ private:
 
 public:
     TriggerAktion( Aktion *number, Aktion *triggerName );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerNachricht : Aktion
+class SpielerNachricht : public Aktion
 {
 private:
     Aktion *spieler;
@@ -127,10 +343,10 @@ private:
 
 public:
     SpielerNachricht( Aktion *spieler, Aktion *nachricht );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DisplayText : Aktion
+class DisplayText : public Aktion
 {
 private:
     Aktion *x;
@@ -141,30 +357,30 @@ private:
 
 public:
     DisplayText( Aktion *x, Aktion *y, Aktion *f, Aktion *dauer, Aktion *nachricht );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielPause : Aktion
+class SpielPause : public Aktion
 {
 private:
     Aktion *paused;
 
 public:
     SpielPause( Aktion *paused );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielEnde : Aktion
+class SpielEnde : public Aktion
 {
 private:
     Aktion *gewinnerTeam;
 
 public:
     SpielEnde( Aktion *gewinnerTeam );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetLevel : Aktion
+class SpielerSetLevel : public Aktion
 {
 private:
     Aktion *level;
@@ -172,10 +388,10 @@ private:
 
 public:
     SpielerSetLevel( Aktion *level, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerGiveItem : Aktion
+class SpielerGiveItem : public Aktion
 {
 private:
     Aktion *item;
@@ -184,10 +400,10 @@ private:
 
 public:
     SpielerGiveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerRemoveItem : Aktion
+class SpielerRemoveItem : public Aktion
 {
 private:
     Aktion *item;
@@ -196,10 +412,10 @@ private:
 
 public:
     SpielerRemoveItem( Aktion *item, Aktion *anzahl, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetPosition : Aktion
+class SpielerSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -208,10 +424,10 @@ private:
 
 public:
     SpielerSetPosition( Aktion *x, Aktion *y, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetLeben : Aktion
+class SpielerSetLeben : public Aktion
 {
 private:
     Aktion *leben;
@@ -219,10 +435,10 @@ private:
 
 public:
     SpielerSetLeben( Aktion *leben, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetMaxLeben : Aktion
+class SpielerSetMaxLeben : public Aktion
 {
 private:
     Aktion *leben;
@@ -230,10 +446,10 @@ private:
 
 public:
     SpielerSetMaxLeben( Aktion *leben, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetErfahrung : Aktion
+class SpielerSetErfahrung : public Aktion
 {
 private:
     Aktion *erfahrung;
@@ -241,10 +457,10 @@ private:
 
 public:
     SpielerSetErfahrung( Aktion *erfahrung, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetMaxErfahrung : Aktion
+class SpielerSetMaxErfahrung : public Aktion
 {
 private:
     Aktion *erfahrung;
@@ -252,10 +468,10 @@ private:
 
 public:
     SpielerSetMaxErfahrung( Aktion *erfahrung, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetTempo : Aktion
+class SpielerSetTempo : public Aktion
 {
 private:
     Aktion *tempo;
@@ -263,10 +479,10 @@ private:
 
 public:
     SpielerSetTempo( Aktion *tempo, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetWaffenTempo : Aktion
+class SpielerSetWaffenTempo : public Aktion
 {
 private:
     Aktion *tempo;
@@ -274,10 +490,10 @@ private:
 
 public:
     SpielerSetWaffenTempo( Aktion *tempo, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetArmor : Aktion
+class SpielerSetArmor : public Aktion
 {
 private:
     Aktion *armor;
@@ -285,10 +501,10 @@ private:
 
 public:
     SpielerSetArmor( Aktion *armor, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetSchadenBonus : Aktion
+class SpielerSetSchadenBonus : public Aktion
 {
 private:
     Aktion *bonus;
@@ -296,10 +512,10 @@ private:
 
 public:
     SpielerSetSchadenBonus( Aktion *bonus, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetLebensraub : Aktion
+class SpielerSetLebensraub : public Aktion
 {
 private:
     Aktion *lebensraub;
@@ -307,10 +523,10 @@ private:
 
 public:
     SpielerSetLebensraub( Aktion *lebensraub, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetLebensregeneration : Aktion
+class SpielerSetLebensregeneration : public Aktion
 {
 private:
     Aktion *regeneration;
@@ -318,10 +534,10 @@ private:
 
 public:
     SpielerSetLebensregeneration( Aktion *regeneration, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerSetAbklingzeitverringerung : Aktion
+class SpielerSetAbklingzeitverringerung : public Aktion
 {
 private:
     Aktion *verringerung;
@@ -329,10 +545,10 @@ private:
 
 public:
     SpielerSetAbklingzeitverringerung( Aktion *verringerung, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropSetTime : Aktion
+class DropSetTime : public Aktion
 {
 private:
     Aktion *time;
@@ -340,10 +556,10 @@ private:
 
 public:
     DropSetTime( Aktion *time, Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropSetMaxTime : Aktion
+class DropSetMaxTime : public Aktion
 {
 private:
     Aktion *time;
@@ -351,10 +567,10 @@ private:
 
 public:
     DropSetMaxTime( Aktion *time, Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropSetArea : Aktion
+class DropSetArea : public Aktion
 {
 private:
     Aktion *minX;
@@ -365,42 +581,30 @@ private:
 
 public:
     DropSetArea( Aktion *minX, Aktion *maxX, Aktion *minY, Aktion *maxY, Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropDoDrop : Aktion
+class DropDoDrop : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     DropDoDrop( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereBewegung : Aktion
+class BariereBewegung : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     BariereBewegung( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereIndividualBewegung : Aktion
-{
-private:
-    Aktion *x;
-    Aktion *y;
-    Aktion *bariere;
-
-public:
-    BariereIndividualBewegung( Aktion *x, Aktion *y, Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
-};
-
-class BariereSetEingeschaltet : Aktion
+class BariereSetEingeschaltet : public Aktion
 {
 private:
     Aktion *eingeschaltet;
@@ -408,10 +612,10 @@ private:
 
 public:
     BariereSetEingeschaltet( Aktion *eingeschaltet, Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereSetPosition : Aktion
+class BariereSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -420,10 +624,10 @@ private:
 
 public:
     BariereSetPosition( Aktion *x, Aktion *y, Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereSetTeam : Aktion
+class BariereSetTeam : public Aktion
 {
 private:
     Aktion *team;
@@ -431,10 +635,10 @@ private:
 
 public:
     BariereSetTeam( Aktion *team, Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SchalterSetPosition : Aktion
+class SchalterSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -443,10 +647,10 @@ private:
 
 public:
     SchalterSetPosition( Aktion *x, Aktion *y, Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SchalterSetErlaubt : Aktion
+class SchalterSetErlaubt : public Aktion
 {
 private:
     Aktion *erlaubt;
@@ -454,20 +658,20 @@ private:
 
 public:
     SchalterSetErlaubt( Aktion *erlaubt, Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SchalterAktivieren : Aktion
+class SchalterAktivieren : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
     SchalterAktivieren( Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TunnelSetPosition : Aktion
+class TunnelSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -476,10 +680,10 @@ private:
 
 public:
     TunnelSetPosition( Aktion *x, Aktion *y, Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TunnelSetZielPosition : Aktion
+class TunnelSetZielPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -488,10 +692,10 @@ private:
 
 public:
     TunnelSetZielPosition( Aktion *x, Aktion *y, Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TunnelSetErlaubt : Aktion
+class TunnelSetErlaubt : public Aktion
 {
 private:
     Aktion *erlaubt;
@@ -499,10 +703,10 @@ private:
 
 public:
     TunnelSetErlaubt( Aktion *erlaubt, Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungSetPosition : Aktion
+class UmlenkungSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -511,10 +715,10 @@ private:
 
 public:
     UmlenkungSetPosition( Aktion *x, Aktion *y, Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungSetRichtung : Aktion
+class UmlenkungSetRichtung : public Aktion
 {
 private:
     Aktion *richtung;
@@ -522,10 +726,10 @@ private:
 
 public:
     UmlenkungSetRichtung( Aktion *richtung, Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungSetMaxAbk : Aktion
+class UmlenkungSetMaxAbk : public Aktion
 {
 private:
     Aktion *abk;
@@ -533,10 +737,10 @@ private:
 
 public:
     UmlenkungSetMaxAbk( Aktion *abk, Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungSetEnabled : Aktion
+class UmlenkungSetEnabled : public Aktion
 {
 private:
     Aktion *enabled;
@@ -544,10 +748,10 @@ private:
 
 public:
     UmlenkungSetEnabled( Aktion *enabled, Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BaseSetPosition : Aktion
+class BaseSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -556,10 +760,10 @@ private:
 
 public:
     BaseSetPosition( Aktion *x, Aktion *y, Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BaseSetTeam : Aktion
+class BaseSetTeam : public Aktion
 {
 private:
     Aktion *team;
@@ -567,31 +771,31 @@ private:
 
 public:
     BaseSetTeam( Aktion *team, Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class AuslöserRun : Aktion
+class TriggerRunStart : public Aktion
 {
 private:
-    Aktion *auslöser;
+    Aktion *trigger;
 
 public:
-    AuslöserRun( Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    TriggerRunStart( Aktion *base );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class AuslöserSetEnabled : Aktion
+class TriggerSetEnabled : public Aktion
 {
 private:
     Aktion *enabled;
-    Aktion *auslöser;
+    Aktion *trigger;
 
 public:
-    AuslöserSetEnabled( Aktion *enabled, Aktion *auslöser );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    TriggerSetEnabled( Aktion *enabled, Aktion *trigger );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TeamSetPunkte : Aktion
+class TeamSetPunkte : public Aktion
 {
 private:
     Aktion *punkte;
@@ -599,10 +803,10 @@ private:
 
 public:
     TeamSetPunkte( Aktion *punkte, Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerSetPosition : Aktion
+class TimerSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -611,10 +815,10 @@ private:
 
 public:
     TimerSetPosition( Aktion *x, Aktion *y, Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerSetPause : Aktion
+class TimerSetPause : public Aktion
 {
 private:
     Aktion *pause;
@@ -622,20 +826,20 @@ private:
 
 public:
     TimerSetPause( Aktion *pause, Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerStart : Aktion
+class TimerStart : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     TimerStart( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerSetZeit : Aktion
+class TimerSetZeit : public Aktion
 {
 private:
     Aktion *zeit;
@@ -643,10 +847,10 @@ private:
 
 public:
     TimerSetZeit( Aktion *zeit, Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerSetSichtbar : Aktion
+class TimerSetSichtbar : public Aktion
 {
 private:
     Aktion *sichtbar;
@@ -654,10 +858,10 @@ private:
 
 public:
     TimerSetSichtbar( Aktion *sichtbar, Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossNeu : Aktion
+class GeschossNeu : public Aktion
 {
 private:
     Aktion *x;
@@ -667,10 +871,10 @@ private:
 
 public:
     GeschossNeu( Aktion *x, Aktion *y, Aktion *typ, Aktion *richtung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossSetPosition : Aktion
+class GeschossSetPosition : public Aktion
 {
 private:
     Aktion *x;
@@ -679,10 +883,10 @@ private:
 
 public:
     GeschossSetPosition( Aktion *x, Aktion *y, Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossSetSpeed : Aktion
+class GeschossSetSpeed : public Aktion
 {
 private:
     Aktion *speed;
@@ -690,10 +894,10 @@ private:
 
 public:
     GeschossSetSpeed( Aktion *speed, Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossSetPlayer : Aktion
+class GeschossSetPlayer : public Aktion
 {
 private:
     Aktion *player;
@@ -701,10 +905,10 @@ private:
 
 public:
     GeschossSetPlayer( Aktion *player, Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossSetRichtung : Aktion
+class GeschossSetRichtung : public Aktion
 {
 private:
     Aktion *richtung;
@@ -712,10 +916,10 @@ private:
 
 public:
     GeschossSetRichtung( Aktion *richtung, Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossSetType : Aktion
+class GeschossSetType : public Aktion
 {
 private:
     Aktion *type;
@@ -723,80 +927,80 @@ private:
 
 public:
     GeschossSetType( Aktion *type, Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TriggerZufall : Aktion
+class TriggerZufall : public Aktion
 {
 public:
     TriggerZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TriggerLastRunned : Aktion
+class TriggerLastRunned : public Aktion
 {
 public:
     TriggerLastRunned();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereZufall : Aktion
+class BariereZufall : public Aktion
 {
 public:
     BariereZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereZuletztEingeschaltet : Aktion
+class BariereZuletztEingeschaltet : public Aktion
 {
 public:
     BariereZuletztEingeschaltet();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereZuletztAusgeschaltet : Aktion
+class BariereZuletztAusgeschaltet : public Aktion
 {
 public:
     BariereZuletztAusgeschaltet();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BariereZuletztBewegt : Aktion
+class BariereZuletztBewegt : public Aktion
 {
 public:
     BariereZuletztBewegt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BaseZufall : Aktion
+class BaseZufall : public Aktion
 {
 public:
     BaseZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BaseZuletztBesitzerGewechselt : Aktion
+class BaseZuletztBesitzerGewechselt : public Aktion
 {
 public:
     BaseZuletztBesitzerGewechselt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropZufall : Aktion
+class DropZufall : public Aktion
 {
 public:
     DropZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class DropZuletztGedropt : Aktion
+class DropZuletztGedropt : public Aktion
 {
 public:
     DropZuletztGedropt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerRechnen : Aktion
+class IntegerRechnen : public Aktion
 {
 private:
     Aktion *left;
@@ -805,10 +1009,10 @@ private:
 
 public:
     IntegerRechnen( Aktion *left, Aktion *right, char op );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerZufall : Aktion
+class IntegerZufall : public Aktion
 {
 private:
     Aktion *min;
@@ -816,470 +1020,460 @@ private:
 
 public:
     IntegerZufall( Aktion *min, Aktion *max );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerAusText : Aktion
+class IntegerAusText : public Aktion
 {
 private:
     Aktion *text;
 
 public:
     IntegerAusText( Aktion *text );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonSpieler : Aktion
+class IntegerXVonSpieler : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerXVonSpieler( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonSpieler : Aktion
+class IntegerYVonSpieler : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerYVonSpieler( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonBariere : Aktion
+class IntegerXVonBariere : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     IntegerXVonBariere( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonBariere : Aktion
+class IntegerYVonBariere : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     IntegerYVonBariere( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonSchalter : Aktion
+class IntegerXVonSchalter : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
     IntegerXVonSchalter( Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonSchalter : Aktion
+class IntegerYVonSchalter : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
     IntegerYVonSchalter( Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonTunnel : Aktion
+class IntegerXVonTunnel : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     IntegerXVonTunnel( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonTunnel : Aktion
+class IntegerYVonTunnel : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     IntegerYVonTunnel( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonTunnelZiel : Aktion
+class IntegerXVonTunnelZiel : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     IntegerXVonTunnelZiel( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonTunnelZiel : Aktion
+class IntegerYVonTunnelZiel : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     IntegerYVonTunnelZiel( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonUmlenkung : Aktion
+class IntegerXVonUmlenkung : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     IntegerXVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonUmlenkung : Aktion
+class IntegerYVonUmlenkung : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     IntegerYVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerMinXVonDrop : Aktion
+class IntegerMinXVonDrop : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerMinXVonDrop( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerMinYVonDrop : Aktion
+class IntegerMinYVonDrop : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerMinYVonDrop( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerMaxXVonDrop : Aktion
+class IntegerMaxXVonDrop : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerMaxXVonDrop( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerMaxYVonDrop : Aktion
+class IntegerMaxYVonDrop : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerMaxYVonDrop( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonBase : Aktion
+class IntegerXVonBase : public Aktion
 {
 private:
     Aktion *base;
 
 public:
     IntegerXVonBase( Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonBase : Aktion
+class IntegerYVonBase : public Aktion
 {
 private:
     Aktion *base;
 
 public:
     IntegerYVonBase( Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonTimer : Aktion
+class IntegerXVonTimer : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     IntegerXVonTimer( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonTimer : Aktion
+class IntegerYVonTimer : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     IntegerYVonTimer( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerXVonGeschoss : Aktion
+class IntegerXVonGeschoss : public Aktion
 {
 private:
     Aktion *geschoss;
 
 public:
     IntegerXVonGeschoss( Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerYVonGeschoss : Aktion
+class IntegerYVonGeschoss : public Aktion
 {
 private:
     Aktion *geschoss;
 
 public:
     IntegerYVonGeschoss( Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerLevel : Aktion
+class IntegerSpielerLevel : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerLevel( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerLeben : Aktion
+class IntegerSpielerLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerLeben( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerMaxLeben : Aktion
+class IntegerSpielerMaxLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerMaxLeben( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerErfahrung : Aktion
+class IntegerSpielerErfahrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerErfahrung( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerMaxErfahrung : Aktion
+class IntegerSpielerMaxErfahrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerMaxErfahrung( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerTempo : Aktion
+class IntegerSpielerTempo : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerTempo( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGeschossTempo : Aktion
+class IntegerSpielerGeschossTempo : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerGeschossTempo( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerRüstung : Aktion
+class IntegerSpielerArmor : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerRüstung( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerArmor( Aktion *spieler );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerSchadenBonus : Aktion
+class IntegerSpielerSchadenBonus : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerSchadenBonus( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerLebensraub : Aktion
+class IntegerSpielerLebensraub : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerLebensraub( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerLebensregeneration : Aktion
+class IntegerSpielerLebensregeneration : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerLebensregeneration( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerAbklingzeitverringerrung : Aktion
+class IntegerSpielerAbklingzeitverringerrung : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerAbklingzeitverringerrung( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerTode : Aktion
+class IntegerSpielerTode : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerTode( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerKills : Aktion
+class IntegerSpielerKills : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerKills( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerTreffer : Aktion
+class IntegerSpielerTreffer : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerTreffer( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGetroffen : Aktion
+class IntegerSpielerGetroffen : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerGetroffen( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerErlittenerSchaden : Aktion
+class IntegerSpielerErlittenerSchaden : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerErlittenerSchaden( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerSchaden : Aktion
+class IntegerSpielerSchaden : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerSchaden( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGeheiltesLeben : Aktion
+class IntegerSpielerGeheiltesLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerGeheiltesLeben( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
-};
-
-class IntegerSpielerErfahrung : Aktion
-{
-private:
-    Aktion *spieler;
-
-public:
-    IntegerSpielerErfahrung( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGegenständeAufgehoben : Aktion
+class IntegerSpielerItemsAufgehoben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerGegenständeAufgehoben( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerItemsAufgehoben( Aktion *spieler );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGegenständeVerwendet : Aktion
+class IntegerSpielerItemsVerwendet : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
-    IntegerSpielerGegenständeVerwendet( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerSpielerItemsVerwendet( Aktion *spieler );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerItemsInInventar : Aktion
+class IntegerSpielerItemsInInventar : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerItemsInInventar( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerItemsTypeInInventar : Aktion
+class IntegerSpielerItemsTypeInInventar : public Aktion
 {
 private:
     Aktion *spieler;
@@ -1287,210 +1481,210 @@ private:
 
 public:
     IntegerSpielerItemsTypeInInventar( Aktion *item, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerTunnelBenutzt : Aktion
+class IntegerSpielerTunnelBenutzt : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerTunnelBenutzt( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerSchalterAktiviert : Aktion
+class IntegerSpielerSchalterAktiviert : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerSchalterAktiviert( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSpielerGeschossen : Aktion
+class IntegerSpielerGeschossen : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     IntegerSpielerGeschossen( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerDropZeit : Aktion
+class IntegerDropZeit : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerDropZeit( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerDropMaxZeit : Aktion
+class IntegerDropMaxZeit : public Aktion
 {
 private:
     Aktion *drop;
 
 public:
     IntegerDropMaxZeit( Aktion *drop );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerBariereBreite : Aktion
+class IntegerBariereBreite : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     IntegerBariereBreite( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerBariereHöhe : Aktion
+class IntegerBariereHeight : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
-    IntegerBariereHöhe( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    IntegerBariereHeight( Aktion *bariere );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerBariereVerschiebungen : Aktion
+class IntegerBariereVerschiebungen : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     IntegerBariereVerschiebungen( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerBariereSchaltungen : Aktion
+class IntegerBariereSchaltungen : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     IntegerBariereSchaltungen( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerSchalterAktivierungen : Aktion
+class IntegerSchalterAktivierungen : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
     IntegerSchalterAktivierungen( Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTunnelBenutzungen : Aktion
+class IntegerTunnelBenutzungen : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     IntegerTunnelBenutzungen( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerUmlenkungBenutzungen : Aktion
+class IntegerUmlenkungBenutzungen : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     IntegerUmlenkungBenutzungen( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTeamPunkte : Aktion
+class IntegerTeamPunkte : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     IntegerTeamPunkte( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTeamKills : Aktion
+class IntegerTeamKills : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     IntegerTeamKills( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTeamTode : Aktion
+class IntegerTeamTode : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     IntegerTeamTode( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTeamWiederbelegungszeit : Aktion
+class IntegerTeamWiederbelegungszeit : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     IntegerTeamWiederbelegungszeit( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTeamSpieleranzahl : Aktion
+class IntegerTeamSpieleranzahl : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     IntegerTeamSpieleranzahl( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTimerAktuelleZeit : Aktion
+class IntegerTimerAktuelleZeit : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     IntegerTimerAktuelleZeit( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTimerMaxZeit : Aktion
+class IntegerTimerMaxZeit : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     IntegerTimerMaxZeit( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class IntegerTriggerRunns : Aktion
+class IntegerTriggerRunns : public Aktion
 {
 private:
     Aktion *trigger;
 
 public:
     IntegerTriggerRunns( Aktion *trigger );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class ItemSpielerInventar : Aktion
+class ItemSpielerInventar : public Aktion
 {
 private:
     Aktion *spieler;
@@ -1498,233 +1692,222 @@ private:
 
 public:
     ItemSpielerInventar( Aktion *index, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class ItemSpielerInventar : Aktion
-{
-private:
-    Aktion *spieler;
-    Aktion *index;
-
-public:
-    ItemSpielerInventar( Aktion *index, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
-};
-
-class ItemZuletztAufgehoben : Aktion
+class ItemZuletztAufgehoben : public Aktion
 {
 public:
     ItemZuletztAufgehoben();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class ItemZuletztAktiviert : Aktion
+class ItemZuletztAktiviert : public Aktion
 {
 public:
     ItemZuletztAktiviert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class ItemZuletztGedropt : Aktion
+class ItemZuletztGedropt : public Aktion
 {
 public:
     ItemZuletztGedropt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class ItemZufall : Aktion
+class ItemZufall : public Aktion
 {
 public:
     ItemZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZufall : Aktion
+class GeschossZufall : public Aktion
 {
 public:
     GeschossZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZuletztAbgefeuert : Aktion
+class GeschossZuletztAbgefeuert : public Aktion
 {
 public:
     GeschossZuletztAbgefeuert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZuletztUmgelenkt : Aktion
+class GeschossZuletztUmgelenkt : public Aktion
 {
 public:
     GeschossZuletztUmgelenkt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZuletztBarjereGetroffen : Aktion
+class GeschossZuletztBarjereGetroffen : public Aktion
 {
 public:
     GeschossZuletztBarjereGetroffen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZuletztTunnelBenutzt : Aktion
+class GeschossZuletztTunnelBenutzt : public Aktion
 {
 public:
     GeschossZuletztTunnelBenutzt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class GeschossZuletztGeschossGetroffen : Aktion
+class GeschossZuletztGeschossGetroffen : public Aktion
 {
 public:
     GeschossZuletztGeschossGetroffen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class RichtungZufall : Aktion
+class RichtungZufall : public Aktion
 {
 public:
     RichtungZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class RichtungVonUmlenkung : Aktion
+class RichtungVonUmlenkung : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     RichtungVonUmlenkung( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class RichtungVonGeschoss : Aktion
+class RichtungVonGeschoss : public Aktion
 {
 private:
     Aktion *geschoss;
 
 public:
     RichtungVonGeschoss( Aktion *geschoss );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SchalterZufall : Aktion
+class SchalterZufall : public Aktion
 {
 public:
     SchalterZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SchalterZuletztAktiviert : Aktion
+class SchalterZuletztAktiviert : public Aktion
 {
 public:
     SchalterZuletztAktiviert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZufall : Aktion
+class SpielerZufall : public Aktion
 {
 public:
     SpielerZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZufallAusTeam : Aktion
+class SpielerZufallAusTeam : public Aktion
 {
 private:
     Aktion *team;
 
 public:
     SpielerZufallAusTeam( Aktion *team );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztSchadenGemacht : Aktion
+class SpielerZuletztSchadenGemacht : public Aktion
 {
 public:
     SpielerZuletztSchadenGemacht();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztSchadenGenommen : Aktion
+class SpielerZuletztSchadenGenommen : public Aktion
 {
 public:
     SpielerZuletztSchadenGenommen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztGeheilt : Aktion
+class SpielerZuletztGeheilt : public Aktion
 {
 public:
     SpielerZuletztGeheilt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztLevelUp : Aktion
+class SpielerZuletztLevelUp : public Aktion
 {
 public:
     SpielerZuletztLevelUp();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztErfahrungBekommen : Aktion
+class SpielerZuletztErfahrungBekommen : public Aktion
 {
 public:
     SpielerZuletztErfahrungBekommen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztGegenstandAktiviert : Aktion
+class SpielerZuletztGegenstandAktiviert : public Aktion
 {
 public:
     SpielerZuletztGegenstandAktiviert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztGegenstandAufgehoben : Aktion
+class SpielerZuletztGegenstandAufgehoben : public Aktion
 {
 public:
     SpielerZuletztGegenstandAufgehoben();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztSchalterAktiviert : Aktion
+class SpielerZuletztSchalterAktiviert : public Aktion
 {
 public:
     SpielerZuletztSchalterAktiviert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztTunnelBenutzt : Aktion
+class SpielerZuletztTunnelBenutzt : public Aktion
 {
 public:
     SpielerZuletztTunnelBenutzt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztGestorben : Aktion
+class SpielerZuletztGestorben : public Aktion
 {
 public:
     SpielerZuletztGestorben();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztWiederbelebent : Aktion
+class SpielerZuletztWiederbelebent : public Aktion
 {
 public:
     SpielerZuletztWiederbelebent();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class SpielerZuletztGeschossGeschossen : Aktion
+class SpielerZuletztGeschossGeschossen : public Aktion
 {
 public:
     SpielerZuletztGeschossGeschossen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextConcat : Aktion
+class TextConcat : public Aktion
 {
 private:
     Aktion *t1;
@@ -1732,70 +1915,70 @@ private:
 
 public:
     TextConcat( Aktion *t1, Aktion *t2 );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextAusZahl : Aktion
+class TextAusZahl : public Aktion
 {
 private:
     Aktion *zahl;
 
 public:
     TextAusZahl( Aktion *zahl );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextAusRichtung : Aktion
+class TextAusRichtung : public Aktion
 {
 private:
     Aktion *richtung;
 
 public:
     TextAusRichtung( Aktion *richtung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextAusBoolean : Aktion
+class TextAusBoolean : public Aktion
 {
 private:
     Aktion *boolean;
 
 public:
     TextAusBoolean( Aktion *boolean );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextSpielerName : Aktion
+class TextSpielerName : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     TextSpielerName( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextItemName : Aktion
+class TextItemName : public Aktion
 {
 private:
     Aktion *item;
 
 public:
     TextItemName( Aktion *item );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextTriggerName : Aktion
+class TextTriggerName : public Aktion
 {
 private:
     Aktion *trigger;
 
 public:
     TextTriggerName( Aktion *trigger );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TextTeilVonText : Aktion
+class TextTeilVonText : public Aktion
 {
 private:
     Aktion *start;
@@ -1804,124 +1987,124 @@ private:
 
 public:
     TextTeilVonText( Aktion *start, Aktion *ende, Aktion *text );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TeamZufall : Aktion
+class TeamZufall : public Aktion
 {
 public:
     TeamZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TeamVonSpieler : Aktion
+class TeamVonSpieler : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     TeamVonSpieler( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TeamVonBariere : Aktion
+class TeamVonBariere : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     TeamVonBariere( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerZufall : Aktion
+class TimerZufall : public Aktion
 {
 public:
     TimerZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerZuletztAbgelaufen : Aktion
+class TimerZuletztAbgelaufen : public Aktion
 {
 public:
     TimerZuletztAbgelaufen();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerZuletztGestartet : Aktion
+class TimerZuletztGestartet : public Aktion
 {
 public:
     TimerZuletztGestartet();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerZuletztPausiert : Aktion
+class TimerZuletztPausiert : public Aktion
 {
 public:
     TimerZuletztPausiert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TimerZuletztFortgesetzt : Aktion
+class TimerZuletztFortgesetzt : public Aktion
 {
 public:
     TimerZuletztFortgesetzt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TunnelZufall : Aktion
+class TunnelZufall : public Aktion
 {
 public:
     TunnelZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class TunnelZuletztBenutzt : Aktion
+class TunnelZuletztBenutzt : public Aktion
 {
 public:
     TunnelZuletztBenutzt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungZufall : Aktion
+class UmlenkungZufall : public Aktion
 {
 public:
     UmlenkungZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class UmlenkungZuletztBenutzt : Aktion
+class UmlenkungZuletztBenutzt : public Aktion
 {
 public:
     UmlenkungZuletztBenutzt();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanZufall : Aktion
+class BooleanZufall : public Aktion
 {
 public:
     BooleanZufall();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielPausiert : Aktion
+class BooleanSpielPausiert : public Aktion
 {
 public:
     BooleanSpielPausiert();
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielerAmLeben : Aktion
+class BooleanSpielerAmLeben : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     BooleanSpielerAmLeben( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielerHatGegenstand : Aktion
+class BooleanSpielerHatGegenstand : public Aktion
 {
 private:
     Aktion *spieler;
@@ -1929,10 +2112,10 @@ private:
 
 public:
     BooleanSpielerHatGegenstand( Aktion *item, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielerInTeam : Aktion
+class BooleanSpielerInTeam : public Aktion
 {
 private:
     Aktion *spieler;
@@ -1940,151 +2123,151 @@ private:
 
 public:
     BooleanSpielerInTeam( Aktion *team, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielerIstVerwundbar : Aktion
+class BooleanSpielerIstVerwundbar : public Aktion
 {
 private:
     Aktion *spieler;
 
 public:
     BooleanSpielerIstVerwundbar( Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSpielerIstItemfähig : Aktion
+class BooleanSpielerKannItemBenutzen : public Aktion
 {
 private:
     Aktion *spieler;
     Aktion *item;
 
 public:
-    BooleanSpielerIstItemfähig( Aktion *item, Aktion *spieler );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    BooleanSpielerKannItemBenutzen( Aktion *item, Aktion *spieler );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanUmlenkungHatAbk : Aktion
+class BooleanUmlenkungHatAbk : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     BooleanUmlenkungHatAbk( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanUmlenkungIstDrehend : Aktion
+class BooleanUmlenkungIstDrehend : public Aktion
 {
 private:
     Aktion *umlenkung;
 
 public:
     BooleanUmlenkungIstDrehend( Aktion *umlenkung );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanBariereBewegtSich : Aktion
+class BooleanBariereBewegtSich : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     BooleanBariereBewegtSich( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanBariereIstSchaltend : Aktion
+class BooleanBariereIstSchaltend : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     BooleanBariereIstSchaltend( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanBariereIstAktiv : Aktion
+class BooleanBariereIstAktiv : public Aktion
 {
 private:
     Aktion *bariere;
 
 public:
     BooleanBariereIstAktiv( Aktion *bariere );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanSchalterIstAktiv : Aktion
+class BooleanSchalterIstAktiv : public Aktion
 {
 private:
     Aktion *schalter;
 
 public:
     BooleanSchalterIstAktiv( Aktion *schalter );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanTunnelIstAktiv : Aktion
+class BooleanTunnelIstAktiv : public Aktion
 {
 private:
     Aktion *tunnel;
 
 public:
     BooleanTunnelIstAktiv( Aktion *tunnel );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanBaseIstNeutral : Aktion
+class BooleanBaseIstNeutral : public Aktion
 {
 private:
     Aktion *base;
 
 public:
     BooleanBaseIstNeutral( Aktion *base );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanTimerIsRunning : Aktion
+class BooleanTimerIsRunning : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     BooleanTimerIsRunning( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanTimerIstSichtbar : Aktion
+class BooleanTimerIstSichtbar : public Aktion
 {
 private:
     Aktion *timer;
 
 public:
     BooleanTimerIstSichtbar( Aktion *timer );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanAusText : Aktion
+class BooleanAusText : public Aktion
 {
 private:
     Aktion *text;
 
 public:
     BooleanAusText( Aktion *text );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanAuslöserIstAktiv : Aktion
+class BooleanTriggerIstAktiv : public Aktion
 {
 private:
-    Aktion *auslöser;
+    Aktion *trigger;
 
 public:
-    BooleanAuslöserIstAktiv( Aktion *auslöser );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    BooleanTriggerIstAktiv( Aktion *trigger );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanGleich : Aktion
+class BooleanGleich : public Aktion
 {
 private:
     Aktion *v1;
@@ -2092,21 +2275,20 @@ private:
 
 public:
     BooleanGleich( Aktion *v1, Aktion *v2 );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanUngleich : Aktion
+class BooleanNicht : public Aktion
 {
 private:
-    Aktion *v1;
-    Aktion *v2;
+    Aktion *boolean;
 
 public:
-    BooleanUngleich( Aktion *v1, Aktion *v2 );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    BooleanNicht( Aktion *boolean );
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanUnd : Aktion
+class BooleanUnd : public Aktion
 {
 private:
     Aktion *v1;
@@ -2114,10 +2296,10 @@ private:
 
 public:
     BooleanUnd( Aktion *v1, Aktion *v2 );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };
 
-class BooleanOder : Aktion
+class BooleanOder : public Aktion
 {
 private:
     Aktion *v1;
@@ -2125,5 +2307,5 @@ private:
 
 public:
     BooleanOder( Aktion *v1, Aktion *v2 );
-    Variable *run( Memory *zMem, Ereignis *zEreignis, double &waitCount ) override;
+    Variable *run( Spiel *zSpiel, Ereignis *zEreignis, double &waitCount ) override;
 };

StickmanWorldOnline/Bariere.h

@@ -19,6 +19,7 @@ public:
         const static int Aktiv = 0x40;
     };
 private:
+    static int nextId;
     int style;
     int autoSchaltungMaxTime;
     float autoSchaltungCurrentTime;
@@ -26,6 +27,7 @@ private:
     float currentWeite;
     int verschiebungAnzahl;
     int schaltungAnzahl;
+    int id;
     Team *team;
 
 public:

StickmanWorldOnline/Base.h

@@ -6,6 +6,8 @@
 class Base : public GameObject
 {
 private:
+    static int nextId;
+    int id;
     Team *team;
     int maxTime;
     bool inChange;

StickmanWorldOnline/Gegenstand.h

@@ -4,6 +4,7 @@
 
 enum GegenstandTyp
 {
+    KEIN_GEGENSTAND,
     PFEIL,
     LEBEN,
     SCHILD,
@@ -21,8 +22,7 @@ enum GegenstandTyp
     RBOSHEIT,
     RLEBEN,
     RTEMPO,
-    ITEMANZAHL,
-    NICHTS
+    ITEMANZAHL
 };
 
 class Gegenstand : public GameObject

StickmanWorldOnline/Geschoss.h

@@ -5,10 +5,10 @@
 
 enum GeschossTyp
 {
-    PFEIL,
-    KUGEL,
-    DRACHENAUGE,
-    FEUERBALL
+    GESCHOSS_PFEIL,
+    GESCHOSS_KUGEL,
+    GESCHOSS_DRACHENAUGE,
+    GESCHOSS_FEUERBALL
 };
 
 class Geschoss : public GameObject

StickmanWorldOnline/Reader.cpp

@@ -0,0 +1,832 @@
+#include "Reader.h"
+#include "Spiel.h"
+
+struct SpielerTeamStruktur
+{
+    int spielerAnzahl;
+    int teamAnzahl;
+    Array< int > spielerFarbe;
+    Array< int > teamFarbe;
+    RCArray< Text > teamName;
+    Array< int > teamSize;
+};
+
+
+// Konstruktor
+MapReader::MapReader( int karteId, SSDatenbankV *db, char *tmpPfad )
+{
+    this->karteId = karteId;
+    this->db = db;
+    pfad = new Text( tmpPfad );
+    ref = 1;
+}
+
+// Destruktor
+MapReader::~MapReader()
+{
+    if( db )
+        db->release();
+    if( pfad )
+        pfad->release();
+}
+
+Aktion *MapReader::readAktion( Datei &dat )
+{
+    int id;
+    dat.lese( (char *)& id, 4 );
+    char pAnz = 0;
+    dat.lese( &pAnz, 1 );
+    Aktion *params[ 255 ];
+    for( int i = 0; i < pAnz; i++ )
+        params[ i ] = readAktion( dat );
+    switch( id )
+    {
+    case BARIERE_BEWEGUNG:
+        return new BariereBewegung( params[ 0 ] );
+    case BARIERE_SET_EINGESCHALTET:
+        return new BariereSetEingeschaltet( params[ 0 ], params[ 1 ] );
+    case BARIERE_SET_POSITION:
+        return new BariereSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case BARIERE_SET_TEAM:
+        return new BariereSetTeam( params[ 0 ], params[ 1 ] );
+    case BARIERE_ZUFALL:
+        return new BariereZufall();
+    case BARIERE_ZULETZT_AUSGESCHALTET:
+        return new BariereZuletztAusgeschaltet();
+    case BARIERE_ZULETZT_BEWEGT:
+        return new BariereZuletztBewegt();
+    case BARIERE_ZULETZT_EINGESCHALTET:
+        return new BariereZuletztEingeschaltet();
+    case BASE_SET_POSITION:
+        return new BaseSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case BASE_SET_TEAM:
+        return new BaseSetTeam( params[ 0 ], params[ 1 ] );
+    case BASE_ZUFALL:
+        return new BaseZufall();
+    case BASE_ZULETZT_BESITZER_GEWECHSELT:
+        return new BaseZuletztBesitzerGewechselt();
+    case BOOLEAN_AUS_TEXT:
+        return new BooleanAusText( params[ 0 ] );
+    case BOOLEAN_BARIERE_BEWEGT_SICH:
+        return new BooleanBariereBewegtSich( params[ 0 ] );
+    case BOOLEAN_BARIERE_IST_AKTIV:
+        return new BooleanBariereIstAktiv( params[ 0 ] );
+    case BOOLEAN_BARIERE_IST_SCHALTEND:
+        return new BooleanBariereIstSchaltend( params[ 0 ] );
+    case BOOLEAN_BASE_IST_NEUTRAL:
+        return new BooleanBaseIstNeutral( params[ 0 ] );
+    case BOOLEAN_GLEICH:
+        return new BooleanGleich( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_NICHT:
+        return new BooleanNicht( params[ 0 ] );
+    case BOOLEAN_ODER:
+        return new BooleanOder( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_SCHALTER_IST_AKTIV:
+        return new BooleanSchalterIstAktiv( params[ 0 ] );
+    case BOOLEAN_SPIELER_AM_LEBEN:
+        return new BooleanSpielerAmLeben( params[ 0 ] );
+    case BOOLEAN_SPIELER_HAT_GEGENSTAND:
+        return new BooleanSpielerHatGegenstand( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_SPIELER_IN_TEAM:
+        return new BooleanSpielerInTeam( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_SPIELER_IST_VERWUNDBAR:
+        return new BooleanSpielerIstVerwundbar( params[ 0 ] );
+    case BOOLEAN_SPIELER_KANN_ITEM_BENUTZEN:
+        return new BooleanSpielerKannItemBenutzen( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_SPIEL_PAUSIERT:
+        return new BooleanSpielPausiert();
+    case BOOLEAN_TIMER_IS_RUNNING:
+        return new BooleanTimerIsRunning( params[ 0 ] );
+    case BOOLEAN_TIMER_IST_SICHTBAR:
+        return new BooleanTimerIstSichtbar( params[ 0 ] );
+    case BOOLEAN_TRIGGER_IST_AKTIV:
+        return new BooleanTriggerIstAktiv( params[ 0 ] );
+    case BOOLEAN_TUNNEL_IST_AKTIV:
+        return new BooleanTunnelIstAktiv( params[ 0 ] );
+    case BOOLEAN_UMLENKUNG_HAT_ABK:
+        return new BooleanUmlenkungHatAbk( params[ 0 ] );
+    case BOOLEAN_UMLENKUNG_IST_DREHEND:
+        return new BooleanUmlenkungIstDrehend( params[ 0 ] );
+    case BOOLEAN_UND:
+        return new BooleanUnd( params[ 0 ], params[ 1 ] );
+    case BOOLEAN_ZUFALL:
+        return new BooleanZufall();
+    case DISPLAY_TEXT:
+        return new DisplayText( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ] );
+    case DROP_DO_DROP:
+        return new DropDoDrop( params[ 0 ] );
+    case DROP_SET_AREA:
+        return new DropSetArea( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ], params[ 4 ] );
+    case DROP_SET_MAX_TIME:
+        return new DropSetMaxTime( params[ 0 ], params[ 1 ] );
+    case DROP_SET_TIME:
+        return new DropSetTime( params[ 0 ], params[ 1 ] );
+    case DROP_ZUFALL:
+        return new DropZufall();
+    case DROP_ZULETZT_GEDROPT:
+        return new DropZuletztGedropt();
+    case GESCHOSS_NEU:
+        return new GeschossNeu( params[ 0 ], params[ 1 ], params[ 2 ], params[ 3 ] );
+    case GESCHOSS_SET_PLAYER:
+        return new GeschossSetPlayer( params[ 0 ], params[ 1 ] );
+    case GESCHOSS_SET_POSITION:
+        return new GeschossSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case GESCHOSS_SET_RICHTUNG:
+        return new GeschossSetRichtung( params[ 0 ], params[ 1 ] );
+    case GESCHOSS_SET_SPEED:
+        return new GeschossSetSpeed( params[ 0 ], params[ 1 ] );
+    case GESCHOSS_SET_TYPE:
+        return new GeschossSetType( params[ 0 ], params[ 1 ] );
+    case GESCHOSS_ZUFALL:
+        return new GeschossZufall();
+    case GESCHOSS_ZULETZT_ABGEFEUERT:
+        return new GeschossZuletztAbgefeuert();
+    case GESCHOSS_ZULETZT_BARIERE_GETROFFEN:
+        return new GeschossZuletztBarjereGetroffen();
+    case GESCHOSS_ZULETZT_GESCHOSS_GETROFFEN:
+        return new GeschossZuletztGeschossGetroffen();
+    case GESCHOSS_ZULETZT_TUNNEL_BENUTZT:
+        return new GeschossZuletztTunnelBenutzt();
+    case GESCHOSS_ZULETZT_UMGELENKT:
+        return new GeschossZuletztUmgelenkt();
+    case INTEGER_AUS_TEXT:
+        return new IntegerAusText( params[ 0 ] );
+    case INTEGER_BARIERE_BREITE:
+        return new IntegerBariereBreite( params[ 0 ] );
+    case INTEGER_BARIERE_HEIGHT:
+        return new IntegerBariereHeight( params[ 0 ] );
+    case INTEGER_BARIERE_SCHALTUNGEN:
+        return new IntegerBariereSchaltungen( params[ 0 ] );
+    case INTEGER_BARIERE_VERSCHIEBUNGEN:
+        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 INTEGER_MAX_X_VON_DROP:
+        return new IntegerMaxXVonDrop( params[ 0 ] );
+    case INTEGER_MAX_Y_VON_DROP:
+        return new IntegerMaxYVonDrop( params[ 0 ] );
+    case INTEGER_MIN_X_VON_DROP:
+        return new IntegerMinXVonDrop( params[ 0 ] );
+    case INTEGER_MIN_Y_VON_DROP:
+        return new IntegerMinYVonDrop( params[ 0 ] );
+    case INTEGER_RECHNEN:
+    {
+        char op;
+        dat.lese( &op, 1 );
+        return new IntegerRechnen( params[ 0 ], params[ 1 ], op );
+    }
+    case INTEGER_SCHALTER_AKTIVIERUNGEN:
+        return new IntegerSchalterAktivierungen( params[ 0 ] );
+    case INTEGER_SPIELER_ABKLINGZEITVERRINGERUNG:
+        return new IntegerSpielerAbklingzeitverringerrung( 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 INTEGER_SPIELER_GESCHOSSEN:
+        return new IntegerSpielerGeschossen( params[ 0 ] );
+    case INTEGER_SPIELER_GESCHOSS_TEMPO:
+        return new IntegerSpielerGeschossTempo( params[ 0 ] );
+    case INTEGER_SPIELER_GETROFFEN:
+        return new IntegerSpielerGetroffen( params[ 0 ] );
+    case INTEGER_SPIELER_ITEMS_AUFGEHOBEN:
+        return new IntegerSpielerItemsAufgehoben( params[ 0 ] );
+    case INTEGER_SPIELER_ANZAHL_ITEMS_IN_INVENTAR:
+        return new IntegerSpielerItemsInInventar( params[ 0 ] );
+    case INTEGER_SPIELER_ANZAHL_ITEMS_VON_TYP:
+        return new IntegerSpielerItemsTypeInInventar( params[ 0 ], params[ 1 ] );
+    case INTEGER_SPIELER_ITEMS_VERWENDET:
+        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 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 INTEGER_SPIELER_SCHALTER_AKTIVIERT:
+        return new IntegerSpielerSchalterAktiviert( params[ 0 ] );
+    case INTEGER_SPIELER_TEMPO:
+        return new IntegerSpielerTempo( params[ 0 ] );
+    case INTEGER_SPIELER_TODE:
+        return new IntegerSpielerTode( params[ 0 ] );
+    case INTEGER_SPIELER_TREFFER:
+        return new IntegerSpielerTreffer( params[ 0 ] );
+    case INTEGER_SPIELER_TUNNEL_BENUTZT:
+        return new IntegerSpielerTunnelBenutzt( params[ 0 ] );
+    case INTEGER_TEAM_KILLS:
+        return new IntegerTeamKills( params[ 0 ] );
+    case INTEGER_TEAM_PUNKTE:
+        return new IntegerTeamPunkte( params[ 0 ] );
+    case INTEGER_TEAM_SPIELERANZAHL:
+        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 INTEGER_TIMER_MAX_ZEIT:
+        return new IntegerTimerMaxZeit( params[ 0 ] );
+    case INTEGER_TRIGGER_RUNNS:
+        return new IntegerTriggerRunns( params[ 0 ] );
+    case INTEGER_TUNNEL_BENUTZUNGEN:
+        return new IntegerTunnelBenutzungen( params[ 0 ] );
+    case INTEGER_UMLENKUNG_BENUTZUNGEN:
+        return new IntegerUmlenkungBenutzungen( params[ 0 ] );
+    case INTEGER_X_VON_BARIERE:
+        return new IntegerXVonBariere( params[ 0 ] );
+    case INTEGER_X_VON_BASE:
+        return new IntegerXVonBase( params[ 0 ] );
+    case INTEGER_X_VON_GESCHOSS:
+        return new IntegerXVonGeschoss( params[ 0 ] );
+    case INTEGER_X_VON_SCHALTER:
+        return new IntegerXVonSchalter( params[ 0 ] );
+    case INTEGER_X_VON_SPIELER:
+        return new IntegerXVonSpieler( params[ 0 ] );
+    case INTEGER_X_VON_TIMER:
+        return new IntegerXVonTimer( params[ 0 ] );
+    case INTEGER_X_VON_TUNNEL:
+        return new IntegerXVonTunnel( params[ 0 ] );
+    case INTEGER_X_VON_TUNNEL_ZIEL:
+        return new IntegerXVonTunnelZiel( params[ 0 ] );
+    case INTEGER_X_VON_UMLENKUNG:
+        return new IntegerXVonUmlenkung( params[ 0 ] );
+    case INTEGER_Y_VON_BARIERE:
+        return new IntegerYVonBariere( params[ 0 ] );
+    case INTEGER_Y_VON_BASE:
+        return new IntegerYVonBase( params[ 0 ] );
+    case INTEGER_Y_VON_GESCHOSS:
+        return new IntegerYVonGeschoss( params[ 0 ] );
+    case INTEGER_Y_VON_SCHALTER:
+        return new IntegerYVonSchalter( params[ 0 ] );
+    case INTEGER_Y_VON_SPIELER:
+        return new IntegerYVonSpieler( params[ 0 ] );
+    case INTEGER_Y_VON_TIMER:
+        return new IntegerYVonTimer( params[ 0 ] );
+    case INTEGER_Y_VON_TUNNEL:
+        return new IntegerYVonTunnel( params[ 0 ] );
+    case INTEGER_Y_VON_TUNNEL_ZIEL:
+        return new IntegerYVonTunnelZiel( params[ 0 ] );
+    case INTEGER_Y_VON_UMLENKUNG:
+        return new IntegerYVonUmlenkung( params[ 0 ] );
+    case INTEGER_ZUFALL:
+        return new IntegerZufall( params[ 0 ], params[ 1 ] );
+    case ITEM_SPIELER_INVENTAR:
+        return new ItemSpielerInventar( params[ 0 ], params[ 1 ] );
+    case ITEM_ZULETZT_AUFGEHOBEN:
+        return new ItemZuletztAufgehoben();
+    case ITEM_ZULETZT_GEDROPT:
+        return new ItemZuletztGedropt();
+    case KONSTANT_BOOLEAN:
+    {
+        bool b;
+        dat.lese( (char *)& b, 1 );
+        return new KonstantBoolean( b );
+    }
+    case KONSTANT_FLOAT:
+    {
+        float f;
+        dat.lese( (char *)& f, 4 );
+        return new KonstantFloat( f );
+    }
+    case KONSTANT_INTEGER:
+    {
+        int i;
+        dat.lese( (char *)& i, 4 );
+        return new KonstantInteger( i );
+    }
+    case KONSTANT_NICHTS:
+        return new KonstantNichts();
+    case KONSTANT_STRING:
+    {
+        char len;
+        dat.lese( &len, 1 );
+        char *txt = new char[ len + 1 ];
+        dat.lese( txt, len );
+        txt[ (int)len ] = 0;
+        Aktion *ret = new KonstantString( txt );
+        delete[] txt;
+        return ret;
+    }
+    case KONSTANT_VARIABLE:
+    {
+        char len;
+        dat.lese( &len, 1 );
+        char *txt = new char[ len + 1 ];
+        dat.lese( txt, len );
+        txt[ (int)len ] = 0;
+        Aktion *ret = new KonstantVariable( txt );
+        delete[] txt;
+        return ret;
+    }
+    case RICHTUNG_VON_GESCHOSS:
+        return new RichtungVonGeschoss( params[ 0 ] );
+    case RICHTUNG_VON_UMLENKUNG:
+        return new RichtungVonUmlenkung( params[ 0 ] );
+    case RICHTUNG_ZUFALL:
+        return new RichtungZufall();
+    case SCHALTER_AKTIVIEREN:
+        return new SchalterAktivieren( params[ 0 ] );
+    case SCHALTER_SET_ERLAUBT:
+        return new SchalterSetErlaubt( params[ 0 ], params[ 1 ] );
+    case SCHALTER_SET_POSITION:
+        return new SchalterSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case SCHALTER_ZUFALL:
+        return new SchalterZufall();
+    case SCHALTER_ZULETZT_AKTIVIERT:
+        return new SchalterZuletztAktiviert();
+    case SET_VARIABLE:
+    {
+        char len;
+        dat.lese( &len, 1 );
+        char *txt = new char[ len + 1 ];
+        dat.lese( txt, len );
+        txt[ (int)len ] = 0;
+        Aktion *ret = new SetVariable( txt, params[ 0 ] );
+        delete[] txt;
+        return ret;
+    }
+    case SPIEL_ENDE:
+        return new SpielEnde( params[ 0 ] );
+    case SPIELER_GIVE_ITEM:
+        return new SpielerGiveItem( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case SPIELER_NACHRICHT:
+        return new SpielerNachricht( params[ 0 ], params[ 1 ] );
+    case SPIELER_REMOVE_ITEM:
+        return new SpielerRemoveItem( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case SPIELER_SET_ABKLINGZEITVERRINGERUNG:
+        return new SpielerSetAbklingzeitverringerung( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_ARMOR:
+        return new SpielerSetArmor( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_ERFAHRUNG:
+        return new SpielerSetErfahrung( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_LEBEN:
+        return new SpielerSetLeben( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_LEBENSRAUB:
+        return new SpielerSetLebensraub( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_LEBENSREGENERATION:
+        return new SpielerSetLebensraub( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_LEVEL:
+        return new SpielerSetLevel( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_MAX_ERFAHRUNG:
+        return new SpielerSetMaxErfahrung( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_POSITION:
+        return new SpielerSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case SPIELER_SET_SCHADEN_BONUS:
+        return new SpielerSetSchadenBonus( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_TEMPO:
+        return new SpielerSetTempo( params[ 0 ], params[ 1 ] );
+    case SPIELER_SET_GESCHOSS_TEMPO:
+        return new SpielerSetWaffenTempo( params[ 0 ], params[ 1 ] );
+    case SPIELER_ZUFALL:
+        return new SpielerZufall();
+    case SPIELER_ZUFALL_AUS_TEAM:
+        return new SpielerZufallAusTeam( params[ 0 ] );
+    case SPIELER_ZULETZT_ERFAHRUNG_BEKOMMEN:
+        return new SpielerZuletztErfahrungBekommen();
+    case SPIELER_ZULETZT_GEGENSTAND_AKTIVIERT:
+        return new SpielerZuletztGegenstandAktiviert();
+    case SPIELER_ZULETZT_GEGENSTAND_AUFGEHOBEN:
+        return new SpielerZuletztGegenstandAufgehoben();
+    case SPIELER_ZULETZT_GEHEILT:
+        return new SpielerZuletztGeheilt();
+    case SPIELER_ZULETZT_GESCHOSSEN:
+        return new SpielerZuletztGeschossGeschossen();
+    case SPIELER_ZULETZT_GESTORBEN:
+        return new SpielerZuletztGestorben();
+    case SPIELER_ZULETZT_LEVEL_UP:
+        return new SpielerZuletztLevelUp();
+    case SPIELER_ZULETZT_SCHADEN_GEMACHT:
+        return new SpielerZuletztSchadenGemacht();
+    case SPIELER_ZULETZT_SCHADEN_GENOMMEN:
+        return new SpielerZuletztSchadenGenommen();
+    case SPIELER_ZULETZT_SCHALTER_AKTIVIERT:
+        return new SpielerZuletztSchalterAktiviert();
+    case SPIELER_ZULETZT_TUNNEL_BENUTZT:
+        return new SpielerZuletztTunnelBenutzt();
+    case SPIELER_ZULETZT_WIEDERBELEBT:
+        return new SpielerZuletztWiederbelebent();
+    case SPIEL_PAUSE:
+        return new SpielPause( params[ 0 ] );
+    case TEAM_SET_PUNKTE:
+        return new TeamSetPunkte( params[ 0 ], params[ 1 ] );
+    case TEAM_VON_BARIERE:
+        return new TeamVonBariere( params[ 0 ] );
+    case TEAM_VON_SPIELER:
+        return new TeamVonSpieler( params[ 0 ] );
+    case TEAM_ZUFALL:
+        return new TeamZufall();
+    case TEXT_AUS_BOOLEAN:
+        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_CONCAT:
+        return new TextConcat( params[ 0 ], params[ 1 ] );
+    case TEXT_ITEM_NAME:
+        return new TextItemName( params[ 0 ] );
+    case TEXT_SPIELER_NAME:
+        return new TextSpielerName( params[ 0 ] );
+    case TEXT_TEIL_VON_TEXT:
+        return new TextTeilVonText( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case TEXT_TRIGGER_NAME:
+        return new TextTriggerName( params[ 0 ] );
+    case TIMER_SET_PAUSE:
+        return new TimerSetPause( params[ 0 ], params[ 1 ] );
+    case TIMER_SET_POSITION:
+        return new TimerSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case TIMER_SET_SICHTBAR:
+        return new TimerSetSichtbar( params[ 0 ], params[ 1 ] );
+    case TIMER_SET_ZEIT:
+        return new TimerSetZeit( params[ 0 ], params[ 1 ] );
+    case TIMER_START:
+        return new TimerStart( params[ 0 ] );
+    case TIMER_ZUFALL:
+        return new TimerZufall();
+    case TIMER_ZULETZT_ABGELAUFEN:
+        return new TimerZuletztAbgelaufen();
+    case TIMER_ZULETZT_FOTOGRAFIERT:
+        return new TimerZuletztFortgesetzt();
+    case TIMER_ZULETZT_GESTARTET:
+        return new TimerZuletztGestartet();
+    case TIMER_ZULETZT_PAUSIERT:
+        return new TimerZuletztPausiert();
+    case TRIGGER_AKTION:
+        return new TriggerAktion( params[ 0 ], params[ 1 ] );
+    case TRIGGER_LAST_RUNNED:
+        return new TriggerLastRunned();
+    case TRIGGER_RUN_START:
+        return new TriggerRunStart( params[ 0 ] );
+    case TRIGGER_SET_ENABLED:
+        return new TriggerSetEnabled( params[ 0 ], params[ 1 ] );
+    case TRIGGER_ZUFALL:
+        return new TriggerZufall();
+    case TUNNEL_SET_ERLAUBT:
+        return new TunnelSetErlaubt( params[ 0 ], params[ 1 ] );
+    case TUNNEL_SET_POSITION:
+        return new TunnelSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case TUNNEL_SET_ZIEL_POSITION:
+        return new TunnelSetZielPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case TUNNEL_ZUFALL:
+        return new TunnelZufall();
+    case TUNNEL_ZULETZT_BENUTZT:
+        return new TunnelZuletztBenutzt();
+    case UMLENKUNG_SET_ERLAUBT:
+        return new UmlenkungSetEnabled( params[ 0 ], params[ 1 ] );
+    case UMLENKUNG_SET_MAX_ABK:
+        return new UmlenkungSetMaxAbk( params[ 0 ], params[ 1 ] );
+    case UMLENKUNG_SET_POSITION:
+        return new UmlenkungSetPosition( params[ 0 ], params[ 1 ], params[ 2 ] );
+    case UMLENKUNG_SET_RICHTUNG:
+        return new UmlenkungSetRichtung( params[ 0 ], params[ 1 ] );
+    case UMLENKUNG_ZUFALL:
+        return new UmlenkungZufall();
+    case UMLENKUNG_ZULETZT_BENUTZT:
+        return new UmlenkungZuletztBenutzt();
+    case WARTEN:
+        return new Warten( params[ 0 ] );
+    case WENN_DANN_SONST:
+        return new WennDannSonst( params[ 0 ], params[ 1 ], params[ 2 ] );
+    }
+    return new KonstantNichts();
+}
+
+// nicht constant
+void MapReader::ladeKarte( Spiel *zSpiel )
+{
+    if( !pfad )
+        return;
+    SpielerTeamStruktur sts;
+    Text *pf = new Text( pfad->getText() );
+    pf->append( "sts.ltgd" );
+    Datei *datei = new Datei();
+    datei->setDatei( pf );
+    if( !datei->existiert() || datei->istOrdner() )
+    {
+        datei->release();
+        return;
+    }
+    datei->open( Datei::Style::lesen );
+    datei->lese( (char *)& sts.spielerAnzahl, 4 );
+    datei->lese( (char *)& sts.teamAnzahl, 4 );
+    for( int i = 0; i < sts.spielerAnzahl; i++ )
+    {
+        int farbe = 0;
+        datei->lese( (char *)& farbe, 4 );
+        sts.spielerFarbe.set( farbe, i );
+    }
+    for( int i = 0; i < sts.teamAnzahl; i++ )
+    {
+        int farbe = 0;
+        datei->lese( (char *)& farbe, 4 );
+        sts.teamFarbe.set( farbe, i );
+    }
+    for( int i = 0; i < sts.teamAnzahl; i++ )
+    {
+        char len = 0;
+        datei->lese( &len, 1 );
+        char *txt = new char[ len + 1 ];
+        txt[ (int)len ] = 0;
+        datei->lese( txt, len );
+        Text *name = new Text( txt );
+        delete[] txt;
+        sts.teamName.set( name, i );
+    }
+    for( int i = 0; i < sts.teamAnzahl; i++ )
+    {
+        int size = 0;
+        datei->lese( (char *)& size, 4 );
+        sts.teamSize.set( size, i );
+    }
+    datei->close();
+    datei->release();
+    pf = new Text( pfad->getText() );
+    pf->append( "data.map" );
+    Datei mapFile;
+    mapFile.setDatei( pf );
+    if( !mapFile.existiert() || mapFile.istOrdner() )
+        return;
+    mapFile.open( Datei::Style::lesen );
+    // teams
+    int anz = 0;
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int maxWbZeit;
+        int punkte;
+        mapFile.lese( (char *)& maxWbZeit, 4 );
+        mapFile.lese( (char *)& punkte, 4 );
+        if( i < sts.teamAnzahl )
+            zSpiel->addTeam( new Team( i, sts.teamSize.get( i ), punkte, maxWbZeit, sts.teamFarbe.get( i ), sts.teamName.z( i )->getText() ) );
+    }
+    // spieler
+    int team = 0;
+    int maxT = sts.teamSize.get( team );
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int spawnX;
+        int spawnY;
+        int breite;
+        int height;
+        int leben;
+        int erfahrung;
+        int laufTempo;
+        int geschossTempo;
+        int armor;
+        int schadenBonus;
+        int lebensraub;
+        int lebensReg;
+        int abkVerringerung;
+        int level;
+        mapFile.lese( (char *)& spawnX, 4 );
+        mapFile.lese( (char *)& spawnY, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        mapFile.lese( (char *)& leben, 4 );
+        mapFile.lese( (char *)& erfahrung, 4 );
+        mapFile.lese( (char *)& laufTempo, 4 );
+        mapFile.lese( (char *)& geschossTempo, 4 );
+        mapFile.lese( (char *)& armor, 4 );
+        mapFile.lese( (char *)& schadenBonus, 4 );
+        mapFile.lese( (char *)& lebensraub, 4 );
+        mapFile.lese( (char *)& lebensReg, 4 );
+        mapFile.lese( (char *)& abkVerringerung, 4 );
+        mapFile.lese( (char *)& level, 4 );
+        if( i < sts.spielerAnzahl )
+        {
+            if( i >= maxT )
+                team++;
+            if( sts.teamSize.hat( team ) )
+                maxT += sts.teamSize.get( team );
+            zSpiel->addSpieler( new Spieler( i, zSpiel->getTeam( team ), spawnX, spawnY, breite, height,
+                                sts.spielerFarbe.get( i ), leben, erfahrung, laufTempo, geschossTempo,
+                                armor, schadenBonus, lebensraub, lebensReg, abkVerringerung, level ) );
+        }
+    }
+    // Barieren
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        int style;
+        int verschiebungWeite;
+        int autoSchaltungMaxTime;
+        int team;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        mapFile.lese( (char *)& style, 4 );
+        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 ) ) );
+    }
+    // Basen
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        int maxTime;
+        int team;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        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 ) ) );
+    }
+    // Drops
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int minX;
+        int minY;
+        int maxX;
+        int maxY;
+        int maxTime;
+        int numDrops;
+        float wahrscheinlichkeit[ ITEMANZAHL ];
+        mapFile.lese( (char *)& minX, 4 );
+        mapFile.lese( (char *)& minY, 4 );
+        mapFile.lese( (char *)& maxX, 4 );
+        mapFile.lese( (char *)& maxY, 4 );
+        mapFile.lese( (char *)& maxTime, 4 );
+        for( int j = KEIN_GEGENSTAND; j < ITEMANZAHL; j++ )
+            mapFile.lese( (char *)& wahrscheinlichkeit[ j ], 4 );
+        char len;
+        mapFile.lese( (char *)& len, 1 );
+        char *name = new char[ (int)len + 1 ];
+        mapFile.lese( (char *)& name, len );
+        name[ (int)len ] = 0;
+        zSpiel->addDrop( new Drop( minX, maxX, minY, maxY, maxTime, numDrops, name, wahrscheinlichkeit ) );
+        delete[] name;
+    }
+    // Schalter
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        bool aktive;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        mapFile.lese( (char *)& aktive, 1 );
+        zSpiel->addSchalter( new Schalter( x, y, breite, height, aktive ) );
+    }
+    // Schiene
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        zSpiel->addSchiene( new Schiene( x, y, breite, height ) );
+    }
+    // Timer
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int maxZeit;
+        bool sichtbar;
+        bool autoWiederhohlung;
+        bool runns;
+        int farbe;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& maxZeit, 4 );
+        mapFile.lese( (char *)& sichtbar, 1 );
+        mapFile.lese( (char *)& autoWiederhohlung, 1 );
+        mapFile.lese( (char *)& runns, 1 );
+        mapFile.lese( (char *)& farbe, 4 );
+        char len;
+        mapFile.lese( (char *)& len, 1 );
+        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 ) );
+        delete[] name;
+    }
+    // Tunnel
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        int zielX;
+        int zielY;
+        bool aktiv;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        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 ) );
+    }
+    // Umlenkungen
+    mapFile.lese( (char *)& anz, 4 );
+    for( int i = 0; i < anz; i++ )
+    {
+        int x;
+        int y;
+        int breite;
+        int height;
+        char richtung;
+        int maxAbklingzeit;
+        bool drehend;
+        bool aktiv;
+        mapFile.lese( (char *)& x, 4 );
+        mapFile.lese( (char *)& y, 4 );
+        mapFile.lese( (char *)& breite, 4 );
+        mapFile.lese( (char *)& height, 4 );
+        mapFile.lese( (char *)& richtung, 1 );
+        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 ) );
+    }
+    // Trigger
+    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;
+        int ereignisAnzahl;
+        int bedingungAnzahl;
+        int aktionAnzahl;
+        mapFile.lese( (char *)& ereignisAnzahl, 4 );
+        mapFile.lese( (char *)& bedingungAnzahl, 4 );
+        mapFile.lese( (char *)& aktionAnzahl, 4 );
+        EreignisTyp *ereignisse = new EreignisTyp[ ereignisAnzahl ];
+        for( int j = 0; j < ereignisAnzahl; j++ )
+            mapFile.lese( (char *)& ereignisse[ j ], 4 );
+        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 >();
+        for( int j = 0; j < aktionAnzahl; j++ )
+            aktionen->add( readAktion( mapFile ) );
+        zSpiel->addTrigger( new Trigger( name, ereignisAnzahl, ereignisse, bedingungen, aktionen ) );
+        delete[] name;
+    }
+    mapFile.close();
+}
+
+// Reference Counting
+MapReader * MapReader::getThis()
+{
+    ref++;
+    return this;
+}
+
+MapReader *MapReader::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Reader.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <Datei.h>
+#include <Vec2.h>
+#include "Team.h"
+#include "SpielKlasse.h"
+
+class Spiel;
+class Aktion;
+
+class MapReader
+{
+private:
+    SSDatenbankV *db;
+    Text *pfad;
+    int karteId;
+    int ref;
+
+    Aktion *readAktion( Datei &dat );
+
+public:
+    // Konstruktor
+    MapReader( int karteId, SSDatenbankV *db, char *tmpPfad );
+    // Destruktor
+    ~MapReader();
+    // nicht constant
+    void ladeKarte( Spiel *zSpiel );
+    // Reference Counting
+    MapReader *getThis();
+    MapReader *release();
+};

StickmanWorldOnline/SSKlient.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <Array.h>
+#include <Vec2.h>
+#include "SSKlientV.h"
+
+class Spieler;
+class SpielerStatistik;
+class TeamStatistik;
+
+class Klient
+{
+private:
+    SSKlientV *klient;
+    int ref;
+
+public:
+    // Konstruktor
+    Klient( SSKlientV *klient );
+    // Destruktor
+    ~Klient();
+    // nicht constant
+    void offline();
+    void online( SSKlientV *zKlient );
+    void sendeInit( RCArray< Spieler > *zSpieler, int spielZeit );
+    void sendeSpielerNummer( int sNum, int spielZeit );
+    void sendeStart( int spielZeit );
+    void sendeTastaturStatus( int spielerId, char taste, bool aktiv, int spielZeit );
+    void sendeSpielEnde( char gewonnen, int spielZeit );
+    void sendeChatNachricht( char *txt, int spielZeit );
+    void sendeStatistikChatNachricht( int vonAccount, char *txt );
+    void sendeStatistikSpielerOffline( int account );
+    void sendeSpielerStatistik( SpielerStatistik *zS );
+    void sendeTeamStatistik( TeamStatistik *zS );
+    void sendeStatistikLadenFertig();
+    // constant
+    bool istOnline() const;
+    // reference Counting
+    Klient *getThis();
+    Klient *release();
+};

StickmanWorldOnline/Schalter.h

@@ -5,6 +5,8 @@
 class Schalter : public GameObject
 {
 private:
+    static int nextId;
+    int id;
     bool aktiv = true;
     int aktivierungen = 0;
 

StickmanWorldOnline/Spiel.cpp

@@ -0,0 +1,321 @@
+#include "Spiel.h"
+
+#define TICK 0.03333333
+
+// Konstruktor
+Spiel::Spiel()
+{
+    isRunning = 0;
+    log = 0;
+    spielerAnzahl = 0;
+    zAccounts = 0;
+    spielId = 0;
+    karteId = 0;
+    pause = 0;
+    gameTicks = 0;
+    ende = 1;
+    stat = new Statistik();
+    ref = 1;
+}
+
+// Destruktor
+Spiel::~Spiel()
+{
+    stat->release();
+    if( psqldb )
+        psqldb->release();
+}
+
+// nicht constant
+void Spiel::setPSQLK( SSDatenbankV *psqldb )
+{
+    if( this->psqldb )
+        this->psqldb->release();
+    this->psqldb = psqldb;
+    stat->setPSQLDB( psqldb->getThis() );
+}
+// call 1
+void Spiel::setSpielId( int id )
+{
+    spielId = id;
+    stat->setSpielId( id );
+}
+// call 2
+void Spiel::setKarteId( int karteId )
+{
+    this->karteId = karteId;
+    stat->setKarteId( karteId );
+}
+// call 3
+void Spiel::setTempPfad( char *pfad )
+{
+    mapPfad = pfad;
+    mapPfad += "/";
+}
+// call 3.5
+void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
+{
+    this->zAccounts = zAccounts->getThis();
+    spielerAnzahl = anzahl;
+}
+// call 4
+void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
+{
+    this->zKlients = zKlients->getThis();
+}
+// call 5
+void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
+{
+    MapReader *reader = new MapReader( karteId, psqldb->getThis(), mapPfad );
+    reader->ladeKarte( this );
+    reader->release();
+    for( int i = 0; i < anzahl; i++ )
+    {
+        for( auto s = spieler.getIterator(); s; s++ )
+        {
+            if( s->getSpielerNummer() == spielerNummern->get( i ) )
+            {
+                s->setAccount( zAccounts->get( i ) );
+                s->setKlient( new Klient( zKlients->get( i ) ) );
+                break;
+            }
+        }
+    }
+    zAccounts = zAccounts->release();
+    zKlients = zKlients->release();
+    stat->setTeams( spielerAnzahl, &teams );
+    stat->setSpieler( spielerAnzahl, &spieler );
+}
+// call 6
+void Spiel::run()
+{
+    log = new Datei();
+    Text *pfad = new Text( "../spiel log/" );
+    pfad->append( spielId );
+    pfad->append( "/verlauf.ksggl" );
+    log->setDatei( pfad );
+    log->remove();
+    log->erstellen();
+    log->open( Datei::Style::schreiben );
+    time_t t;
+    time( &t );
+    srand( (unsigned int)t );
+    log->schreibe( (char *)& spielerAnzahl, 4 );
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        Spieler *tmp = spieler.z( i );
+        if( tmp && tmp->zKlient() )
+        {
+            tmp->zKlient()->sendeInit( &spieler, -1 );
+            log->schreibe( (char *)& i, 4 );
+            int sNum = tmp->getSpielerNummer();
+            log->schreibe( (char *)& sNum, 4 );
+            tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
+            Text * name = psqldb->getAccountRufName( tmp->getAccountId() );
+            char len = (char)( name ? name->getLength() : 0 );
+            log->schreibe( &len, 1 );
+            if( len )
+                log->schreibe( name->getText(), len );
+            if( name )
+                name->release();
+        }
+    }
+    __int64 randSeed = randG.getSeed();
+    log->schreibe( (char *)& randSeed, 8 );
+    Array< char > spielerStatus;
+    ZeitMesser * zeit = new ZeitMesser();
+    zeit->messungStart();
+    isRunning = 1;
+    ende = 0;
+    double ausgleich = 0;
+    double sZ = 0;
+    gameTicks = -1;
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        Spieler *tmp = spieler.z( i );
+        if( tmp && tmp->zKlient() )
+            tmp->zKlient()->sendeStart( gameTicks );
+    }
+    double rZeit = 0;
+    while( !ende )
+    {
+        zeit->messungEnde();
+        zeit->messungStart();
+        double z = zeit->getSekunden();
+        ausgleich += TICK - z;
+        if( ausgleich > 0 )
+            Sleep( (int)( ausgleich * 1000 ) );
+        rZeit += z;
+        while( sZ + TICK < rZeit && !ende )
+        {
+            c.lock();
+            sZ += TICK;
+            gameTicks++;
+            char ch = 0;
+            log->schreibe( &ch, 1 );
+            tick( TICK );
+            c.unlock();
+        }
+    }
+    zeit->messungEnde();
+    zeit->release();
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler.z( i ) && spieler.z( i )->zKlient() )
+        {
+            if( !spieler.z( i )->zTeam()->getPunkte() )
+            {
+                spielerStatus.set( 1, i ); // Datenbank Verloren
+                spieler.z( i )->zKlient()->sendeSpielEnde( 0, 0 );
+            }
+            else
+            {
+                spielerStatus.set( 2, i ); // Datenbank Gewonnen
+                spieler.z( i )->zKlient()->sendeSpielEnde( 1, 0 );
+            }
+        }
+        if( spieler.z( i ) && ( !spieler.z( i )->zKlient() || !spieler.z( i )->zKlient()->istOnline() ) )
+            spielerStatus.set( 3, i );
+    }
+    psqldb->setSpielStatusBeendet( spielId, 5 );
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        Spieler *tmp = spieler.z( i );
+        if( tmp )
+        {
+            psqldb->setSpielSpielerStatus( spielId, tmp->getAccountId(), tmp->getPunkte(), spielerStatus.get( i ) );
+            psqldb->addSpielerStatistik( tmp->getAccountId(), spielId );
+        }
+    }
+    log->close();
+    log = log->release();
+    isRunning = 0;
+}
+// call 7
+void Spiel::klientOffline( int accountId )
+{
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler.z( i )->getAccountId() == accountId )
+            spieler.z( i )->zKlient()->offline();
+    }
+}
+
+void Spiel::klientOnline( int accountId, SSKlientV *zKlient )
+{
+    for( int i = 0; i < spielerAnzahl; i++ )
+    {
+        if( spieler.z( i )->getAccountId() == accountId )
+        {
+            c.lock();
+            Spieler *s = spieler.z( i );
+            Klient *tmp = s->zKlient();
+            tmp->online( zKlient );
+            tmp->sendeSpielerNummer( s->getSpielerNummer(), 0 );
+            //--------------------------
+            c.unlock();
+        }
+    }
+}
+
+void Spiel::nachricht( int accountId, int len, char *bytes )
+{
+
+}
+
+void Spiel::setPausiert( bool pausiert )
+{
+    this->pause = pausiert;
+}
+
+void Spiel::tick( double zeit )
+{
+
+}
+
+void Spiel::addVariable( const char *name, Variable *var )
+{
+    bool found = 0;
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->zName()->istGleich( name ) )
+        {
+            found = 1;
+            break;
+        }
+    }
+    if( !found )
+        variablen.add( new VarPointer( name, var ) );
+    else
+        var->release();
+}
+
+void Spiel::setVariable( const char *name, Variable *var )
+{
+    bool found = 0;
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->zName()->istGleich( name ) )
+        {
+            v->setVariable( var );
+            break;
+        }
+    }
+    if( !found )
+        var->release();
+}
+
+void Spiel::addTeam( Team *team )
+{
+    teams.add( team );
+}
+
+void Spiel::addSpieler( Spieler *spieler )
+{
+    this->spieler.add( spieler );
+}
+
+Variable *Spiel::getVariable( const char *name ) const
+{
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->zName()->istGleich( name ) )
+            return v->getVariable();
+    }
+    return 0;
+}
+
+Variable *Spiel::zVariable( const char *name ) const
+{
+    for( auto v = variablen.getIterator(); v; v++ )
+    {
+        if( v->zName()->istGleich( name ) )
+            return v->zVariable();
+    }
+    return 0;
+}
+
+bool Spiel::istPausiert() const
+{
+    return pause;
+}
+
+// constant
+StatistikV *Spiel::getStatistik() const
+{
+    return stat->getThis();
+}
+
+// Reference Counting 
+SpielKlasse *Spiel::getThis()
+{
+    ref++;
+    return this;
+}
+
+SpielKlasse *Spiel::release()
+{
+    if( !--ref )
+        delete this;
+    return 0;
+}

StickmanWorldOnline/Spiel.h

@@ -1,7 +1,21 @@
 #pragma once
 
 #include "SpielKlasse.h"
+#include "Variablen.h"
+#include "Trigger.h"
+#include "Bariere.h"
+#include "Base.h"
+#include "Drop.h"
+#include "Geschoss.h"
+#include "Umlenkung.h"
+#include "Tunnel.h"
+#include "Schiene.h"
+#include "Schalter.h"
+#include "Statistik.h"
+#include "Reader.h"
+#include <Critical.h>
 #include <Datei.h>
+#include <Random.h>
 
 class Statistik;
 class StatistikV;
@@ -9,6 +23,36 @@ class StatistikV;
 class Spiel : public SpielKlasse
 {
 private:
+    bool isRunning;
+    RandomGenerator randG;
+    SSDatenbankV *psqldb;
+    RCArray< SSKlientV > *zKlients;
+    RCArray< VarPointer > variablen;
+    RCArray< Spieler > spieler;
+    RCArray< Team > teams;
+    RCArray< Bariere > bariere;
+    RCArray< Base > basen;
+    RCArray< Drop > drops;
+    RCArray< Gegenstand > gegenstand;
+    RCArray< Geschoss > shots;
+    RCArray< Schalter > schalter;
+    RCArray< Schiene > schiene;
+    RCArray< Timer > timer;
+    RCArray< Tunnel > tunnel;
+    RCArray< Umlenkung > umlenkung;
+    RCArray< Trigger > trigger;
+    RCArray< TriggerRun > triggerRuns;
+    Array< int > *zAccounts;
+    Statistik *stat;
+    Text mapPfad;
+    Critical c;
+    Datei *log;
+    bool ende;
+    int spielerAnzahl;
+    int spielId;
+    int karteId;
+    int gameTicks;
+    bool pause;
     int ref;
 
 public:
@@ -24,12 +68,34 @@ public:
     void setAccounts( int anzahl, Array< int > *zAccounts ) override; // call 4
     void setKlients( int anzahl, RCArray< SSKlientV > *zKlients ) override; // call 5
     void setSpielerNummern( int anzahl, Array< int > *spielerNummern ) override; // call 6
+    void run() override; // call 7
     void klientOffline( int accountId ) override;
     void klientOnline( int accountId, SSKlientV *zKlient ) override;
     void nachricht( int accountId, int len, char *bytes ) override;
+
+    void setPausiert( bool pausiert );
     void tick( double zeit );
-    void run() override; // call 7
-                // constant
+    void addVariable( const char *name, Variable *var );
+    void setVariable( const char *name, Variable *var );
+    void addTeam( Team *team );
+    void addSpieler( Spieler *spieler );
+    void addBariere( Bariere *bariere );
+    void addBase( Base *base );
+    void addDrop( Drop *drop );
+    void addGegenstand( Gegenstand *gegenstand );
+    void addGeschoss( Geschoss *geschoss );
+    void addSchalter( Schalter *schalter );
+    void addSchiene( Schiene *schiene );
+    void addTimer( Timer *timer );
+    void addTunnel( Tunnel *tunnel );
+    void addUmlenkung( Umlenkung *umlenkung );
+    void addTrigger( Trigger *trigger );
+    void addTriggerRun( TriggerRun *tRun );
+    Team *getTeam( int id ) const;
+    Variable *getVariable( const char *name ) const;
+    Variable *zVariable( const char *name ) const;
+    bool istPausiert() const;
+    // constant
     StatistikV *getStatistik() const override;
     // Reference Counting 
     SpielKlasse *getThis() override;

StickmanWorldOnline/Spieler.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "GameObject.h"
 #include "Team.h"
 #include "Gegenstand.h"
+#include "SSKlient.h"
 
 class Spieler : public GameObject
 {
@@ -19,6 +19,8 @@ public:
         const static int ENTERHAKEN_UNVERWUNDBAR = 0x40;
     };
 private:
+    Klient *klient;
+    int accountId;
     int spielerNummer;
     Team *team;
     int style;
@@ -38,7 +40,7 @@ private:
     int armor;
     int schadensBonus;
     int lebensraub;
-    int lebensregeneration;
+    int lebensRegeneration;
     int abklingZeitVerringerung;
     int color;
     float gegenstandAbklingzeit[ ITEMANZAHL ];
@@ -57,7 +59,18 @@ private:
     int geschosseGeschossen;
 
 public:
-    Spieler( int id, Team *team, int spawnX, int spawnY, int breite, int height );
+    Spieler( int id, Team *team, int spawnX, int spawnY, int breite, int height, 
+             int farbe, int leben, int erfahrung, int laufTempo, int geschossTempo,
+             int armor, int schadenBonus, int lebensraub, int lebensReg,
+             int abkVerringerung, int level );
     ~Spieler();
-
+    void setTeam( Team *team );
+    void setAccount( int id );
+    void setKlient( Klient *klient );
+    Klient *zKlient() const;
+    int getSpielerNummer() const;
+    Team *zTeam() const;
+    int getFarbe() const;
+    int getAccountId() const;
+    int getPunkte() const;
 };

StickmanWorldOnline/SpielerStatistik.h

@@ -0,0 +1,6 @@
+#pragma once
+
+class SpielerStatistik
+{
+
+};

StickmanWorldOnline/Statistik.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "StatistikKlasse.h"
+#include "SSDatenbankV.h"
+#include "Spieler.h"
+#include "SpielerStatistik.h"
+#include "TeamStatistik.h"
+
+class Statistik : public StatistikV
+{
+private:
+    int spielId;
+    int karteId;
+    SSDatenbankV *db;
+    int spielerAnzahl;
+    RCArray< Spieler > *spieler;
+    bool erstellt;
+    Array< bool > *sOnline;
+    Array< bool > *sBereit;
+    RCArray< SpielerStatistik > *gss;
+    RCArray< TeamStatistik > *gts;
+    RCArray< Text > *teamNamen;
+    int gewinnerTeam;
+    int ref;
+
+    void sendeStatistik( int index );
+
+public:
+    // Konstruktor
+    Statistik();
+    // Destruktor
+    ~Statistik();
+    // nicht constant
+    void setSpielId( int id );
+    void setKarteId( int id );
+    void setPSQLDB( SSDatenbankV *db );
+    void spielEnde( int team );
+    void setTeams( int anzahl, RCArray< Team > *zTeams );
+    void setSpieler( int anzahl, RCArray< Spieler > *zSpieler );
+    virtual void klientOffline( int accountId );
+    virtual void statistikAnfrage( int accountId, short len, char *bytes );
+    virtual void run();
+    // Reference Counting
+    virtual StatistikV *getThis();
+    virtual StatistikV *release();
+};

StickmanWorldOnline/StickmanWorldOnline.vcxproj

@@ -78,11 +78,18 @@
   </PropertyGroup>
   <ItemGroup>
     <ClCompile Include="DllStart.cpp" />
+    <ClCompile Include="Reader.cpp" />
+    <ClCompile Include="Spiel.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Aktionen.h" />
     <ClInclude Include="Geschoss.h" />
+    <ClInclude Include="Reader.h" />
     <ClInclude Include="Spieler.h" />
+    <ClInclude Include="SpielerStatistik.h" />
+    <ClInclude Include="SSKlient.h" />
+    <ClInclude Include="Statistik.h" />
+    <ClInclude Include="TeamStatistik.h" />
     <ClInclude Include="Trigger.h" />
     <ClInclude Include="Bariere.h" />
     <ClInclude Include="Base.h" />

StickmanWorldOnline/StickmanWorldOnline.vcxproj.filters

@@ -25,11 +25,20 @@
     <Filter Include="Spiel\System">
       <UniqueIdentifier>{214ae990-4b8e-4fad-a428-7f6f31c33648}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Spiel\Karte">
+      <UniqueIdentifier>{22733a3e-50b6-403e-9144-ec2d224435cc}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="DllStart.cpp">
       <Filter>Start</Filter>
     </ClCompile>
+    <ClCompile Include="Spiel.cpp">
+      <Filter>Spiel</Filter>
+    </ClCompile>
+    <ClCompile Include="Reader.cpp">
+      <Filter>Spiel\Karte</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="SpielKlasse.h">
@@ -104,5 +113,20 @@
     <ClInclude Include="Geschoss.h">
       <Filter>Spiel\System</Filter>
     </ClInclude>
+    <ClInclude Include="Reader.h">
+      <Filter>Spiel\Karte</Filter>
+    </ClInclude>
+    <ClInclude Include="Statistik.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="SpielerStatistik.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="TeamStatistik.h">
+      <Filter>Statistik</Filter>
+    </ClInclude>
+    <ClInclude Include="SSKlient.h">
+      <Filter>Netzwerk</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>

StickmanWorldOnline/Team.h

@@ -2,7 +2,7 @@
 
 #include "Variablen.h"
 
-class Team : Variable
+class Team : public Variable
 {
 private:
     int maxWiederbelebungsZeit;
@@ -11,17 +11,23 @@ private:
     int punkte;
     int teamnummer;
     int spielerAnzahl;
+    int maxSpielerAnzahl;
+    int farbe;
+    Text name;
 
 public:
-    Team( int id, int spielerAnzahl, int punkte, int maxWiederbelebungZeit );
-    void setMaxWiederbelebungsZeit( int sekunden ) const;
-    void addTod() const;
-    void addKill() const;
-    void addPunkte( int punkte ) const;
+    Team( int id, int maxSpielerAnzahl, int punkte, int maxWiederbelebungZeit, int farbe, const char *name );
+    void setMaxWiederbelebungsZeit( int sekunden );
+    void addSpieler();
+    void addTod();
+    void addKill();
+    void addPunkte( int punkte );
+    Text getName() const;
     int getMaxWiederbelebungsZeit() const;
     int getTode() const;
     int getKills() const;
     int getPunkte() const;
     int getTeamNummer() const;
     int getSpielerAnzahl() const;
+    int getFarbe() const;
 };

StickmanWorldOnline/TeamStatistik.h

@@ -0,0 +1,6 @@
+#pragma once
+
+class TeamStatistik
+{
+
+};

StickmanWorldOnline/Timer.h

@@ -5,6 +5,8 @@
 class Timer : public GameObject
 {
 private:
+    static int nextId;
+    int id;
     Text name;
     bool runns;
     bool pause;

StickmanWorldOnline/Trigger.h

@@ -7,6 +7,7 @@
 using namespace Framework;
 
 class TriggerRun;
+class Spiel;
 
 class VarPointer
 {
@@ -18,6 +19,7 @@ private:
 public:
     VarPointer( const char *name, Variable *var );
     ~VarPointer();
+    Text *zName() const;
     void setVariable( Variable *var );
     Variable *getVariable() const;
     Variable *zVariable() const;
@@ -26,23 +28,6 @@ public:
     VarPointer *release();
 };
 
-class Memory
-{
-private:
-    RCArray< VarPointer > variablen;
-    int ref;
-
-public:
-    Memory();
-    ~Memory();
-    void addVariable( const char *name, Variable *var );
-    void setVariable( const char *name, Variable *var );
-    Variable *getVariable( const char *name ) const;
-    Variable *zVariable( const char *name ) const;
-    Memory *getThis();
-    Memory *release();
-};
-
 class Bedingung
 {
 private:
@@ -50,10 +35,10 @@ private:
     int ref;
 
 public:
-    Bedingung();
+    Bedingung( Aktion *expression );
     ~Bedingung();
     void setExpression( Aktion *expr );
-    bool check( Memory *zMem, Ereignis *zEreignis );
+    bool check( Spiel *zSpiel, Ereignis *zEreignis );
     Bedingung *getThis();
     Bedingung *release();
 };
@@ -61,13 +46,16 @@ public:
 class Trigger : public Variable
 {
 private:
+    static int nextId;
+    int id;
+    Text name;
     int ereignisAnzahl;
     EreignisTyp *ereignisse;
     RCArray< Bedingung > *bedingungen;
     RCArray< Aktion > *aktionen;
 
 public:
-    Trigger();
+    Trigger( const char *name, int ereignisAnzahl, EreignisTyp *ereignisse, RCArray< Bedingung > *bedingungen, RCArray< Aktion > *aktionen );
     ~Trigger();
     int getAktionAnzahl() const;
     Aktion *zAktion( int index ) const;
@@ -75,7 +63,7 @@ public:
     // 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, Memory *mem );
+    TriggerRun *runTrigger( Ereignis *e, Spiel *zSpiel );
 };
 
 class TriggerRun
@@ -83,14 +71,16 @@ class TriggerRun
 private:
     Trigger *trigger;
     Ereignis *ereignis;
-    Memory *memory;
+    Spiel *spiel;
     int programCounter;
     double waitCount;
     int ref;
 
 public:
-    TriggerRun( Trigger *trig, Ereignis *e, Memory *mem );
+    TriggerRun( Trigger *trig, Ereignis *e, Spiel *spiel );
     ~TriggerRun();
     // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
     bool runNext( double t );
+    TriggerRun *getThis();
+    TriggerRun *release();
 };

StickmanWorldOnline/Tunnel.h

@@ -5,6 +5,8 @@
 class Tunnel : public GameObject
 {
 private:
+    static int nextId;
+    int id;
     bool aktiv;
     int benutzt;
     int zielX;

StickmanWorldOnline/Umlenkung.h

@@ -5,6 +5,8 @@
 class Umlenkung : public GameObject
 {
 private:
+    static int nextId;
+    int id;
     Richtung richtung;
     bool drehend;
     bool aktiv;