Changeset 7474 for code/trunk/src/modules

Timestamp:

Sep 21, 2010, 11:15:44 PM (14 years ago)

Author:

dafrick

Message:

Synchronizing Notifications.
In the course of that, notifications are not longer sent by creating a Notification and the calling notification.send() bur by letting the NotificationManager handle all this: NotificationManager::getInstance().sendNotification(message)
This made QuestNotification obsolete, thus it was removde.

Also did some work on synchronizing the Script class. It should work properly most of the time, but the current solution is unreliable and unsatisfactory. So this will change as soon as I know how.

Location:

code/trunk/src/modules

Files:

• notifications/Notification.cc (modified) (4 diffs)
• notifications/Notification.h (modified) (1 diff)
• notifications/NotificationDispatcher.cc (modified) (6 diffs)
• notifications/NotificationDispatcher.h (modified) (3 diffs)
• notifications/NotificationManager.cc (modified) (3 diffs)
• notifications/NotificationManager.h (modified) (1 diff)
• notifications/dispatchers/CommandNotification.cc (modified) (2 diffs)
• notifications/dispatchers/CommandNotification.h (modified) (2 diffs)
• notifications/dispatchers/SimpleNotification.cc (modified) (1 diff)
• objects/Script.cc (modified) (8 diffs)
• objects/Script.h (modified) (6 diffs)
• questsystem/CMakeLists.txt (modified) (1 diff)
• questsystem/QuestDescription.cc (modified) (2 diffs)
• questsystem/QuestDescription.h (modified) (1 diff)
• questsystem/QuestNotification.cc (deleted)
• questsystem/QuestNotification.h (deleted)
• questsystem/QuestsystemPrereqs.h (modified) (1 diff)

code/trunk/src/modules/notifications/Notification.cc

@@ -42 +42 @@
 {
 
-    CreateUnloadableFactory(Notification);
-
-    registerMemberNetworkFunction(Notification, send);
-
     /**
     @brief
         Default constructor. Initializes the object.
-    @param creator
-        The object that created this Notification 
     */
-    Notification::Notification(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
+    Notification::Notification()
     {
-        RegisterObject(Notification);
+        RegisterRootObject(Notification);
         this->initialize();
         this->registerVariables();
@@ -67 +61 @@
         The message of the Notification.
     */
-    Notification::Notification(BaseObject* creator, const std::string & message) : BaseObject(creator), Synchronisable(creator)
+    Notification::Notification(const std::string & message)
     {
-        RegisterObject(Notification);
+        RegisterRootObject(Notification);
         this->initialize();
         this->message_ = message;
-        this->registerVariables();
     }
 
@@ -95 +88 @@
     }
 
-    void Notification::registerVariables(void)
-    {
-        registerVariable(this->message_);
-        registerVariable(this->sender_);
-        registerVariable(this->sent_);
-    }
-
     /**
     @brief
         Sends the Notification to the Notificationmanager, which then in turn distributes it to the different NotificationQueues.
-    @param clientId
-        The id of the client that this Notification is sent to.
     @param sender
         The sender the Notification was sent by. Used by the NotificationManager to distributes the notification to the correct NotificationQueues.
@@ -112 +96 @@
         Returns true if successful.
     */
-    bool Notification::send(unsigned int clientId, const std::string & sender = NotificationManager::NONE)
-    {
-        COUT(0) << "MUP: " << Host::getPlayerID() << "|" << clientId << std::endl;
-        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
-        {
-            this->sendHelper(sender);
-        }
-        else if(GameMode::isServer())
-        {
-            callMemberNetworkFunction(Notification, send, this->getObjectID(), clientId, clientId, sender);
-        }
-
-        return true;
-    }
-
-    bool Notification::sendHelper(const std::string& sender)
+    bool Notification::send(const std::string & sender)
     {
         if(this->isSent()) //TODO: Needed?

code/trunk/src/modules/notifications/Notification.h

@@ -51 +51 @@
         Damian 'Mozork' Frick
     */
-    class _NotificationsExport Notification : public BaseObject, public Synchronisable
+    class _NotificationsExport Notification : public OrxonoxClass
     {
         public:
-            Notification(BaseObject* creator);
-            Notification(BaseObject* creator, const std::string & message);
+            Notification();
+            Notification(const std::string & message);
             virtual ~Notification();
 
-            bool send(unsigned int clientId, const std::string & sender); //!< Sends the Notification to the Notificationmanager.
-            bool sendHelper(const std::string& sender);
+            bool send(const std::string & sender); //!< Sends the Notification to the Notificationmanager.
 
             /**

code/trunk/src/modules/notifications/NotificationDispatcher.cc

@@ -35 +35 @@
 
 #include "core/CoreIncludes.h"
+#include "core/EventIncludes.h"
 #include "core/XMLPort.h"
-#include "core/EventIncludes.h"
+#include "network/NetworkFunction.h"
+#include "network/Host.h"
+
+#include "infos/PlayerInfo.h"
+#include "interfaces/PlayerTrigger.h"
+#include "worldentities/pawns/Pawn.h"
+
 #include "Notification.h"
 #include "NotificationManager.h"
-#include "interfaces/PlayerTrigger.h"
-#include "infos/PlayerInfo.h"
-#include "worldentities/pawns/Pawn.h"
 
 namespace orxonox
@@ -48 +52 @@
     CreateUnloadableFactory(NotificationDispatcher);
 
+    registerMemberNetworkFunction(NotificationDispatcher, dispatch);
+
     /**
     @brief
         Default constructor. Initializes the object.
     */
-    NotificationDispatcher::NotificationDispatcher(BaseObject* creator) : BaseObject(creator)
+    NotificationDispatcher::NotificationDispatcher(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     {
         RegisterObject(NotificationDispatcher);
 
         this->sender_ = NotificationManager::NONE;
+        this->registerVariables();
     }
 
@@ -86 +93 @@
     }
 
+    void NotificationDispatcher::registerVariables(void)
+    {
+        registerVariable(this->sender_, VariableDirection::ToClient);
+    }
+
     /**
     @brief
@@ -94 +106 @@
     void NotificationDispatcher::dispatch(unsigned int clientId)
     {
-        const std::string message = this->createNotificationMessage();
-        Notification* notification = new Notification(this, message);
-
-        notification->send(clientId, this->getSender());
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId || this->getSyncMode() == 0x0)
+        {
+            const std::string message = this->createNotificationMessage();
+            NotificationManager::sendNotification(message, clientId, this->getSender());
+        }
+        else if(GameMode::isServer())
+        {
+            callMemberNetworkFunction(NotificationDispatcher, dispatch, this->getObjectID(), clientId, clientId);
+        }
     }
 
@@ -123 +140 @@
         if(pTrigger != NULL)
         {
-            if(!pTrigger->isForPlayer())  //!< The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
+            if(!pTrigger->isForPlayer())  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
                 return false;
             else
@@ -133 +150 @@
         if(pawn == NULL)
         {
-            COUT(4) << "The QuestEffectBeacon was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
+            COUT(4) << "The NotificationDispatcher was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
             return false;
         }
 
-        //! Extract the PlayerInfo from the Pawn.
+        // Extract the PlayerInfo from the Pawn.
         PlayerInfo* player = pawn->getPlayer();
 

code/trunk/src/modules/notifications/NotificationDispatcher.h

@@ -40 +40 @@
 #include <string>
 #include "core/BaseObject.h"
+#include "network/synchronisable/Synchronisable.h"
 
 namespace orxonox
@@ -50 +51 @@
         Damian 'Mozork' Frick
     */
-    class _NotificationsExport NotificationDispatcher : public BaseObject
+    class _NotificationsExport NotificationDispatcher : public BaseObject, public Synchronisable
     {
         public:
@@ -72 +73 @@
             std::string sender_; //!< The name of the sender of the Notification dispatched by this NotificationDispatcher.
 
+           void registerVariables(void);
+
             /**
             @brief Set the sender of the Notification dispatched by this NotificationDispatcher.

code/trunk/src/modules/notifications/NotificationManager.cc

@@ -38 +38 @@
 #include "core/GUIManager.h"
 #include "core/LuaState.h"
+#include "network/Host.h"
+#include "network/NetworkFunction.h"
 #include "util/ScopedSingletonManager.h"
 
@@ -59 +61 @@
 
     SetConsoleCommand("enterEditMode", &NotificationManager::enterEditMode);
+
+    registerStaticNetworkFunction(NotificationManager::sendNotification);
 
     /**
@@ -100 +104 @@
         }
         this->queues_.clear();
+    }
+
+    /*static*/ void NotificationManager::sendNotification(const std::string& message, unsigned int clientId, const std::string& sender)
+    {
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
+        {
+            Notification* notification = new Notification(message);
+            notification->send(sender);
+        }
+        else if(GameMode::isServer())
+        {
+            callStaticNetworkFunction(NotificationManager::sendNotification, clientId, message, clientId, sender);
+        }
     }
 

code/trunk/src/modules/notifications/NotificationManager.h

@@ -70 +70 @@
             static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.
 
+            static void sendNotification(const std::string& message, unsigned int clientId, const std::string& sender = NotificationManager::NONE);
+
             bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
             void unregisterNotification(Notification* notification, NotificationListener* listener); //!< Unregisters a Notification within the NotificationManager for a given NotificationListener.

code/trunk/src/modules/notifications/dispatchers/CommandNotification.cc

@@ -55 +55 @@
 
         this->setSender("commandNotification");
+        this->registerVariables();
     }
 
@@ -77 +78 @@
         XMLPortParam(CommandNotification, "preMessage", setPreMessage, getPreMessage, xmlelement, mode);
         XMLPortParam(CommandNotification, "postMessage", setPostMessage, getPostMessage, xmlelement, mode);
+    }
+
+    void CommandNotification::registerVariables(void)
+    {
+        registerVariable(this->command_, VariableDirection::ToClient);
+        registerVariable(this->preMessage_, VariableDirection::ToClient);
+        registerVariable(this->postMessage_, VariableDirection::ToClient);
     }
 

code/trunk/src/modules/notifications/dispatchers/CommandNotification.h

@@ -38 +38 @@
 #include "notifications/NotificationsPrereqs.h"
 
+#include <string>
 #include "notifications/NotificationDispatcher.h"
-#include <string>
 
 namespace orxonox {
@@ -86 +86 @@
             std::string postMessage_; //!< The last part of the displayed message.
 
+            void registerVariables(void);
+
             /**
             @brief Set the command, whose key is displayed.

code/trunk/src/modules/notifications/dispatchers/SimpleNotification.cc

@@ -50 +50 @@
 
         this->setSender("simpleNotification");
+
+        this->setSyncMode(0x0);
     }
 

code/trunk/src/modules/objects/Script.cc

@@ -35 +35 @@
 #include "core/LuaState.h"
 #include "core/XMLPort.h"
+#include "network/Host.h"
+#include "network/NetworkFunction.h"
+
+#include "PlayerManager.h"
+#include "infos/PlayerInfo.h"
+#include "interfaces/PlayerTrigger.h"
+#include "worldentities/pawns/Pawn.h"
 
 namespace orxonox
 {
     CreateFactory(Script);
+
+    registerMemberNetworkFunction(Script, execute);
 
     // Initializing constants.
@@ -51 +60 @@
         The creator of this object.
     */
-    Script::Script(BaseObject* creator) : BaseObject(creator)
+    Script::Script(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
     {
         RegisterObject(Script);
@@ -63 +72 @@
         this->needsGraphics_ = false;
 
+        this->counter_ = 0.0f;
+
+        this->registerVariables();
     }
 
@@ -92 +104 @@
         XMLPortParam(Script, "times", setTimes, getTimes, xmlelement, mode).defaultValues(Script::INF);
         XMLPortParam(Script, "needsGraphics", setNeedsGraphics, getNeedsGraphics, xmlelement, mode).defaultValues(false);
+        XMLPortParam(Script, "forAll", setForAll, isForAll, xmlelement, mode).defaultValues(false);
 
         XMLPortEventSink(Script, BaseObject, "trigger", trigger, xmlelement, mode);
 
-        if(this->isOnLoad()) // If the object is onLoad the code is executed at once.
-            this->execute();
+        if(this->isOnLoad()) // If the object is onLoad the code is executed at once for all clients.
+            this->execute(0);
     }
 
@@ -116 +129 @@
     /**
     @brief
+        Register the variables that need to be synchronized.
+    */
+    void Script::registerVariables(void)
+    {
+        registerVariable(code_, VariableDirection::ToClient);
+        registerVariable(needsGraphics_, VariableDirection::ToClient);
+        registerVariable(modeStr_, VariableDirection::ToClient, new NetworkCallback<Script>(this, &Script::modeChanged));
+    }
+
+    void Script::modeChanged(void)
+    {
+        this->setMode(this->modeStr_);
+    }
+
+    void Script::tick(float dt)
+    {
+        SUPER(Script, tick, dt);
+
+        if(!this->clientCallbacks_.empty())
+        {
+            if(this->counter_ < 2.0f)
+            {
+                this->counter_ += dt;
+            }
+            else
+            {
+                for(std::vector<unsigned int>::iterator it = this->clientCallbacks_.begin(); it != this->clientCallbacks_.end(); it++)
+                {
+                    this->execute(*it, true);
+                }
+                this->clientCallbacks_.clear();
+                this->counter_ = 0.0f;
+            }
+        }
+    }
+
+    /**
+    @brief
         Is called when an event comes in trough the event port.
     @param triggered
         Whether the event is triggering or un-triggering.
-    */
-    void Script::trigger(bool triggered)
-    {
-        if(triggered) // If the event is triggering (instead of un-triggering) the code of this Script  is executed.
-            this->execute();
-    }
-
-    /**
-    @brief
-        Executes the Scripts code, depending on the mode.
-    */
-    void Script::execute()
-    {
-        if(this->times_ != Script::INF && this->remainingExecutions_ == 0)
-            return;
-
-        // If the code needs graphics to be executed but the GameMode doesn't show graphics the code isn't executed.
-        if(this->needsGraphics_ && !GameMode::showsGraphics())
-            return;
-
-        if(this->mode_ == ScriptMode::normal) // If the mode is 'normal'.
-            CommandExecutor::execute(this->code_);
-        else if(this->mode_ == ScriptMode::lua) // If it's 'lua'.
-        {
-            assert(this->luaState_);
-            this->luaState_->doString(this->code_);
-        }
-
-        if(this->times_ != Script::INF)
-            this->remainingExecutions_--;
+    @param trigger
+        The object that caused the event to be fired.
+    @return
+        Returns true if successful.
+    */
+    bool Script::trigger(bool triggered, BaseObject* trigger)
+    {
+        if(!triggered || !this->isActive()) // If the Script is inactive it cannot be executed.
+            return false;
+
+        COUT(4) << "Script (&" << this << ") triggered." << std::endl;
+
+        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
+        Pawn* pawn = NULL;
+
+        // 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();
+        }
+        else
+            return false;
+
+        if(pawn == NULL)  //TODO: Will this ever happen? If not, change in NotificationDispatcher as well.
+        {
+            COUT(4) << "The Script was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << std::endl;
+            return false;
+        }
+
+        // Extract the PlayerInfo from the Pawn.
+        PlayerInfo* player = pawn->getPlayer();
+
+        if(player == NULL)
+        {
+            COUT(3) << "The PlayerInfo* is NULL." << std::endl;
+            return false;
+        }
+
+        this->execute(player->getClientID());
+        return true;
+    }
+
+    /**
+    @brief
+        Executes the Scripts code for the input client, depending on the mode.
+    @param clientId
+        The Id of the client the Script should be executed for.
+    @param fromCallback
+        Whether this method is executed in response to the connectedCallback().
+    */
+    void Script::execute(unsigned int clientId, bool fromCallback)
+    {
+        if(GameMode::isServer())
+        {
+            // If the number of executions have been used up.
+            if(this->times_ != Script::INF && this->remainingExecutions_ == 0)
+                return;
+
+            // Decrement the number of remaining executions.
+            if(this->times_ != Script::INF)
+                this->remainingExecutions_--;
+        }
+
+        if(GameMode::isStandalone() || Host::getPlayerID() == clientId)
+        {
+            // If the code needs graphics to be executed but the GameMode doesn't show graphics the code isn't executed.
+            if(this->needsGraphics_ && !GameMode::showsGraphics())
+                return;
+
+            if(this->mode_ == ScriptMode::normal) // If the mode is 'normal'.
+                CommandExecutor::execute(this->code_);
+            else if(this->mode_ == ScriptMode::lua) // If it's 'lua'.
+            {
+                if(this->luaState_ == NULL)
+                    this->luaState_ = new LuaState();
+                this->luaState_->doString(this->code_);
+            }
+        }
+        if(!GameMode::isStandalone() && GameMode::isServer() && Host::getPlayerID() != clientId)
+        {
+            if(!fromCallback && this->isForAll())
+            {
+                const std::map<unsigned int, PlayerInfo*> clients = PlayerManager::getInstance().getClients();
+                for(std::map<unsigned int, PlayerInfo*>::const_iterator it = clients.begin(); it != clients.end(); it++)
+                {
+                    callMemberNetworkFunction(Script, execute, this->getObjectID(), it->first, it->first, false);
+                }
+            }
+            else
+            {
+                callMemberNetworkFunction(Script, execute, this->getObjectID(), clientId, clientId, false);
+            }
+        }
+    }
+
+    void Script::clientConnected(unsigned int clientId)
+    {
+        if(!GameMode::isStandalone() && GameMode::isServer() && this->isOnLoad())
+        {
+            if(clientId != 0)
+                //TODO: Do better. This is only a temporary fix.
+                this->clientCallbacks_.push_back(clientId);
+        }
     }
 
@@ -160 +287 @@
     {
         if(mode == Script::NORMAL)
+        {
             this->setMode(ScriptMode::normal);
+            this->modeStr_ = Script::NORMAL;
+        }
         else if(mode == Script::LUA)
         {
             this->setMode(ScriptMode::lua);
+            this->modeStr_ = Script::LUA;
             // Creates a new LuaState.
             if(this->luaState_ == NULL)
@@ -170 +301 @@
         else
         {
-            COUT(2) << "Invalid mode '" << mode << "' in Script object." << std::endl;
+            COUT(2) << "Invalid mode '" << mode << "' in Script object. Setting to 'normal'." << std::endl;
             this->setMode(ScriptMode::normal);
+            this->modeStr_ = Script::NORMAL;
         }
     }
@@ -210 +342 @@
         else
         {
-            COUT(2) << "Invalid times '" << times << "' in Script." << std::endl;
+            COUT(2) << "Invalid times '" << times << "' in Script. Setting to infinity." << std::endl;
             this->times_ = Script::INF;
+            this->remainingExecutions_ = Script::INF;
         }
     }

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

@@ -33 +33 @@
 
 #include <string>
+#include <vector>
+
 #include "core/BaseObject.h"
+#include "tools/interfaces/Tickable.h"
+#include "network/synchronisable/Synchronisable.h"
+#include "network/ClientConnectionListener.h"
 
 namespace orxonox
@@ -54 +59 @@
         'code': The code that should be executed.
         'mode': The mode, specifying whether the set code should be executed the normal way ('normal') or in lua ('lua'). Default is 'normal'.
-        'onLoad': Whether the code is executed upon loading (creation) of this object. Default is true.
+        'onLoad': Whether the code is executed upon loading (creation) of this object. If this is set the code is executed ofr all players, regardless of the value of parameter 'forAll'. Default is true.
         'needsGraphics': Whether the code needs graphics to be executed or not. Default is false.
+        'forAll': Whether the code is executed for all players each time the Script is triggered or jut for the player triggering the Script. If forAll is false, which is default, the event that triggers the Script must come from a PlayerTrigger.
 
         Here are two examples illustrating the usage:
@@ -77 +83 @@
         Damian 'Mozork' Frick
     */
-    class _ObjectsExport Script : public BaseObject
+    class _ObjectsExport Script : public BaseObject, public Synchronisable, public ClientConnectionListener, public Tickable
     {
         public:
@@ -86 +92 @@
             virtual void XMLEventPort(Element& xmlelement, XMLPort::Mode mode); //!< Creates a port that can be used to channel events and react to them.
 
-            void trigger(bool triggered); //!< Is called when an event comes in trough the event port.
-            void execute(); //!< Executes the Scripts code, depending on the mode.
+            virtual void tick(float dt);
+
+            bool trigger(bool triggered, BaseObject* trigger); //!< Is called when an event comes in trough the event port.
+            void execute(unsigned int clientId, bool fromCallback = false); //!< Executes the Scripts code for the input client, depending on the mode.
 
             /**
@@ -139 +147 @@
                 { return this->needsGraphics_; }
 
+            /**
+            @brief Set whether the code is executed for all players or just for the player triggering the Script.
+            @param forAll If true the code is executed for all players.
+            */
+            void setForAll(bool forAll)
+                { this->forAll_ = forAll; }
+            /**
+            @brief Get whether the Script executes its code for all players or just for the player triggering the Script.
+            @return Returns true if the code is executed for all players, false if not.
+            */
+            bool isForAll(void)
+                { return this->forAll_; }
+
+            virtual void clientConnected(unsigned int clientId);
+            virtual void clientDisconnected(unsigned int clientid) {}
+
         private:
             //! Static variables to avoid magic strings.
@@ -150 +174 @@
             int times_; //!< The number of times the Scripts code is executed at the most. -1 denotes infinity.
             bool needsGraphics_; //!< Whether the code to be executed needs graphics.
+            bool forAll_; //!< Whether the code is executed for all players (in a multiplayer setup) or just for the one triggering the Script.
+
+            std::string modeStr_;
+
+            std::vector<unsigned int> clientCallbacks_;
+            float counter_;
 
             LuaState* luaState_; //!< The LuaState to execute the code in lua.
             int remainingExecutions_; //!< The number of remainign executions. -1 denotes infinity.
+
+            void registerVariables(void);
+            void modeChanged();
 
             /**

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

@@ -10 +10 @@
   QuestListener.cc
   QuestManager.cc
-  QuestNotification.cc
 )
 

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

@@ -38 +38 @@
 #include "core/XMLPort.h"
 
-#include "QuestNotification.h"
+#include "infos/PlayerInfo.h"
+
+#include "notifications/NotificationManager.h"
 
 namespace orxonox
 {
     CreateFactory(QuestDescription);
+
+    /*static*/ const std::string QuestDescription::SENDER = "questsystem";
 
     /**
@@ -115 +119 @@
         }
 
-        QuestNotification* notification = new QuestNotification(this, message);
-        notification->send(player);
+        NotificationManager::sendNotification(message, player->getClientID(), QuestDescription::SENDER);
         return true;
     }

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

@@ -128 +128 @@
 
         private:
+            static const std::string SENDER;
+
             std::string title_; //!< The title.
             std::string description_; //!< The description.

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

@@ -81 +81 @@
     class QuestListener;
     class QuestManager;
-    class QuestNotification;
 }