Changeset 6800

Timestamp:

Apr 29, 2010, 1:16:16 PM (15 years ago)

Author:

dafrick

Message:

Created a new class of triggers called Multitriggers.
MultiTriggers are triggers which (as opposed to normal triggers) have a state for each object triggering the MultiTrigger, that means, that a MultiTrigger can be triggered for two different Players, while not being triggered for a third.
To go with this MultiTrigger I created a data structure (MultitriggerContainer), which helps relaying important information to the objects, that receive the Events of the trigger.
Also there is a MultiDistanceTrigger, which is just the DistanceTrigger as a MultiTrigger.

To make this work I had to make some adjustements to the eventsystem, namely an EventState can now be either an EventState (as it was before) or an EventSink, which means that every efent arriving at the EventState is processed as opposed to just the ones which change the state.
There is a new makro (XMLPortEventSink) to create an EventState with sink behaviour. It can be used exacly as the XMLPortEventState makro.

Location:

code/trunk/src

Files:

• libraries/core/BaseObject.cc (modified) (2 diffs)
• libraries/core/BaseObject.h (modified) (1 diff)
• libraries/core/Event.cc (modified) (5 diffs)
• libraries/core/Event.h (modified) (3 diffs)
• libraries/core/EventIncludes.h (modified) (1 diff)
• modules/objects/ObjectsPrereqs.h (modified) (1 diff)
• modules/objects/eventsystem/EventListener.cc (modified) (1 diff)
• modules/objects/triggers/CMakeLists.txt (modified) (1 diff)
• modules/objects/triggers/DistanceMultiTrigger.cc (added)
• modules/objects/triggers/DistanceMultiTrigger.h (added)
• modules/objects/triggers/MultiTrigger.cc (added)
• modules/objects/triggers/MultiTrigger.h (added)
• modules/objects/triggers/MultiTriggerContainer.cc (added)
• modules/objects/triggers/MultiTriggerContainer.h (added)
• modules/questsystem/CMakeLists.txt (modified) (1 diff)
• modules/questsystem/QuestEffectBeacon.cc (modified) (5 diffs)
• modules/questsystem/QuestEffectBeacon.h (modified) (1 diff)

code/trunk/src/libraries/core/BaseObject.cc

@@ -103 +103 @@
         }
     }
+    
+    /** @brief Adds an object which listens to the events of this object. */
+    void BaseObject::registerEventListener(BaseObject* object)
+    {
+        COUT(4) << "New EventListener: " << object->getIdentifier()->getName() << " &(" << object << ")." << std::endl;
+        this->eventListeners_.insert(object);
+    }
 
     /**
@@ -356 +363 @@
     {
         this->registerEventStates();
+        
+        COUT(4) << this->getIdentifier()->getName() << " (&" << this << ") processing event. originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << "." << std::endl;
 
         std::map<std::string, EventState*>::const_iterator it = this->eventStates_.find(event.statename_);

code/trunk/src/libraries/core/BaseObject.h

@@ -188 +188 @@
         private:
             /** @brief Adds an object which listens to the events of this object. */
-            inline void registerEventListener(BaseObject* object)
-                { this->eventListeners_.insert(object); }
+            void registerEventListener(BaseObject* object);
             /** @brief Removes an event listener from this object. */
             inline void unregisterEventListener(BaseObject* object)

code/trunk/src/libraries/core/Event.cc

@@ -59 +59 @@
         this->bProcessingEvent_ = true;
 
+        COUT(4) << "Processing event (EventState) : originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << "), activate: " << event.activate_ << ", name: " << event.name_ << ", statename: " << event.statename_ << ", object: " << object->getIdentifier()->getName() << " (&" << object << ")" << ", subclass: " << this->subclass_->getName() << ", (?): " << event.originator_->isA(this->subclass_) << "." << std::endl;
+        
         // check if the originator is an instance of the requested class
         if (event.originator_->isA(this->subclass_))
         {
+            // If the EventState doesn't act as an EventSink.
             // actualize the activationcounter
-            if (event.activate_)
-                ++this->activeEvents_;
-            else
+            if(!this->bSink_)
             {
-                --this->activeEvents_;
+                if (event.activate_)
+                    ++this->activeEvents_;
+                else
+                {
+                    --this->activeEvents_;
 
-                if (this->activeEvents_ < 0)
-                    this->activeEvents_ = 0;
+                    if (this->activeEvents_ < 0)
+                        this->activeEvents_ = 0;
+                }
             }
 
@@ -78 +84 @@
                 (*this->statefunction_)();
             }
-            else if ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_))
+            else if (this->bSink_ || (!this->bSink_ && ((this->activeEvents_ == 1 && event.activate_) || (this->activeEvents_ == 0 && !event.activate_)) ) )
             {
                 // if the eventfunction needs a state, we just call the function if the state changed from 0 to 1 (state = true) or from 1 to 0 (state = false) [but not if activeEvents_ is > 1]
@@ -84 +90 @@
                 {
                     // one argument: just the eventstate
-                    (*this->statefunction_)(this->activeEvents_);
+                    (*this->statefunction_)(event.activate_);
                 }
                 else if (this->statefunction_->getParamCount() >= 2)
@@ -92 +98 @@
                     {
                         // if the subclass is BaseObject, we don't have to cast the pointer
-                        (*this->statefunction_)(this->activeEvents_, event.originator_);
+                        (*this->statefunction_)(event.activate_, event.originator_);
                     }
                     else
@@ -98 +104 @@
                         // else cast the pointer to the desired class
                         void* castedOriginator = event.originator_->getDerivedPointer(this->subclass_->getClassID());
-                        (*this->statefunction_)(this->activeEvents_, castedOriginator);
+                        (*this->statefunction_)(event.activate_, castedOriginator);
                     }
                 }

code/trunk/src/libraries/core/Event.h

@@ -46 +46 @@
         BaseObject* originator_; //!< The object which triggered this event
         std::string name_;       //!< The name of this event
+
     };
 
@@ -66 +67 @@
     {
         public:
-            EventState(Functor* statefunction, Identifier* subclass) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass) {}
+            EventState(Functor* statefunction, Identifier* subclass, bool bSink = false) : bProcessingEvent_(false), activeEvents_(0), statefunction_(statefunction), subclass_(subclass), bSink_(bSink) {}
             virtual ~EventState();
 
@@ -79 +80 @@
             Functor*    statefunction_;     //!< A functor to set the state
             Identifier* subclass_;          //!< Originators must be an instance of this class (usually BaseObject, but some statefunctions allow a second argument with an originator of a specific class)
+            bool        bSink_;             //!< Determines whether the EventState acts as an EventSink forwarding any Event (even if the state didn't change) or in the normal manner, only processing Events that change the state.
     };
 }

code/trunk/src/libraries/core/EventIncludes.h

@@ -52 +52 @@
     } \
     XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
+    
+#define XMLPortEventSink(classname, subclassname, statename, function, xmlelement, mode) \
+    orxonox::EventState* containername##function = this->getEventState(statename); \
+    if (!containername##function) \
+    { \
+        containername##function = new orxonox::EventState(orxonox::createFunctor(&classname::function, this), orxonox::ClassIdentifier<subclassname>::getIdentifier(), true); \
+        this->addEventState(statename, containername##function); \
+    } \
+    XMLPortEventStateIntern(xmlportevent##function, classname, statename, xmlelement, mode)
 
 /**
-    @brief Like XMLPortEventState but with additional template arguments to identify the function of the state (if ambiguous).
+    @brief Like XMLPortEventState but creates an event sink instead of an event state.
+           The most important destinction between an EventState and an EventSink is, that an EventState only processes event which change the state of the EventState, where as an EventSink is an EventState that processes any Event that reaches it.
 */
 #define XMLPortEventStateTemplate(classname, subclassname, statename, function, xmlelement, mode, ...) \

code/trunk/src/modules/objects/ObjectsPrereqs.h

@@ -85 +85 @@
     // triggers
     class CheckPoint;
+    class DistanceMultiTrigger;
     class DistanceTrigger;
     class EventTrigger;
+    class MultiTrigger;
+    class MultiTriggerContainer;
     class Trigger;
 }

code/trunk/src/modules/objects/eventsystem/EventListener.cc

@@ -61 +61 @@
             return;
         }
+        
+        COUT(4) << "EventListener: Processing event: originator: " << event.originator_->getIdentifier()->getName() << " (&" << event.originator_ << ")" << ", activate: " << event.activate_ << ", name: " << event.name_ << std::endl;
 
         this->bActive_ = true;

code/trunk/src/modules/objects/triggers/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(OBJECTS_SRC_FILES
-  Trigger.cc
+  CheckPoint.cc
+  DistanceMultiTrigger.cc
   DistanceTrigger.cc
   EventTrigger.cc
-  CheckPoint.cc
+  MultiTrigger.cc
+  MultiTriggerContainer.cc
+  Trigger.cc
 )

code/trunk/src/modules/questsystem/CMakeLists.txt

@@ -34 +34 @@
   LINK_LIBRARIES
     orxonox
+    objects
     overlays
   SOURCE_FILES ${QUESTSYSTEM_SRC_FILES}

code/trunk/src/modules/questsystem/QuestEffectBeacon.cc

@@ -39 +39 @@
 #include "worldentities/pawns/Pawn.h"
 #include "interfaces/PlayerTrigger.h"
+#include "objects/triggers/MultiTriggerContainer.h"
 #include "QuestEffect.h"
 
@@ -75 +76 @@
         XMLPortObject(QuestEffectBeacon, QuestEffect, "effects", addEffect, getEffect, xmlelement, mode);
 
-        XMLPortEventState(QuestEffectBeacon, PlayerTrigger, "execute", execute, xmlelement, mode);
+        XMLPortEventState(QuestEffectBeacon, BaseObject, "execute", execute, xmlelement, mode); //TODO: Change BaseObject to MultiTrigger as soon as MultiTrigger is the base of all triggers.
 
         COUT(3) << "New QuestEffectBeacon created." << std::endl;
@@ -84 +85 @@
         SUPER(QuestEffectBeacon, XMLEventPort, xmlelement, mode);
 
-        XMLPortEventState(QuestEffectBeacon, PlayerTrigger, "execute", execute, xmlelement, mode);
+        XMLPortEventSink(QuestEffectBeacon, BaseObject, "execute", execute, xmlelement, mode);
     }
 
@@ -92 +93 @@
         This means extracting the Pawn from the PlayerTrigger, provided by the Event causing the execution, and the extracting the PlayerInfo from the received Pawn and invoking the QuestEffectbeacon's QuestEffects on the received PlayerInfo.
     @param trigger
-        Apointer to the PlayerTrigger that threw the Event.
+        A pointer to the PlayerTrigger that threw the Event.
     @return
         Returns true if successfully executed, false if not.
     */
-    bool QuestEffectBeacon::execute(bool b, PlayerTrigger* trigger)
-    {
+    bool QuestEffectBeacon::execute(bool b, BaseObject* trigger)
+    {
+        //TODO: Remove debug output.
+        COUT(1) << "Debug: Calling execute on QuestEffectBeacon." << std::endl;
+        
         if(!b)
         {
@@ -108 +112 @@
         }
 
-        if(!trigger->isForPlayer()) //!< The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
-        {
-            return false;
-        }
-
-        //! Extracting the Pawn from the PlayerTrigger.
-        Pawn* pawn = trigger->getTriggeringPlayer();
+        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
+        MultiTriggerContainer* mTrigger = orxonox_cast<MultiTriggerContainer*>(trigger);
+        Pawn* pawn = NULL;
+        
+        //! If the trigger is neither a Playertrigger nor a MultiTrigger (i.e. a MultitriggerContainer) we can do anything with it.
+        if(pTrigger == NULL && mTrigger == NULL)
+            return false;
+        
+        // If the trigger is a PlayerTrigger.        
+        if(pTrigger != NULL)
+        {
+            if(!pTrigger->isForPlayer())  //!< The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
+                return false;
+            else
+                pawn = pTrigger->getTriggeringPlayer();
+        }
+        
+        // If the trigger is a MultiTrigger (i.e. a MultiTriggerContainer)
+        if(mTrigger != NULL)
+        {
+            pawn = orxonox_cast<Pawn*>(mTrigger->getData());
+        }
 
         if(pawn == NULL)

code/trunk/src/modules/questsystem/QuestEffectBeacon.h

@@ -88 +88 @@
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode);
 
-            bool execute(bool b, PlayerTrigger* trigger); //!< Executes the QuestEffects of the QuestEffectBeacon.
+            bool execute(bool b, BaseObject* trigger); //!< Executes the QuestEffects of the QuestEffectBeacon.
 
             /**