Changeset 8453 for code/branches/tutoriallevel3/src

code/branches/tutoriallevel3

Property svn:mergeinfo changed
/code/branches/tutoriallevel (added) merged: 7828-7831,7894,8370
/code/branches/tutoriallevel2 (added) merged: 8371,8374,8376-8378,8444-8451

code/branches/tutoriallevel3/src/libraries/core/GUIManager.cc

-                      r8439
+                      r8453
 #include <CEGUIDefaultLogger.h>
 #include <CEGUIExceptions.h>
+#include <CEGUIFontManager.h>
 #include <CEGUIInputEvent.h>
 #include <CEGUIMouseCursor.h>
 …
 #include <CEGUIWindow.h>
 #include <CEGUIWindowManager.h>
+#include <CEGUIXMLAttributes.h>
 #include <elements/CEGUIListbox.h>
 #include <elements/CEGUIListboxItem.h>
 …
+    }
+    /**
+    @brief
+        Adds a new freetype font to the CEGUI system.
+    @param name
+        The name of the new font.
+    @param size
+        The font size of the new font in pixels.
+        @param fontName
+        The filename of the font.
+    */
+    /*static*/ void GUIManager::addFontHelper(const std::string& name, int size, const std::string& fontName)
+    {
+        if(CEGUI::FontManager::getSingleton().isFontPresent(name)) // If a font with that name already exists.
+            return;
+        CEGUI::Font* font = NULL;
+        CEGUI::XMLAttributes xmlAttributes;
+        // Attributes specified within CEGUIFont
+        xmlAttributes.add("Name", name);
+        xmlAttributes.add("Filename", fontName);
+        xmlAttributes.add("ResourceGroup", "");
+        xmlAttributes.add("AutoScaled", "true");
+        xmlAttributes.add("NativeHorzRes", "800");
+        xmlAttributes.add("NativeVertRes", "600");
+        // Attributes specified within CEGUIXMLAttributes
+        xmlAttributes.add("Size", multi_cast<std::string>(size));
+        xmlAttributes.add("AntiAlias", "true");
+        font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
+        if(font != NULL)
+            font->load();
+    }
+}

code/branches/tutoriallevel3/src/libraries/core/GUIManager.h

-                      r8423
+                      r8453
         // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work
+        static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); //tolua_export
+        static void setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& toooltip); //tolua_export
+        static void setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled); //tolua_export
+        static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); // tolua_export
+        static void setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& toooltip); // tolua_export
+        static void setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled); // tolua_export
+        static void addFontHelper(const std::string& name, int size, const std::string& fontName); // tolua_export
         static GUIManager& getInstance() { return Singleton<GUIManager>::getInstance(); } // tolua_export

code/branches/tutoriallevel3/src/libraries/network/synchronisable/Synchronisable.cc

-                      r8329
+                      r8453
   /**
    * This function determines, wheter the object should be saved to the bytestream (according to its syncmode/direction)
-   * @param id gamestate id
    * @param mode Synchronisation mode (toclient, toserver or bidirectional)
    * @return true/false
 …
   /**
    * This function determines, wheter the object should accept data from the bytestream (according to its syncmode/direction)
-   * @param id gamestate id
    * @param mode Synchronisation mode (toclient, toserver or bidirectional)
    * @return true/false

code/branches/tutoriallevel3/src/libraries/util/SubString.h

r7401	r8453
169	169	/// Returns the number of tokens stored in this SubString
170	170	inline unsigned int size() const { return this->tokens_.size(); }
171		/// Returns the i'th token from the subset of strings @param index The index of the requested doken
	171	/// Returns the i'th token from the subset of strings @param index The index of the requested token
172	172	inline const std::string& operator[](unsigned int index) const { return this->tokens_[index]; }
173	173	/// Returns the i'th token from the subset of strings @param index The index of the requested token

code/branches/tutoriallevel3/src/modules/notifications/CMakeLists.txt

-                      r7403
+                      r8453
 SET_SOURCE_FILES(NOTIFICATIONS_SRC_FILES
-  Notification.cc
   NotificationDispatcher.cc
   NotificationManager.cc
   NotificationQueue.cc
+  NotificationQueueCEGUI.cc
+)
 …
   TOLUA_FILES
     NotificationManager.h
     NotificationQueue.h
+    NotificationQueueCEGUI.h
   PCH_FILE
     NotificationsPrecompiledHeaders.h

code/branches/tutoriallevel3/src/modules/notifications/NotificationDispatcher.cc

-                      r7552
+                      r8453
 #include "infos/PlayerInfo.h"
+#include "interfaces/NotificationListener.h"
 #include "interfaces/PlayerTrigger.h"
 #include "worldentities/pawns/Pawn.h"
-#include "NotificationManager.h"
 namespace orxonox
 …
         RegisterObject(NotificationDispatcher);
         this->sender_ = NotificationManager::NONE;
+        this->sender_ = NotificationListener::NONE;
         this->registerVariables();
+    }
 …
+        {
             const std::string message = this->createNotificationMessage();
+            NotificationManager::sendNotification(message, clientId, this->getSender());
+            // TODO: Make the type configurable.
+            NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId);
+        }
         else if(GameMode::isServer())

code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.cc

-                      r8079
+                      r8453
 #include "core/command/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
-#include "core/GUIManager.h"
 #include "core/LuaState.h"
-#include "network/Host.h"
-#include "network/NetworkFunction.h"
 #include "util/ScopedSingletonManager.h"
 #include "interfaces/NotificationListener.h"
-#include "Notification.h"
 #include "NotificationQueue.h"
+#include "ToluaBindNotifications.h"
+#include "NotificationQueueCEGUI.h"
 namespace orxonox
+{
-    const std::string NotificationManager::ALL("all");
-    const std::string NotificationManager::NONE("none");
-    // Register tolua_open function when loading the library.
-    DeclareToluaInterface(Notifications);
     ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
-    // Setting console command to enter the edit mode.
-    SetConsoleCommand("enterEditMode", &NotificationManager::enterEditMode);
-    registerStaticNetworkFunction(NotificationManager::sendNotification);
     /**
     @brief
 …
         RegisterRootObject(NotificationManager);
-        this->highestIndex_ = 0;
-        ModifyConsoleCommand("enterEditMode").setObject(this);
         COUT(3) << "NotificatioManager created." << std::endl;
+    }
 …
     NotificationManager::~NotificationManager()
+    {
-        ModifyConsoleCommand("enterEditMode").setObject(NULL);
         // Destroys all Notifications.
         for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it!= this->allNotificationsList_.end(); it++)
 …
         while(it != this->queues_.end())
+        {
             it->second->destroy(true);
+            it->second->destroy();
             it = this->queues_.begin();
+        }
 …
     /**
     @brief
+        Sends a Notification with the specified message to the specified client from the specified sender.
+        Creates and registers a Notification with the input message from the input sender.
+        This is called by the NotificationListener, whenever a new notification arrives.
     @param message
+        The message that should be sent.
+    @param clientId
+        The id of the client the notification should be sent to.
+        The message of the new Notification.
     @param sender
+        The sender that sent the notification.
+    @param isLocal
+        If this is set to true (false is default), then the Notification is sent to the client where this function is executed, meaning the Notification is sent locally.
+    */
+    /*static*/ void NotificationManager::sendNotification(const std::string& message, unsigned int clientId, const std::string& sender, bool isLocal)
+    {
+        // If we're in standalone mode or we're already no the right client we create and send the Notification.
+        if(GameMode::isStandalone() || isLocal || Host::getPlayerID() == clientId)
+        {
+            Notification* notification = new Notification(message, sender);
+            if(NotificationManager::getInstance().registerNotification(notification))
+                COUT(3) << "Notification \"" << notification->getMessage() << "\" sent." << std::endl;
+        }
+        // If we're on the server (and the server is not the intended recipient of the Notification) we send it over the network.
+        else if(GameMode::isServer())
+        {
+            callStaticNetworkFunction(NotificationManager::sendNotification, clientId, message, clientId, sender);
+        }
+    }
+    /**
+    @brief
+        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its sender.
+        The name of the entity (of the collective) that sent the new Notification.
+    @param type
+        The type of the new Notification.
+    @return
+        Returns true if successful.
+    */
+    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    {
+        // TODO: Do something with the type.
+        Notification* notification = new Notification(message, sender, type);
+        return this->registerNotification(notification);
+    }
+    /**
+    @brief
+        Executes the input command from the input sender.
+        This is called by the NotificationListener, whenever a new command arrives.
+    @param command
+        The command to be executed,
+    @param sender
+        The The name of the entity (of the collective) that sent the command.
+    @return
+        Returns true if the command was successfully executed.
+    */
+    bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender)
+    {
+        bool commandExecuted = false;
+        if(command == notificationCommand::clear)
+        {
+            if(this->commandClear(sender))
+                commandExecuted = true;
+        }
+        if(commandExecuted)
+            COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
+        return commandExecuted;
+    }
+    /**
+    @brief
+        The clear command. Clears all NotificationQueues that have its sender as a target.
+    @param sender
+        The sender of the clear command.
+    @return
+        Returns true if the command was successfully executed by at least one NotificationQueue, false if it was not executed.
+    */
+    bool NotificationManager::commandClear(const std::string& sender)
+    {
+        bool all = (sender == NotificationListener::ALL);
+        bool executed = false;
+        // Clear all NotificationQueues that have the input sender as target.
+        for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = it->second->getTargetsSet();
+            // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
+            if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
+                executed = it->second->tidy() || executed;
+        }
+        return executed;
+    }
+    /**
+    @brief
+        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationQueues associated with its sender.
     @param notification
         The Notification to be registered.
 …
         this->allNotificationsList_.insert(std::pair<std::time_t, Notification*>(time, notification));
         if(notification->getSender() == NotificationManager::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
+        if(notification->getSender() == NotificationListener::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
             return true;
+        bool all = false;
+        if(notification->getSender() == NotificationManager::ALL) // If all are the sender, then the Notifications is added to every NotificationListener.
+            all = true;
+        // Insert the Notification in all NotificationListeners that have its sender as target.
+        for(std::map<NotificationListener*, unsigned int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) // Iterate through all NotificationListeners.
+        {
+            const std::set<std::string>& set = it->first->getTargetsSet();
+            bool bAll = set.find(NotificationManager::ALL) != set.end();
+            // If either the Notification has as sender 'all', the NotificationListener displays all Notifications or the NotificationListener has the sender of the Notification as target.
+        // If all are the sender, then the Notifications is added to every NotificationQueue.
+        bool all = (notification->getSender() == NotificationListener::ALL);
+        // Insert the Notification in all NotificationQueues that have its sender as target.
+        for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues.
+        {
+            const std::set<std::string>& set = it->second->getTargetsSet();
+            bool bAll = set.find(NotificationListener::ALL) != set.end();
+            // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
             if(all || bAll || set.find(notification->getSender()) != set.end())
+            {
                 if(!bAll)
                     this->notificationLists_[it->second]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationListener.
                 it->first->update(notification, time); // Update the NotificationListener.
+                    this->notificationLists_[it->second->getName()]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationQueue.
+                it->second->update(notification, time); // Update the NotificationQueue.
+            }
+        }
 …
     /**
     @brief
         Unregisters a Notification within the NotificationManager for a given NotificationListener.
+        Unregisters a Notification within the NotificationManager for a given NotificationQueue.
     @param notification
         A pointer to the Notification to be unregistered.
     @param listener
         A pointer to the NotificationListener the Notification is unregistered for.
     */
     void NotificationManager::unregisterNotification(Notification* notification, NotificationListener* listener)
+    @param queue
+        A pointer to the NotificationQueue the Notification is unregistered for.
+    */
+    void NotificationManager::unregisterNotification(Notification* notification, NotificationQueue* queue)
+    {
         assert(notification);
         assert(listener);
         // Remove the Notification from the list of Notifications of the input NotificationListener.
         this->removeNotification(notification, *(this->notificationLists_.find(this->listenerList_.find(listener)->second)->second));
         COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from listener (&" << listener << ")" << std::endl;
+        assert(queue);
+        // Remove the Notification from the list of Notifications of the input NotificationQueue.
+        this->removeNotification(notification, *(this->notificationLists_.find(queue->getName())->second));
+        COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << std::endl;
+    }
 …
     /**
     @brief
+        Registers a NotificationListener within the NotificationManager.
+    @param listener
+        The NotificationListener to be registered.
+    @return
+        Returns true if successful.  Fales if the NotificationListener is already registered.
+    */
+    bool NotificationManager::registerListener(NotificationListener* listener)
+    {
+        assert(listener);
+        // If the NotificationListener is already registered.
+        if(this->listenerList_.find(listener) != this->listenerList_.end())
+            return false;
+        this->highestIndex_ += 1;
+        unsigned int index = this->highestIndex_; // An identifier that identifies each registered NotificationListener uniquely.
+        this->listenerList_[listener] = index; // Add the NotificationListener to the list of NotificationListeners.
+        const std::set<std::string>& set = listener->getTargetsSet();
+        // If all senders are the target of the NotificationListener, then the list of Notifications for that specific NotificationListener is the same as the list of all Notifications.
+        bool bAll = set.find(NotificationManager::ALL) != set.end();
+        std::multimap<std::time_t, Notification*>* map = NULL;
+        if(bAll)
+            this->notificationLists_[index] = &this->allNotificationsList_;
+        // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationListeners.
+        else
+        {
+            this->notificationLists_[index] = new std::multimap<std::time_t, Notification*>;
+            map = this->notificationLists_[index];
+        }
+        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener.
+        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
+        {
+            if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
+                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
+        }
+        listener->update(); // Update the listener.
+        COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl;
+        return true;
+    }
+    /**
+    @brief
+        Unregisters a NotificationListener within the NotificationManager.
+    @param listener
+        The NotificationListener to be unregistered.
+    */
+    void NotificationManager::unregisterListener(NotificationListener* listener)
+    {
+        assert(listener);
+        unsigned int identifier = this->listenerList_.find(listener)->second;
+        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(identifier)->second;
+        // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
+        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
+        if(map != &this->allNotificationsList_)
+        {
+            while(it != map->end())
+            {
+                this->unregisterNotification(it->second, listener);
+                it = map->begin();
+            }
+            delete map;
+        }
+        COUT(4) << "NotificationListener '" << identifier << "' unregistered with the NotificationManager." << std::endl;
+        // Remove the NotificationListener from the list of NotificationListeners.
+        this->listenerList_.erase(listener);
+        // Remove the Notifications list that was associated with the input NotificationListener.
+        this->notificationLists_.erase(identifier);
+    }
+    /**
+    @brief
+        Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map.
+    @param listener
+        The NotificationListener the Notifications are fetched for.
+        Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map.
+    @param queue
+        The NotificationQueue the Notifications are fetched for.
     @param map
         A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
 …
         Returns true if successful.
     */
     void NotificationManager::getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    {
         assert(listener);
+    void NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
+    {
+        assert(queue);
         assert(map);
         std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[this->listenerList_[listener]]; // All the Notifications for the input NotificationListener.
+        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
         std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
 …
     /**
     @brief
+        Enters the edit mode of the NotificationLayer.
+    */
+    void NotificationManager::enterEditMode(void)
+    {
+        if(GameMode::showsGraphics())
+        {
+            GUIManager::getInstance().hideGUI("NotificationLayer");
+            GUIManager::getInstance().showGUI("NotificationLayer", false, false);
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.enterEditMode()");
+        Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map.
+    @param queue
+        The NotificationQueue the Notifications are fetched for.
+    @param map
+        A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
+    @param numberOfNotifications
+        The number of newest Notifications to be got.
+    @return
+        Returns true if successful.
+    */
+    void NotificationManager::getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications)
+    {
+        assert(queue);
+        assert(map);
+        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
+        if(!notifications->empty()) // If the list of Notifications is not empty.
+        {
+            std::multimap<std::time_t,Notification*>::iterator it = notifications->end();
+            for(int i = 0; i < numberOfNotifications; i++) // Iterate through the Notifications from the newest until we have the specified number of notifications.
+            {
+                it--;
+                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); // Add the found Notifications to the map.
+                if(it == notifications->begin())
+                    break;
+            }
+        }
+    }
 …
     @brief
         Registers a NotificationQueue.
         This makes sure that the NotificationQueue can be attained through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager.
+        This makes sure that the NotificationQueue can be accessed through lua by name. It also makes sure that the NotificationQueue is destroyed upon destruction of the NotificationManager.
     @param queue
         A pointer to the NotificationQueue to be registered.
 …
     bool NotificationManager::registerQueue(NotificationQueue* queue)
+    {
+        assert(queue);
+        // If the NotificationQueue is already registered.
+        if(this->queues_.find(queue->getName()) != this->queues_.end())
+            return false;
+        this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)); // Add the NotificationQueue to the list of NotificationQueues.
+        const std::set<std::string>& set = queue->getTargetsSet();
+        // If all senders are the target of the NotificationQueue, then the list of Notifications for that specific NotificationQueue is the same as the list of all Notifications.
+        bool bAll = set.find(NotificationListener::ALL) != set.end();
+        std::multimap<std::time_t, Notification*>* map = NULL;
+        if(bAll)
+            this->notificationLists_[queue->getName()] = &this->allNotificationsList_;
+        // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationQueues.
+        else
+        {
+            this->notificationLists_[queue->getName()] = new std::multimap<std::time_t, Notification*>;
+            map = this->notificationLists_[queue->getName()];
+        }
+        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
+        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
+        {
+            if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
+                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
+        }
+        queue->update(); // Update the queue.
         COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl;
         return this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)).second;
+        return true;
+    }
 …
     void NotificationManager::unregisterQueue(NotificationQueue* queue)
+    {
+        assert(queue);
+        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(queue->getName())->second;
+        // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
+        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
+        if(map != &this->allNotificationsList_)
+        {
+            while(it != map->end())
+            {
+                this->unregisterNotification(it->second, queue);
+                it = map->begin();
+            }
+            delete map;
+        }
+        // Remove the NotificationQueue from the list of NotificationQueues.
+        this->queues_.erase(queue->getName());
+        // Remove the Notifications list that was associated with the input NotificationQueue.
+        this->notificationLists_.erase(queue->getName());
         COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl;
-        this->queues_.erase(queue->getName());
+    }
-    /**
-    @brief
-        Loads all the NotificationQueues that should exist.
-    */
-    void NotificationManager::loadQueues(void)
+    {
-        new NotificationQueue("all");
+    }
-    /**
-    @brief
-        Creates a new NotificationQueue.
-        This is used in lua.
-    @param name
-        The name of the new NotificationQueue.
-    */
-    void NotificationManager::createQueue(const std::string& name)
+    {
-        new NotificationQueue(name);
+    }
 …
+    }
+    /**
+    @brief
+        Loads all the NotificationQueues that should exist.
+    */
+    void NotificationManager::loadQueues(void)
+    {
+        NotificationQueueCEGUI* allQueue = new NotificationQueueCEGUI("all");
+        allQueue->setDisplaySize(Vector2(0.5, 0));
+        allQueue->setPosition(Vector4(0.0, 10, 0.3, 0));
+        NotificationQueueCEGUI* infoQueue = new NotificationQueueCEGUI("info", "gameinfo", 1, -1);
+        infoQueue->setPosition(Vector4(0.2, 0, 0.8, 0));
+        infoQueue->setFontSize(24);
+        infoQueue->setFontColor(Vector4(1.0, 1.0, 0.0, 0.8));
+        infoQueue->setAlignment("HorzCentred");
+        infoQueue->setDisplaySize(Vector2(0.6, 0.0));
+    }
+    // Notification class
+    /**
+    @brief
+        Constructor. Creates a Notification with the input message and sender.
+    @param message
+        The message of the Notification.
+    @param sender
+        The sender of the Notification.
+    @param type
+    */
+    Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+    {
+        this->initialize();
+        this->message_ = message;
+        this->sender_ = sender;
+        this->type_ = type;
+    }
+    /**
+    @brief
+        Destructor.
+    */
+    Notification::~Notification()
+    {
+    }
+    /**
+    @brief
+        Registers the object and sets some default values.
+    */
+    void Notification::initialize(void)
+    {
+        this->message_.clear();
+        this->sender_ = NotificationListener::NONE;
+    }
+}

code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.h

-                      r7552
+                      r8453
 #include <string>
+#include "core/OrxonoxClass.h"
 #include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
+#include "interfaces/NotificationListener.h"
 namespace orxonox // tolua_export
 …
     /**
     @brief
+        The Singleton NotificationManager functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationListener "NotificationListeners".
+        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationListener "NotificationListeners".
+        It also provides a static function to send @ref orxonox::Notification "Notifications" and works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer.
+        A Notification represents a short message used to inform the player about something that just happened. With the @ref orxonox::NotificationManager "NotificationManager" a Notification can be sent from any part of orxonox and is then displayed by the proper @ref orxonox::NotificationQueue "NotificationQueue(s)" (depending on which senders the specific @ref orxonox::NotificationQueue "NotificationQueues" accepts).
+        A Notification is just a data structure that is used internally by the Notifications module.
+    @author
+        Damian 'Mozork' Frick
+    @ingroup Notifications
+    */
+    class _NotificationsExport Notification
+    {
+        public:
+            Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            virtual ~Notification();
+            /**
+            @brief Destroys the Notification.
+            */
+            void destroy(void)
+                { delete this; }
+            /**
+            @brief Get the message of the Notification.
+            @return Returns the message of the Notification.
+            */
+            inline const std::string & getMessage(void) const
+                { return this->message_; }
+            /**
+            @brief Get the sender of the Notification.
+            @return Returns the sender of the Notification.
+            */
+            inline const std::string & getSender(void) const
+                { return this->sender_; }
+            /**
+            @brief Get the type of the Notification.
+            @return Returns an enum with the type of the Notification.
+            */
+            inline notificationMessageType::Value getType(void) const
+                { return this->type_; }
+        private:
+            std::string message_; //!< The Notification message.
+            std::string sender_; //!< The sender of the notification.
+            notificationMessageType::Value type_; //!< The type of the notification.
+            void initialize(void); //!< Registers the object and sets some default values.
+    };
+    /**
+    @brief
+        The Singleton NotificationManager is a NotificationListener and functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationQueue "NotificationQueues".
+        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationQueue "NotificationQueues".
+        It also works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer.
     @author
 …
     */
     class _NotificationsExport NotificationManager // tolua_export
         : public Singleton<NotificationManager>, public OrxonoxClass
+        : public Singleton<NotificationManager>, public NotificationListener
     { // tolua_export
             friend class Singleton<NotificationManager>;
 …
             virtual ~NotificationManager();
             virtual void preDestroy(void); //!< Is called before the object is destroyed.
+            virtual void preDestroy(void); // Is called before the object is destroyed.
             /**
 …
             static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export
             static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationListeners.
             static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.
+            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
+            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender);
             //! Sends a Notification with the specified message to the specified client from the specified sender.
             static void sendNotification(const std::string& message, unsigned int clientId, const std::string& sender = NotificationManager::NONE, bool isLocal = false);
+            bool registerNotification(Notification* notification); // Registers a Notification within the NotificationManager.
+            void unregisterNotification(Notification* notification, NotificationQueue* queue); // Unregisters a Notification within the NotificationManager for a given NotificationQueue.
+            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.
+            bool registerListener(NotificationListener* listener); //!< Registers a NotificationListener within the NotificationManager.
+            void unregisterListener(NotificationListener* listener); //!< Unregisters a NotificationListener withing the NotificationManager.
+            void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); //!< Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map.
+            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd); // Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map.
             /**
             @brief Fetches the Notifications for a specific NotificationListener in a timeframe from now-timeDelay to now and stores them in the input map.
             @param listener The NotificationListener the Notifications are fetched for.
+            @brief Fetches the Notifications for a specific NotificationQueue in a timeframe from (now-timeDelay) to now and stores them in the input map.
+            @param queue The NotificationQueue the Notifications are fetched for.
             @param map A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
             @param timeDelay The timespan.
             @return Returns true if successful.
             */
             void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, int timeDelay)
                 { this->getNotifications(listener, map, std::time(0)-timeDelay, std::time(0)); }
+            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int timeDelay)
+                { this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); }
             void enterEditMode(void); //!< Enters the edit mode of the NotificationLayer.
+            void getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications); // Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map.
             bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue.
             void unregisterQueue(NotificationQueue* queue); //!< Unregisters a NotificationQueue.
+            bool registerQueue(NotificationQueue* queue); // Registers a NotificationQueue.
+            void unregisterQueue(NotificationQueue* queue); // Unregisters a NotificationQueue.
+            // tolua_begin
+            void loadQueues(void); //!< Loads all the NotificationQueues that should exist.
+            void createQueue(const std::string& name); //!< Creates a new NotificationQueue.
+            orxonox::NotificationQueue* getQueue(const std::string & name); //!< Get the NotificationQueue with the input name.
+            // tolua_end
+            void loadQueues(void); // tolua_export // Loads all the NotificationQueues that should exist.
+            NotificationQueue* getQueue(const std::string & name); // Get the NotificationQueue with the input name.
         private:
             static NotificationManager* singletonPtr_s;
-            unsigned int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that no key appears twice.
             std::multimap<std::time_t, Notification*> allNotificationsList_; //!< Container where all Notifications are stored.
+            std::map<NotificationListener*, unsigned int> listenerList_; //!< Container where all NotificationListeners are stored with a number as identifier.
+            std::map<int,std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationListener), are stored.
+            std::map<const std::string, std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationQueue), are stored.
             std::map<const std::string, NotificationQueue*> queues_; //!< The list of NotificationQueues created by the NotificationManager.
+            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); //!< Helper method that removes an input Notification form an input map.
+            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); // Helper method that removes an input Notification form an input map.
+            // Commands
+            bool commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target.
     }; // tolua_export

code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.cc

-                      r8079
+                      r8453
 #include "core/CoreIncludes.h"
-#include "core/GameMode.h"
-#include "core/GUIManager.h"
-#include "core/LuaState.h"
-#include "util/Convert.h"
 #include "util/SubString.h"
-#include "Notification.h"
 namespace orxonox
 …
     @param senders
         The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
         The senders need to be seperated by commas.
+        The senders need to be separated by commas.
     @param size
         The size (the maximum number of displayed Notifications) of this NotificationQueue.
 …
+        }
+        this->create(); // Creates the NotificationQueue in lua.
+        // Register the NotificationQueue as NotificationListener with the NotificationManager.
+        bool listenerRegistered = NotificationManager::getInstance().registerListener(this);
+        if(!listenerRegistered) // If the registration has failed.
+        {
+            this->registered_ = false;
+            // Remove the NotificationQueue in lua.
+            if(GameMode::showsGraphics())
+                GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
+        COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
+    }
+    /**
+    @brief
+        Destructor.
+    */
+    NotificationQueue::~NotificationQueue()
+    {
+        this->targets_.clear();
+        if(this->registered_) // If the NotificationQueue is registered.
+        {
+            this->clear(true);
+            // Unregister with the NotificationManager.
             NotificationManager::getInstance().unregisterQueue(this);
+            COUT(1) << "Error: NotificationQueue '" << this->getName() << "' could not be registered." << std::endl;
+            return;
+        }
+        COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
+    }
+    /**
+    @brief
+        Destructor.
+    */
+    NotificationQueue::~NotificationQueue()
+    {
+        this->targets_.clear();
+        if(this->registered_) // If the NotificationQueue is registered.
+        {
+            this->clear(true);
+            // Unregister with the NotificationManager.
+            NotificationManager::getInstance().unregisterListener(this);
+            NotificationManager::getInstance().unregisterQueue(this);
+        }
+    }
+    /**
+    @brief
+        Destroys the NotificationQueue.
+        Used in lua and NotificationManager.
+    @param noGraphics
+        If this is set to true (false is default), then the queue is not removed in lua. This is used to destroy the queue, after the GUIManager has been destroyed.
+    */
+    void NotificationQueue::destroy(bool noGraphics)
+    {
+        // Remove the NotificationQueue in lua.
+        if(GameMode::showsGraphics() && !noGraphics)
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
+        }
         COUT(3) << "NotificationQueue '" << this->getName() << "' destroyed." << std::endl;
-        this->OrxonoxClass::destroy();
+    }
-    /**
-    @brief
-        Creates the NotificationQueue in lua.
-    */
-    void NotificationQueue::create(void)
+    {
-        if(GameMode::showsGraphics())
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.createQueue(\"" + this->getName() +  "\", " + multi_cast<std::string>(this->getMaxSize()) + ")");
+    }
 …
+    {
         this->tickTime_ += dt; // Add the time interval that has passed to the time counter.
         if(this->tickTime_ >= 1.0) // If the time counter is greater than 1s all Notifications that have expired are removed, if it is smaller we wait to the next tick.
+        if(this->displayTime_ != INF && this->tickTime_ >= 1.0) // If the time counter is greater than 1s all Notifications that have expired are removed, if it is smaller we wait to the next tick.
+        {
             this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containig the current time.
 …
         Updates the NotificationQueue.
         Updates by clearing the queue and requesting all relevant Notifications from the NotificationManager and inserting them into the queue.
+        This is called by the NotificationManager when the Notifications have changed so much, that the NotificationQueue may have to re-initialize his operations.
     */
     void NotificationQueue::update(void)
 …
         std::multimap<std::time_t, Notification*>* notifications = new std::multimap<std::time_t, Notification*>;
         // Get the Notifications sent in the interval from now to now minus the display time.
+        NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
+        if(this->displayTime_ == INF)
+            NotificationManager::getInstance().getNewestNotifications(this, notifications, this->getMaxSize());
+        else
+            NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
         if(!notifications->empty())
 …
         this->notifications_.insert(this->notifications_.begin(), container);
+        // Push the Notification to the GUI.
+        if(GameMode::showsGraphics())
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
+        // Inform that a Notification was pushed.
+        this->notificationPushed(notification);
         COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
+        COUT(3) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
+    }
 …
         delete container;
+        // Pops the Notification from the GUI.
+        if(GameMode::showsGraphics())
+            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")");
+        // Inform that a Notification was popped.
+        this->notificationPopped();
+    }
 …
         delete *containerIterator;
         // Removes the Notification from the GUI.
         if(GameMode::showsGraphics())
             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");
+        // TODO: index automatically cast?
+        // Inform that a Notification was removed.
+        this->notificationRemoved(index);
+    }
 …
         Clears the NotificationQueue by removing all NotificationContainers.
     @param noGraphics
         If this is eset to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
+        If this is set to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
     */
     void NotificationQueue::clear(bool noGraphics)
 …
         this->notifications_.clear();
         this->size_ = 0;
-        // Clear the NotificationQueue in the GUI.
-        if(GameMode::showsGraphics() && !noGraphics)
-            GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");
+    }
 …
         Sets the maximum number of seconds a Notification is displayed.
     @param time
+        The number of seconds the Notifications is displayed.
+    @return
+        Returns true if successful.
+    */
+    void NotificationQueue::setDisplayTime(unsigned int time)
+        The number of seconds a Notification is displayed.
+    */
+    void NotificationQueue::setDisplayTime(int time)
+    {
         if(this->displayTime_ == time)
 …
     /**
     @brief
         Produces all targets of the NotificationQueue concatinated as string, with commas (',') as seperators.
+        Produces all targets of the NotificationQueue concatenated as string, with commas (',') as separators.
     @return
         Returns the targets as a string.
 …
         The targets are the senders whose Notifications are displayed in this queue.
     @param targets
         Accepts a string of targets, each seperated by commas (','), spaces are ignored.
+        Accepts a string of targets, each separated by commas (','), spaces are ignored.
     */
     void NotificationQueue::setTargets(const std::string & targets)
 …
             this->targets_.insert(string[i]);
+        // TODO: Why?
         if(this->registered_)
+        {
+            NotificationManager::getInstance().unregisterListener(this);
+            NotificationManager::getInstance().registerListener(this);
+        }
+            NotificationManager::getInstance().unregisterQueue(this);
+            NotificationManager::getInstance().registerQueue(this);
+        }
+    }
+    /**
+    @brief
+        Pops all Notifications from the NotificationQueue.
+    @return
+        Returns true if successful, false if not.
+    */
+    bool NotificationQueue::tidy(void)
+    {
+        while(this->size_ > 0)
+            this->pop();
+        return true;
+    }

code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.h

-                      r7552
+                      r8453
 #include "tools/interfaces/Tickable.h"
-#include "interfaces/NotificationListener.h"
 namespace orxonox // tolua_export
 { // tolua_export
+namespace orxonox
+{
     /**
 …
         Displays @ref orxonox::Notification "Notifications" from specific senders.
         There are quite some parameters that influence the behaviour of the NotificationQueue:
+        There are quite some parameters that influence the behavior of the NotificationQueue:
         - @b name The name of the NotificationQueue. It needs to be unique.
         - @b senders The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
 …
     @ingroup Notifications
     */
+    class _NotificationsExport NotificationQueue // tolua_export
+        : public Tickable, public NotificationListener
+    { // tolua_export
+    class _NotificationsExport NotificationQueue : public Tickable
+    {
         public:
             NotificationQueue(const std::string& name, const std::string& senders = NotificationManager::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
+            NotificationQueue(const std::string& name, const std::string& senders = NotificationListener::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
             virtual ~NotificationQueue();
-            //! Destroys the NotificationQueue.
-            void destroy(bool noGraphics = false); // tolua_export
             virtual void tick(float dt); //!< To update from time to time.
 …
                 { return this->maxSize_; }
             void setDisplayTime(unsigned int time); //!< Sets the maximum number of seconds a Notification is displayed.
+            void setDisplayTime(int time); //!< Sets the maximum number of seconds a Notification is displayed.
             /**
             @brief Returns the time interval the Notification is displayed.
             @return Returns the display time.
             */
             inline unsigned int getDisplayTime() const
+            inline int getDisplayTime() const
                 { return this->displayTime_; }
             // tolua_end
 …
                 { return this->targets_; }
-            // tolua_begin
             void setTargets(const std::string & targets); //!< Set the targets of this NotificationQueue.
+            const std::string& getTargets(void) const; //!< Returns a string consisting of the concatination of the targets.
+            // tolua_end
+            const std::string& getTargets(void) const; //!< Returns a string consisting of the concatenation of the targets.
+            bool tidy(void); // Pops all Notifications from the NotificationQueue.
+        protected:
+            /**
+            @brief Is called when a notification was pushed.
+            @param notification The Notification that was pushed.
+            */
+            virtual void notificationPushed(Notification* notification) {}
+            /**
+            @brief Is called when a notification was popped.
+            */
+            virtual void notificationPopped(void) {}
+            /**
+            @brief Is called when a notification was removed.
+            @param index The index the removed notification was at.
+            */
+            virtual void notificationRemoved(unsigned int index) {}
+            virtual void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.
+        protected:
+            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
+            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
+            static const int INF = -1; //!< Constant denoting infinity.
         private:
-            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
-            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
             std::string name_; //!< The name of the NotificationQueue.
             unsigned int maxSize_; //!< The maximal number of Notifications displayed.
             unsigned int size_; //!< The number of Notifications displayed.
             unsigned int displayTime_; //!< The time a Notification is displayed.
+            int displayTime_; //!< The time a Notification is displayed.
             bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already.
 …
             NotificationContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
-            void create(void); //!< Creates the NotificationQueue in lua.
             void setName(const std::string& name); //!< Sets the name of the NotificationQueue.
 …
             void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); //!< Removes the Notification that is stored in the input NotificationContainer.
             void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.
+    };
+    }; // tolua_export
+}
+} // tolua_export
+#endif /* _NotificationOverlay_H__ */
+#endif /* _NotificationQueue_H__ */

code/branches/tutoriallevel3/src/modules/objects/triggers/DistanceTrigger.cc

-                      r8213
+                      r8453
         Check whether the DistanceTrigger is triggered.
         It is triggered if it is triggered according only to its mode (i.e. its sub-triggers) and if a target is in range.
+    @param
+    @param mode
+        The mode for which it is tested, whether the DistanceTrigger is triggered.
+    @return
         Returns true if it is triggered ,false if not.
     */

code/branches/tutoriallevel3/src/modules/objects/triggers/DistanceTrigger.h

r8213	r8453
71	71	- @b target Which specifies the class of objects that can trigger the DistanceTrigger. Default is <code>"Pawn"</code>.
72	72	- @b beaconMode Which specifies, whether the DistanceTrigger operates on @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacons" or not. If <em>off</em> the DistanceMultiTrigger works as usual. If set to <em>identify</em> the DistanceTrigger is only triggered by objects that have a @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacon", with the same name as specified in <em>targetname</em>, attached to them. If set to <em>exclude</em> the DistanceTrigger is only triggered by objects that don't have a @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacon", with the same name as specified in <em>targetname</em>, attached to them. Default is <em>off</em>.
73		- @b targetname Which specifies the name @ref oroxnox::DistanceTriggerBeacon "DistanceTriggerBeacons" need to have to make the DistanceTrigger react to them if it is in <em>beacon-mode</em> (the beaconMode is not <em>off</em>).
	73	- @b targetname Which specifies the name @ref orxonox::DistanceTriggerBeacon "DistanceTriggerBeacons" need to have to make the DistanceTrigger react to them if it is in <em>beacon-mode</em> (the beaconMode is not <em>off</em>).
74	74
75	75	A simple DistanceTrigger could look like this:

code/branches/tutoriallevel3/src/modules/objects/triggers/EventTrigger.h

r8213	r8453
60	60
61	61	@see Trigger
62		For more information on @ref oroxnox::Trigger "Triggers".
	62	For more information on @ref orxonox::Trigger "Triggers".
63	63
64	64	@author

code/branches/tutoriallevel3/src/modules/objects/triggers/MultiTrigger.cc

r8213	r8453
198	198	if(bActive ^ this->isActive(state->originator))
199	199	{
200
201	200	bool bFire = true;
202	201

code/branches/tutoriallevel3/src/modules/objects/triggers/TriggerBase.h

-                      r8213
+                      r8453
             inline int getActivations(void) const
                 { return this->remainingActivations_; }
+            /**
+            @brief Check whether the trigger has still at least one remaining activation.
+            @return Returns true if the trigger has remaining activations (i.e. the number of remaining activations is not zero).
+            */
+            inline bool hasRemainingActivations(void) const
+                { return this->remainingActivations_ > 0 || this->remainingActivations_ == INF_s; }
             /**

code/branches/tutoriallevel3/src/modules/overlays/hud/CMakeLists.txt

r8178	r8453
7	7	HUDTimer.cc
8	8	ChatOverlay.cc
9		~~GametypeStatus.cc~~
10	9	AnnounceMessage.cc
11	10	KillMessage.cc

code/branches/tutoriallevel3/src/modules/questsystem/QuestDescription.cc

-                      r7474
+                      r8453
 #include "infos/PlayerInfo.h"
 #include "notifications/NotificationManager.h"
+#include "interfaces/NotificationListener.h"
 namespace orxonox
 …
+        }
         NotificationManager::sendNotification(message, player->getClientID(), QuestDescription::SENDER);
+        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
         return true;
+    }

code/branches/tutoriallevel3/src/modules/questsystem/QuestManager.cc

-                      r8079
+                      r8453
     int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
+    {
+        if(quest == NULL)
+            return this->getNumRootQuests(player);
         std::list<Quest*> quests = quest->getSubQuestList();
         int numQuests = 0;
 …
     Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
+    {
+        if(quest == NULL)
+            return this->getRootQuest(player, index);
         std::list<Quest*> quests = quest->getSubQuestList();
         for(std::list<Quest*>::iterator it = quests.begin(); it != quests.end(); it++)
 …
     @param player
         The player.
+    @return Returns the number of QuestHints of the input Quest for the input player.
+    @return
+        Returns the number of QuestHints of the input Quest for the input player.
     */
     int QuestManager::getNumHints(Quest* quest, PlayerInfo* player)
 …
     @param index
         The index of the QuestHint.
+    @return
+        Returns a pointer to the index-th QuestHint of the input Quest for the input player.
     */
     QuestHint* QuestManager::getHints(Quest* quest, PlayerInfo* player, int index)
 …
+        }
         return NULL;
+    }
+    /**
+    @brief
+        Get the parent-quest of the input Quest.
+    @param quest
+        The Quest to get the parent-quest of.
+    @return
+        Returns a pointer to the parent-quest of the input Quest.
+    */
+    Quest* QuestManager::getParentQuest(Quest* quest)
+    {
+        return quest->getParentQuest();
+    }
 …
     /**
     @brief
+        Get the id of the input Quest.
+    @param item
+        The Quest to get the id of.
+    @return
+        Returns the id of the input Quest.
+    */
+    const std::string QuestManager::getId(Quest* item) const
+    {
+        return item->getId();
+    }
+    /**
+    @brief
+        Get the id of the input QuestHint.
+    @param item
+        The QuestHint to get the id of.
+    @return
+        Returns the id of the input QuestHint.
+    */
+    const std::string QuestManager::getId(QuestHint* item) const
+    {
+        return item->getId();
+    }
+    /**
+    @brief
         Retrieve the player for a certain GUI.
     @param guiName

code/branches/tutoriallevel3/src/modules/questsystem/QuestManager.h

-                      r7552
+                      r8453
             QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index); //!< Get the index-th QuestHint of the input Quest for the input player.
+            QuestDescription* getDescription(Quest* item);
+            QuestDescription* getDescription(QuestHint* item);
+            Quest* getParentQuest(Quest* quest); //!< Get the parent-quest of the input Quest.
+            QuestDescription* getDescription(Quest* item); //!< Get the QuestDescription of the input Quest.
+            QuestDescription* getDescription(QuestHint* item); //!< Get the QuestDescription of the input QuestHint.
+            const std::string getId(Quest* item) const; //!< Get the id of the input Quest.
+            const std::string getId(QuestHint* item) const; //!< Get the id of the input QuestHint.
             // tolua_end

code/branches/tutoriallevel3/src/orxonox/LevelManager.cc

r8079	r8453
222	222	this->nextLevel_ = this->availableLevels_.begin();
223	223	}
	224
224	225	while(this->nextIndex_ != index)
225	226	{

code/branches/tutoriallevel3/src/orxonox/gametypes/Gametype.cc

-                      r8327
+                      r8453
         this->defaultControllableEntity_ = Class(Spectator);
+        this->bFirstTick_ = true;
         this->bAutoStart_ = false;
         this->bForceSpawn_ = false;
 …
         SUPER(Gametype, tick, dt);
+        // Activate the GametypeInfo.
+        if(this->bFirstTick_)
+        {
+            this->gtinfo_->setActive(true);
+            this->bFirstTick_ = false;
+        }
         //count timer
         if (timerIsActive_)
 …
+        }
         if (this->gtinfo_->bStartCountdownRunning_ && !this->gtinfo_->bStarted_)
             this->gtinfo_->startCountdown_ -= dt;
         if (!this->gtinfo_->bStarted_)
+        if (this->gtinfo_->isStartCountdownRunning() && !this->gtinfo_->hasStarted())
+            this->gtinfo_->countdownStartCountdown(dt);
+        if (!this->gtinfo_->hasStarted())
             this->checkStart();
         else if (!this->gtinfo_->bEnded_)
+        else if (!this->gtinfo_->hasEnded())
             this->spawnDeadPlayersIfRequested();
 …
         this->addBots(this->numberOfBots_);
         this->gtinfo_->bStarted_ = true;
+        this->gtinfo_->start();
         this->spawnPlayersIfRequested();
 …
     void Gametype::end()
+    {
         this->gtinfo_->bEnded_ = true;
+        this->gtinfo_->end();
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
 …
+                }
+                if(victim->getPlayer()->isHumanPlayer())
+                    this->gtinfo_->pawnKilled(victim->getPlayer());
                 ControllableEntity* entity = this->defaultControllableEntity_.fabricate(victim->getCreator());
                 if (victim->getCamera())
 …
                 it->second.state_ = PlayerState::Dead;
                 if (!it->first->isReadyToSpawn() || !this->gtinfo_->bStarted_)
+                if (!it->first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
+                {
                     this->spawnPlayerAsDefaultPawn(it->first);
 …
     void Gametype::checkStart()
+    {
         if (!this->gtinfo_->bStarted_)
+        {
             if (this->gtinfo_->bStartCountdownRunning_)
+            {
                 if (this->gtinfo_->startCountdown_ <= 0)
+                {
                     this->gtinfo_->bStartCountdownRunning_ = false;
                     this->gtinfo_->startCountdown_ = 0;
+        if (!this->gtinfo_->hasStarted())
+        {
+            if (this->gtinfo_->isStartCountdownRunning())
+            {
+                if (this->gtinfo_->getStartCountdown() <= 0.0f)
+                {
+                    this->gtinfo_->stopStartCountdown();
+                    this->gtinfo_->setStartCountdown(0.0f);;
                     this->start();
+                }
 …
                         if (it->first->isHumanPlayer())
                             hashumanplayers = true;
+                        // Inform the GametypeInfo that the player is ready to spawn.
+                        // TODO: Can it happen, that that changes?
+                        if(it->first->isHumanPlayer() && it->first->isReadyToSpawn())
+                            this->gtinfo_->playerReadyToSpawn(it->first);
+                    }
                     if (allplayersready && hashumanplayers)
 …
                         // If in developer's mode, there is no start countdown.
                         if(Core::getInstance().inDevMode())
                             this->gtinfo_->startCountdown_ = 0;
+                            this->start();
                         else
                             this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
                         this->gtinfo_->bStartCountdownRunning_ = true;
+                            this->gtinfo_->setStartCountdown(this->initialStartCountdown_);
+                        this->gtinfo_->startStartCountdown();
+                    }
+                }
 …
+    {
         for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
+        {
             if (it->first->isReadyToSpawn() || this->bForceSpawn_)
                 this->spawnPlayer(it->first);
+        }
+    }
 …
             player->startControl(spawnpoint->spawn());
             this->players_[player].state_ = PlayerState::Alive;
+            if(player->isHumanPlayer())
+                this->gtinfo_->playerSpawned(player);
             this->playerPostSpawn(player);
+        }

code/branches/tutoriallevel3/src/orxonox/gametypes/Gametype.h

-                      r8178
+                      r8453
             inline bool hasStarted() const
                 { return this->gtinfo_->bStarted_; }
+                { return this->gtinfo_->hasStarted(); }
             inline bool hasEnded() const
                 { return this->gtinfo_->bEnded_; }
+                { return this->gtinfo_->hasEnded(); }
             virtual void start();
 …
             inline bool isStartCountdownRunning() const
                 { return this->gtinfo_->bStartCountdownRunning_; }
+                { return this->gtinfo_->isStartCountdownRunning(); }
             inline float getStartCountdown() const
                 { return this->gtinfo_->startCountdown_; }
+                { return this->gtinfo_->getStartCountdown(); }
             inline void setHUDTemplate(const std::string& name)
                 { this->gtinfo_->hudtemplate_ = name; }
+                { this->gtinfo_->setHUDTemplate(name); }
             inline const std::string& getHUDTemplate() const
                 { return this->gtinfo_->hudtemplate_; }
+                { return this->gtinfo_->getHUDTemplate(); }
             void addBots(unsigned int amount);
 …
             SmartPtr<GametypeInfo> gtinfo_;
+            bool bFirstTick_; //!< Whether this is the first tick or not.
             bool bAutoStart_;
             bool bForceSpawn_;

code/branches/tutoriallevel3/src/orxonox/infos/GametypeInfo.cc

-                      r8327
+                      r8453
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Damian 'Mozork' Frick
+ *
  */
+/**
+    @file GametypeInfo.cc
+    @brief Implementation of the GametypeInfo class
+*/
 #include "GametypeInfo.h"
 …
 #include "core/CoreIncludes.h"
 #include "core/GameMode.h"
+#include "network/Host.h"
 #include "network/NetworkFunction.h"
+#include "network/Host.h"
+#include "util/Convert.h"
 #include "interfaces/GametypeMessageListener.h"
+#include "interfaces/NotificationListener.h"
+#include "PlayerInfo.h"
 namespace orxonox
 …
     registerMemberNetworkFunction(GametypeInfo, dispatchFadingMessage);
+    /*static*/ const std::string GametypeInfo::NOTIFICATION_SENDER("gameinfo");
+    /**
+    @brief
+        Registers and initializes the object.
+    */
     GametypeInfo::GametypeInfo(BaseObject* creator) : Info(creator)
+    {
         RegisterObject(GametypeInfo);
+        this->bActive_ = false; // At first the GametypeInfo is inactive.
         this->bStarted_ = false;
         this->bEnded_ = false;
         this->startCountdown_ = 0;
+        this->startCountdown_ = 0.0f;
         this->bStartCountdownRunning_ = false;
+        this->counter_ = 0;
         this->registerVariables();
 …
     void GametypeInfo::registerVariables()
+    {
+        registerVariable(this->bStarted_,               VariableDirection::ToClient);
+        registerVariable(this->bEnded_,                 VariableDirection::ToClient);
+        registerVariable(this->bStarted_,               VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStarted));
+        registerVariable(this->bEnded_,                 VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedEnded));
+        registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStartCountdownRunning));
         registerVariable(this->startCountdown_,         VariableDirection::ToClient);
         registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient);
+        registerVariable(this->counter_,                VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedCountdownCounter));
         registerVariable(this->hudtemplate_,            VariableDirection::ToClient);
+    }
+    /**
+    @brief
+        Is called when the activity has changed.
+    */
+    void GametypeInfo::changedActivity(void)
+    {
+        SUPER(GametypeInfo, changedActivity);
+        // If the GametypeInfo has become active the "Press [Fire] to start the match" notification is sent.
+        if(this->isActive())
+            NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER);
+    }
+    /**
+    @brief
+        Is called when the game has changed to started.
+    */
+    void GametypeInfo::changedStarted(void)
+    {
+    }
+    /**
+    @brief
+        Is called when the game has changed to ended.
+    */
+    void GametypeInfo::changedEnded(void)
+    {
+        // If the game has ended, a "Game has ended" notification is displayed.
+        if(this->hasEnded())
+            NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER);
+    }
+    /**
+    @brief
+        Is called when the start countdown has been either started or stopped.
+    */
+    void GametypeInfo::changedStartCountdownRunning(void)
+    {
+        // Clear the notifications if the countdown has stopped running.
+        if(!this->hasStarted() && !this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER);
+        // Send first countdown notification if the countdown has started.
+        if(!this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
+    }
+    /**
+    @brief
+        Is called when the start countdown counter has changed.
+    */
+    void GametypeInfo::changedCountdownCounter(void)
+    {
+        // Send countdown notification if the counter has gone down.
+        if(!this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
+    }
+    /**
+    @brief
+        Is called when a player has become ready to spawn.
+    @param player
+        The player that has become ready to spawn.
+    */
+    void GametypeInfo::changedReadyToSpawn(PlayerInfo* player)
+    {
+        // Send "Waiting for other players" over the network to the right player if a player has become ready to spawn.
+        if(!this->hasStarted() && !this->isStartCountdownRunning() && !this->hasEnded())
+            NotificationListener::sendNotification("Waiting for other players", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+        // Clear the notifications if the player has respawned.
+        if(this->hasStarted() && !this->hasEnded())
+            NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER, notificationSendMode::network, player->getClientID());
+    }
+    /**
+    @brief
+        Inform the GametypeInfo that the game has started.
+    */
+    void GametypeInfo::start(void)
+    {
+        if(this->bStarted_)
+            return;
+        this->bStarted_ = true;
+        this->changedStarted();
+    }
+    /**
+    @brief
+        Inform the GametypeInfo that the game has ended.
+    */
+    void GametypeInfo::end(void)
+    {
+        if(this->bEnded_)
+            return;
+        this->bEnded_ = true;
+        this->changedEnded();
+    }
+    /**
+    @brief
+        Set the start countdown to the input value.
+    @param countdown
+        The countdown to be set.
+    */
+    void GametypeInfo::setStartCountdown(float countdown)
+    {
+        if(this->startCountdown_ == countdown || countdown < 0.0f)
+            return;
+        this->startCountdown_ = countdown;
+        // Set the counter to the ceiling of the current countdown.
+        this->counter_ = ceil(countdown);
+        this->changedCountdownCounter();
+    }
+    /**
+    @brief
+        Count down the start countdown by the specified value.
+    @param countDown
+        The amount by which we count down.
+    */
+    void GametypeInfo::countdownStartCountdown(float countDown)
+    {
+        float newCountdown = this->startCountdown_ - countDown;
+        // If we have switched integers or arrived at zero, we also count down the start countdown counter.
+        if(ceil(newCountdown) != ceil(this->startCountdown_) || newCountdown <= 0.0f)
+            this->countDown();
+        this->startCountdown_ = newCountdown;
+    }
+    /**
+    @brief
+        Count down the start countdown counter.
+    */
+    void GametypeInfo::countDown()
+    {
+        if(this->counter_ == 0)
+            return;
+        this->counter_--;
+        this->changedCountdownCounter();
+    }
+    /**
+    @brief
+        Inform the GametypeInfo about the start of the start countdown.
+    */
+    void GametypeInfo::startStartCountdown(void)
+    {
+        if(this->bStartCountdownRunning_)
+            return;
+        this->bStartCountdownRunning_ = true;
+        this->changedStartCountdownRunning();
+    }
+    /**
+    @brief
+        Inform the GametypeInfo about the stop of the start countdown.
+    */
+    void GametypeInfo::stopStartCountdown(void)
+    {
+        if(!this->bStartCountdownRunning_)
+            return;
+        this->bStartCountdownRunning_ = false;
+        this->changedStartCountdownRunning();
+    }
+    /**
+    @brief
+        Inform the GametypeInfo about a player that is ready to spawn.
+    @param player
+        The player that is ready to spawn.
+    */
+    void GametypeInfo::playerReadyToSpawn(PlayerInfo* player)
+    {
+        // If the player has spawned already.
+        if(this->spawned_.find(player) != this->spawned_.end())
+            return;
+        this->spawned_.insert(player);
+        this->changedReadyToSpawn(player);
+    }
+    /**
+    @brief
+        Inform the GametypeInfo about a player whose Pawn has been killed.
+    @param player
+        The player whose Pawn has been killed.
+    */
+    void GametypeInfo::pawnKilled(PlayerInfo* player)
+    {
+        NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
+        // Remove the player from the list of players that have spawned, since it currently is not.
+        this->spawned_.erase(player);
+    }
+    /**
+    @brief
+        Inform the GametypeInfo about a player that has spawned.
+    @param player
+        The player that has spawned.
+    */
+    void GametypeInfo::playerSpawned(PlayerInfo* player)
+    {
+        if(this->hasStarted() && !this->hasEnded())
+            NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER, notificationSendMode::network, player->getClientID());
+    }

code/branches/tutoriallevel3/src/orxonox/infos/GametypeInfo.h

-                      r7163
+                      r8453
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Damian 'Mozork' Frick
+ *
  */
+/**
+    @file GametypeInfo.h
+    @brief Definition of the GametypeInfo class
+*/
 #ifndef _GametypeInfo_H__
 …
 #include <string>
 #include "Info.h"
 namespace orxonox
+{
+    /**
+    @brief
+        The GametypeInfo class keeps track of the state of the game and provides facilities to inform the player about it.
+    @author
+        Fabian 'x3n' Landau
+    @author
+        Damian 'Mozork' Frick
+    */
     class _OrxonoxExport GametypeInfo : public Info
+    {
 …
             virtual ~GametypeInfo();
+            virtual void changedActivity(void); // Is called when the activity has changed.
+            /**
+            @brief Get whether the game has started yet.
+            @return Returns true if the game has started, false if not.
+            */
             inline bool hasStarted() const
                 { return this->bStarted_; }
+            void changedStarted(void); // Is called when the game has changed to started.
+            /**
+            @brief Get whether the game has ended yet.
+            @return Returns true if the game has ended, false if not.
+            */
             inline bool hasEnded() const
                 { return this->bEnded_; }
+            void changedEnded(void); // Is called when the game has changed to ended.
+            /**
+            @brief Get whether the start countdown is currently running.
+            @return Returns true if the countdown is running, false if not.
+            */
             inline bool isStartCountdownRunning() const
                 { return this->bStartCountdownRunning_; }
+            void changedStartCountdownRunning(void); // Is called when the start countdown has been either started or stopped.
+            /**
+            @brief Get the current value of the start countdown.
+            @return Returns the current value of the start countdown.
+            */
             inline float getStartCountdown() const
                 { return this->startCountdown_; }
+            /**
+            @brief Get the current start countdown counter.
+                   The start countdown counter only has integer values that correspond to the actually displayed countdown.
+            @return Returns the current integer countdown counter.
+            */
+            inline unsigned int getStartCountdownCounter() const
+                { return this->counter_; }
+            void changedCountdownCounter(void); // Is called when the start countdown counter has changed.
             inline const std::string& getHUDTemplate() const
 …
             void dispatchStaticMessage(const std::string& message,const ColourValue& colour);
             void dispatchFadingMessage(const std::string& message);
+        protected:
+            void changedReadyToSpawn(PlayerInfo* player); // Is called when a player has become ready to spawn.
+            void start(void); // Inform the GametypeInfo that the game has started.
+            void end(void); // Inform the GametypeInfo that the game has ended.
+            void setStartCountdown(float countdown); // Set the start countdown to the input value.
+            void countdownStartCountdown(float countDown); // Count down the start countdown by the specified value.
+            void countDown(); // Count down the start countdown counter.
+            void startStartCountdown(void); // Inform the GametypeInfo about the start of the start countdown.
+            void stopStartCountdown(void); // Inform the GametypeInfo about the stop of the start countdown.
+            void playerReadyToSpawn(PlayerInfo* player); // Inform the GametypeInfo about a player that is ready to spawn.
+            void pawnKilled(PlayerInfo* player); // Inform the GametypeInfo about a player whose Pawn has been killed.
+            void playerSpawned(PlayerInfo* player); // Inform the GametypeInfo about a player that has spawned.
+            inline void setHUDTemplate(const std::string& templateName)
+                { this->hudtemplate_ = templateName; };
         private:
             void registerVariables();
+            bool bStarted_;
+            bool bEnded_;
+            bool bStartCountdownRunning_;
+            float startCountdown_;
+            static const std::string NOTIFICATION_SENDER; //!< The name of the sender for the sending of notifications.
+            bool bStarted_; //!< Whether the game has started,
+            bool bEnded_; //!< Whether the game has ended.
+            bool bStartCountdownRunning_; //!< Whether the start countdown is running.
+            float startCountdown_; //!< The current value of the start countdown.
+            unsigned int counter_; //!< The current integer value of the start countdown, the start countdown counter.
             std::string hudtemplate_;
+            std::set<PlayerInfo*> spawned_; //!< A set of players that are currently spawned.
     };
+}

code/branches/tutoriallevel3/src/orxonox/interfaces/CMakeLists.txt

r7504	r8453
1	1	ADD_SOURCE_FILES(ORXONOX_SRC_FILES
2	2	InterfaceCompilation.cc
	3	NotificationListener.cc
3	4	Pickupable.cc
4	5	PickupCarrier.cc

code/branches/tutoriallevel3/src/orxonox/interfaces/InterfaceCompilation.cc

-                      r7606
+                      r8453
         RegisterRootObject(Rewardable);
+    }
-    //----------------------------
-    // NotificationListener
-    //----------------------------
-    NotificationListener::NotificationListener()
+    {
-        RegisterRootObject(NotificationListener);
+    }
+}

code/branches/tutoriallevel3/src/orxonox/interfaces/NotificationListener.h

-                      r7552
+                      r8453
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Damian 'Mozork' Frick
  *   Co-authors:
  *      ...
 …
 namespace orxonox
+{
+    class Notification;
+    // TODO: Document.
+    namespace notificationMessageType
+    {
+        enum Value {
+            info,
+            important
+        };
+    }
+    namespace notificationSendMode
+    {
+        enum Value {
+            local,
+            network,
+            broadcast
+        };
+    }
+    namespace notificationCommand
+    {
+        enum Value {
+            none,
+            clear
+        };
+    }
+    // TODO: Update doc.
     /**
     @brief
         NotificationListener interface.
+        The NotificationListener interface presents a means to being informed when @ref orxonox::Notification "Notifications" in the target set of this NotificationListener change. (e.g. @ref orxonox::Notification "Notifications" were added or removed)
+        When inheriting from a NotificationListener it is important to register (in the constructor) and unregister (in the destructor) it to and from the @ref orxonox::NotificationManager "NotificationManager".
+        The NotificationListener interface (or more precisely abstract class) presents a means of being informed when a new @ref orxonox::Notification "Notification" is sent.
+        The NotificationListener can be used to send a new notification message (with NotificationListener::sendNotification() ) or a new notification command (with NotificationListener::sendCommand() ). Each NotificationListener is then informed about the new @ref orxonox::Notification "Notification" and can take appropriate action. Currently the only NotificationListener ist the @ref orxonox::NotificationManager "NotificationManager" singleton.
+        When inheriting from a NotificationListener it is important to provide an appropriate implementation of registerNotification() and executeCommand().
     @author
         Fabian 'x3n' Landau
+        Damian 'Mozork' Frick
     @ingroup Notifications
+    @todo Consistent terminology between message, notification and command.
     */
     class _OrxonoxExport NotificationListener : virtual public OrxonoxClass
 …
             /**
+            @brief Get the senders that are targets of this NotificationListener.
+            @return Returns the set of senders that are targets of this NotificationListener.
+            @brief Sends a Notification with the specified message to the specified client from the specified sender.
+            @param message The message that should be sent.
+            @param sender The sender that sent the notification. Default is 'none'.
+            @param messageType The type of the message, can be either 'info' or 'important'. Default is 'info'.
+            @param sendMode The mode in which the notification is sent, can be 'local' to send the notification to the client where this function is executed, 'network' if the notification is to be sent to the client with the specified clientID, or 'broadcast' if the notification should be sent to all hosts. Default is notificationSendMode::local.
+            @param clientId The id of the client the notification should be sent to. Default is 0.
             */
+            virtual const std::set<std::string> & getTargetsSet(void) = 0;
+            static void sendNotification(const std::string& message, const std::string& sender = NotificationListener::NONE, notificationMessageType::Value messageType = notificationMessageType::info, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+                { NotificationListener::sendNetworkHelper(message, sender, sendMode, clientId, false, messageType); }
+            /**
+            @brief Sends a specified command to the specified client from the specified sender.
+            @param command The command that should be sent (and later executed).
+            @param sender The sender that sent the notification. Default is 'none'.
+            @param sendMode The mode in which the command is sent, can be 'local' to send the command to the client where this function is executed, 'network' if the command is to be sent to the client with the specified clientID, or 'broadcast' if the command should be sent to all hosts. Default is notificationSendMode::local.
+            @param clientId The id of the client the command should be sent to. Default is 0.
+            */
+            static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
+                { NotificationListener::sendNetworkHelper(command, sender, sendMode, clientId, true); }
+            static void sendHelper(const std::string& message, const std::string& sender, bool isCommand = false, unsigned int messageMode = 0); // Helper method to register a notification/execute a command with all NotificationListeners after it has been sent over the network.
+            //TODO: Make protected?
             /**
+            @brief Updates the whole NotificationListener.
+                   This is called by the @ref orxonox::NotificationManager "NotificationManager" when the @ref orxonox::Notification "Notifications" have changed so much, that the NotificationListener may have to re-initialize his operations.
+            @brief Registers a notification with the NotificationListener.
+                   This needs to be overloaded by each class inheriting from NotificationListener.
+            @param message The notification's message.
+            @param sender The sender of the notification.
+            @param type The type of the notification.
+            @return Returns true if the notification was successfully registered, false if not.
             */
+            virtual void update(void) = 0;
+            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
+                { return false; }
             /**
+            @brief Updates the NotificationListener, when a new Notification has come in at the specified time.
+            @param notification A pointer to the @ref orxonox::Notification "Notification".
+            @param time The time the @ref orxonox::Notification "Notification" has come in.
+            @brief Executes a command with the NotificationListener
+                   This needs to be overloaded by each class inheriting from NotificationListener.
+            @param command The command to be executed.
+            @param sender The sender of the command.
+            @return Returns true if the command was successfully executed, false if not.
             */
+            virtual void update(Notification* notification, const std::time_t & time) = 0;
+            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) { return false; }
+        public:
+            static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationQueues.
+            static const std::string NONE; //!< Static string to indicate a sender that sends to no specific NotificationQueues.
+            //! Commands
+            static const std::string COMMAND_CLEAR;
+            static const std::string COMMAND_NONE;
+        protected:
+            static void sendNetworkHelper(const std::string& message, const std::string& sender, notificationSendMode::Value sendMode, unsigned int clientId, bool isCommand = false, notificationMessageType::Value messageType = notificationMessageType::info); // Helper method to send both notifications and commands over the network.
+            static notificationCommand::Value str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
+            static const std::string& command2Str(notificationCommand::Value command); // Helper method. Converts a command enum into its corresponding string.
     };
+}

Context Navigation

Legend:

code/branches/tutoriallevel3

code/branches/tutoriallevel3/src/libraries/core/GUIManager.cc

code/branches/tutoriallevel3/src/libraries/core/GUIManager.h

code/branches/tutoriallevel3/src/libraries/network/synchronisable/Synchronisable.cc

code/branches/tutoriallevel3/src/libraries/util/SubString.h

code/branches/tutoriallevel3/src/modules/notifications/CMakeLists.txt

code/branches/tutoriallevel3/src/modules/notifications/NotificationDispatcher.cc

code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.cc

code/branches/tutoriallevel3/src/modules/notifications/NotificationManager.h

code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.cc

code/branches/tutoriallevel3/src/modules/notifications/NotificationQueue.h

code/branches/tutoriallevel3/src/modules/objects/triggers/DistanceTrigger.cc

code/branches/tutoriallevel3/src/modules/objects/triggers/DistanceTrigger.h

code/branches/tutoriallevel3/src/modules/objects/triggers/EventTrigger.h

code/branches/tutoriallevel3/src/modules/objects/triggers/MultiTrigger.cc

code/branches/tutoriallevel3/src/modules/objects/triggers/TriggerBase.h

code/branches/tutoriallevel3/src/modules/overlays/hud/CMakeLists.txt

code/branches/tutoriallevel3/src/modules/questsystem/QuestDescription.cc

code/branches/tutoriallevel3/src/modules/questsystem/QuestManager.cc

code/branches/tutoriallevel3/src/modules/questsystem/QuestManager.h

code/branches/tutoriallevel3/src/orxonox/LevelManager.cc

code/branches/tutoriallevel3/src/orxonox/gametypes/Gametype.cc

code/branches/tutoriallevel3/src/orxonox/gametypes/Gametype.h

code/branches/tutoriallevel3/src/orxonox/infos/GametypeInfo.cc

code/branches/tutoriallevel3/src/orxonox/infos/GametypeInfo.h

code/branches/tutoriallevel3/src/orxonox/interfaces/CMakeLists.txt

code/branches/tutoriallevel3/src/orxonox/interfaces/InterfaceCompilation.cc

code/branches/tutoriallevel3/src/orxonox/interfaces/NotificationListener.h

Download in other formats:

/code/branches/tutoriallevel (added)	merged: 7828-7831,7894,8370
/code/branches/tutoriallevel2 (added)	merged: 8371,8374,8376-8378,8444-8451