Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 28, 2011, 5:10:01 PM (13 years ago)
Author:
dafrick
Message:

Merging tutoriallevel3 branch into presentation branch.

Location:
code/branches/presentation
Files:
4 deleted
27 edited
3 copied

Legend:

Unmodified
Added
Removed
  • code/branches/presentation

  • code/branches/presentation/src/libraries/core/GUIManager.cc

    r8627 r8637  
    3838#include <CEGUIDefaultLogger.h>
    3939#include <CEGUIExceptions.h>
     40#include <CEGUIFontManager.h>
    4041#include <CEGUIInputEvent.h>
    4142#include <CEGUIMouseCursor.h>
     
    4445#include <CEGUIWindow.h>
    4546#include <CEGUIWindowManager.h>
     47#include <CEGUIXMLAttributes.h>
    4648#include <elements/CEGUIListbox.h>
    4749#include <elements/CEGUIListboxItem.h>
     
    729731    }
    730732
     733    /**
     734    @brief
     735        Adds a new freetype font to the CEGUI system.
     736    @param name
     737        The name of the new font.
     738    @param size
     739        The font size of the new font in pixels.
     740        @param fontName
     741        The filename of the font.
     742    */
     743    /*static*/ void GUIManager::addFontHelper(const std::string& name, int size, const std::string& fontName)
     744    {
     745        if(CEGUI::FontManager::getSingleton().isFontPresent(name)) // If a font with that name already exists.
     746            return;
     747
     748        CEGUI::Font* font = NULL;
     749        CEGUI::XMLAttributes xmlAttributes;
     750
     751        // Attributes specified within CEGUIFont
     752        xmlAttributes.add("Name", name);
     753        xmlAttributes.add("Filename", fontName);
     754        xmlAttributes.add("ResourceGroup", "");
     755        xmlAttributes.add("AutoScaled", "true");
     756        xmlAttributes.add("NativeHorzRes", "800");
     757        xmlAttributes.add("NativeVertRes", "600");
     758
     759        // Attributes specified within CEGUIXMLAttributes
     760        xmlAttributes.add("Size", multi_cast<std::string>(size));
     761        xmlAttributes.add("AntiAlias", "true");
     762
     763        font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
     764        if(font != NULL)
     765            font->load();
     766    }
     767
    731768}
  • code/branches/presentation/src/libraries/core/GUIManager.h

    r8627 r8637  
    128128
    129129        // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work
    130         static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); //tolua_export
    131         static void setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& toooltip); //tolua_export
    132         static void setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled); //tolua_export
     130        static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); // tolua_export
     131        static void setTooltipTextHelper(CEGUI::ListboxItem* item, const std::string& toooltip); // tolua_export
     132        static void setItemTooltipsEnabledHelper(CEGUI::Listbox* listbox, bool enabled); // tolua_export
     133        static void addFontHelper(const std::string& name, int size, const std::string& fontName); // tolua_export
    133134
    134135        static GUIManager& getInstance() { return Singleton<GUIManager>::getInstance(); } // tolua_export
  • code/branches/presentation/src/libraries/network/synchronisable/Synchronisable.cc

    r8329 r8637  
    383383  /**
    384384   * This function determines, wheter the object should be saved to the bytestream (according to its syncmode/direction)
    385    * @param id gamestate id
    386385   * @param mode Synchronisation mode (toclient, toserver or bidirectional)
    387386   * @return true/false
     
    397396  /**
    398397   * This function determines, wheter the object should accept data from the bytestream (according to its syncmode/direction)
    399    * @param id gamestate id
    400398   * @param mode Synchronisation mode (toclient, toserver or bidirectional)
    401399   * @return true/false
  • code/branches/presentation/src/modules/notifications/CMakeLists.txt

    r7403 r8637  
    11SET_SOURCE_FILES(NOTIFICATIONS_SRC_FILES
    2   Notification.cc
    32  NotificationDispatcher.cc
    43  NotificationManager.cc
    54  NotificationQueue.cc
     5  NotificationQueueCEGUI.cc
    66)
    77
     
    1313  TOLUA_FILES
    1414    NotificationManager.h
    15     NotificationQueue.h
     15    NotificationQueueCEGUI.h
    1616  PCH_FILE
    1717    NotificationsPrecompiledHeaders.h
  • code/branches/presentation/src/modules/notifications/NotificationDispatcher.cc

    r7552 r8637  
    4141
    4242#include "infos/PlayerInfo.h"
     43#include "interfaces/NotificationListener.h"
    4344#include "interfaces/PlayerTrigger.h"
    4445#include "worldentities/pawns/Pawn.h"
    45 
    46 #include "NotificationManager.h"
    4746
    4847namespace orxonox
     
    6160        RegisterObject(NotificationDispatcher);
    6261
    63         this->sender_ = NotificationManager::NONE;
     62        this->sender_ = NotificationListener::NONE;
    6463        this->registerVariables();
    6564    }
     
    114113        {
    115114            const std::string message = this->createNotificationMessage();
    116             NotificationManager::sendNotification(message, clientId, this->getSender());
     115            // TODO: Make the type configurable.
     116            NotificationListener::sendNotification(message, this->getSender(), notificationMessageType::info, notificationSendMode::network, clientId);
    117117        }
    118118        else if(GameMode::isServer())
     
    164164        if(player == NULL)
    165165        {
    166             COUT(3) << "The PlayerInfo* is NULL." << std::endl;
     166            CCOUT(3) << "The PlayerInfo* is NULL." << std::endl;
    167167            return false;
    168168        }
  • code/branches/presentation/src/modules/notifications/NotificationManager.cc

    r8079 r8637  
    3636#include "core/command/ConsoleCommand.h"
    3737#include "core/CoreIncludes.h"
    38 #include "core/GUIManager.h"
    3938#include "core/LuaState.h"
    40 #include "network/Host.h"
    41 #include "network/NetworkFunction.h"
    4239#include "util/ScopedSingletonManager.h"
    4340
    4441#include "interfaces/NotificationListener.h"
    4542
    46 #include "Notification.h"
    4743#include "NotificationQueue.h"
    48 
    49 #include "ToluaBindNotifications.h"
     44#include "NotificationQueueCEGUI.h"
    5045
    5146namespace orxonox
    5247{
    5348
    54     const std::string NotificationManager::ALL("all");
    55     const std::string NotificationManager::NONE("none");
    56 
    57     // Register tolua_open function when loading the library.
    58     DeclareToluaInterface(Notifications);
    59 
    6049    ManageScopedSingleton(NotificationManager, ScopeID::Root, false);
    6150
    62     // Setting console command to enter the edit mode.
    63     SetConsoleCommand("enterEditMode", &NotificationManager::enterEditMode);
    64 
    65     registerStaticNetworkFunction(NotificationManager::sendNotification);
    66 
    6751    /**
    6852    @brief
     
    7357        RegisterRootObject(NotificationManager);
    7458
    75         this->highestIndex_ = 0;
    76 
    77         ModifyConsoleCommand("enterEditMode").setObject(this);
    78 
    7959        COUT(3) << "NotificatioManager created." << std::endl;
    8060    }
     
    8666    NotificationManager::~NotificationManager()
    8767    {
    88         ModifyConsoleCommand("enterEditMode").setObject(NULL);
    89 
    9068        // Destroys all Notifications.
    9169        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it!= this->allNotificationsList_.end(); it++)
     
    10684        while(it != this->queues_.end())
    10785        {
    108             it->second->destroy(true);
     86            it->second->destroy();
    10987            it = this->queues_.begin();
    11088        }
     
    11593    /**
    11694    @brief
    117         Sends a Notification with the specified message to the specified client from the specified sender.
     95        Creates and registers a Notification with the input message from the input sender.
     96        This is called by the NotificationListener, whenever a new notification arrives.
    11897    @param message
    119         The message that should be sent.
    120     @param clientId
    121         The id of the client the notification should be sent to.
     98        The message of the new Notification.
    12299    @param sender
    123         The sender that sent the notification.
    124     @param isLocal
    125         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.
    126     */
    127     /*static*/ void NotificationManager::sendNotification(const std::string& message, unsigned int clientId, const std::string& sender, bool isLocal)
    128     {
    129         // If we're in standalone mode or we're already no the right client we create and send the Notification.
    130         if(GameMode::isStandalone() || isLocal || Host::getPlayerID() == clientId)
    131         {
    132             Notification* notification = new Notification(message, sender);
    133             if(NotificationManager::getInstance().registerNotification(notification))
    134                 COUT(3) << "Notification \"" << notification->getMessage() << "\" sent." << std::endl;
    135         }
    136         // If we're on the server (and the server is not the intended recipient of the Notification) we send it over the network.
    137         else if(GameMode::isServer())
    138         {
    139             callStaticNetworkFunction(NotificationManager::sendNotification, clientId, message, clientId, sender);
    140         }
    141     }
    142 
    143     /**
    144     @brief
    145         Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationListeners associated with its sender.
     100        The name of the entity (of the collective) that sent the new Notification.
     101    @param type
     102        The type of the new Notification.
     103    @return
     104        Returns true if successful.
     105    */
     106    bool NotificationManager::registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
     107    {
     108        // TODO: Do something with the type.
     109        Notification* notification = new Notification(message, sender, type);
     110        return this->registerNotification(notification);
     111    }
     112
     113    /**
     114    @brief
     115        Executes the input command from the input sender.
     116        This is called by the NotificationListener, whenever a new command arrives.
     117    @param command
     118        The command to be executed,
     119    @param sender
     120        The The name of the entity (of the collective) that sent the command.
     121    @return
     122        Returns true if the command was successfully executed.
     123    */
     124    bool NotificationManager::executeCommand(notificationCommand::Value command, const std::string& sender)
     125    {
     126        bool commandExecuted = false;
     127        if(command == notificationCommand::clear)
     128        {
     129            if(this->commandClear(sender))
     130                commandExecuted = true;
     131        }
     132
     133        if(commandExecuted)
     134            COUT(3) << "Notification command \"" << NotificationListener::command2Str(command) << "\" executed." << endl;
     135
     136        return commandExecuted;
     137    }
     138
     139    /**
     140    @brief
     141        The clear command. Clears all NotificationQueues that have its sender as a target.
     142    @param sender
     143        The sender of the clear command.
     144    @return
     145        Returns true if the command was successfully executed by at least one NotificationQueue, false if it was not executed.
     146    */
     147    bool NotificationManager::commandClear(const std::string& sender)
     148    {
     149        bool all = (sender == NotificationListener::ALL);
     150        bool executed = false;
     151        // Clear all NotificationQueues that have the input sender as target.
     152        for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues.
     153        {
     154            const std::set<std::string>& set = it->second->getTargetsSet();
     155            // If either the sender is 'all', the NotificationQueue has as target all or the NotificationQueue has the input sender as a target.
     156            if(all || set.find(NotificationListener::ALL) != set.end() || set.find(sender) != set.end())
     157                executed = it->second->tidy() || executed;
     158        }
     159
     160        return executed;
     161    }
     162   
     163    /**
     164    @brief
     165        Registers a Notification within the NotificationManager and makes sure that the Notification is sent to all the NotificationQueues associated with its sender.
    146166    @param notification
    147167        The Notification to be registered.
     
    158178        this->allNotificationsList_.insert(std::pair<std::time_t, Notification*>(time, notification));
    159179
    160         if(notification->getSender() == NotificationManager::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
     180        if(notification->getSender() == NotificationListener::NONE) // If the sender has no specific name, then the Notification is only added to the list of all Notifications.
    161181            return true;
    162182
    163         bool all = false;
    164         if(notification->getSender() == NotificationManager::ALL) // If all are the sender, then the Notifications is added to every NotificationListener.
    165             all = true;
    166 
    167         // Insert the Notification in all NotificationListeners that have its sender as target.
    168         for(std::map<NotificationListener*, unsigned int>::iterator it = this->listenerList_.begin(); it != this->listenerList_.end(); it++) // Iterate through all NotificationListeners.
    169         {
    170             const std::set<std::string>& set = it->first->getTargetsSet();
    171             bool bAll = set.find(NotificationManager::ALL) != set.end();
    172             // If either the Notification has as sender 'all', the NotificationListener displays all Notifications or the NotificationListener has the sender of the Notification as target.
     183        // If all are the sender, then the Notifications is added to every NotificationQueue.
     184        bool all = (notification->getSender() == NotificationListener::ALL);
     185
     186        // Insert the Notification in all NotificationQueues that have its sender as target.
     187        for(std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.begin(); it != this->queues_.end(); it++) // Iterate through all NotificationQueues.
     188        {
     189            const std::set<std::string>& set = it->second->getTargetsSet();
     190            bool bAll = set.find(NotificationListener::ALL) != set.end();
     191            // If either the Notification has as sender 'all', the NotificationQueue displays all Notifications or the NotificationQueue has the sender of the Notification as target.
    173192            if(all || bAll || set.find(notification->getSender()) != set.end())
    174193            {
    175194                if(!bAll)
    176                     this->notificationLists_[it->second]->insert(std::pair<std::time_t, Notification*>(time, notification)); // Insert the Notification in the notifications list of the current NotificationListener.
    177                 it->first->update(notification, time); // Update the NotificationListener.
     195                    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.
     196                it->second->update(notification, time); // Update the NotificationQueue.
    178197            }
    179198        }
     
    186205    /**
    187206    @brief
    188         Unregisters a Notification within the NotificationManager for a given NotificationListener.
     207        Unregisters a Notification within the NotificationManager for a given NotificationQueue.
    189208    @param notification
    190209        A pointer to the Notification to be unregistered.
    191     @param listener
    192         A pointer to the NotificationListener the Notification is unregistered for.
    193     */
    194     void NotificationManager::unregisterNotification(Notification* notification, NotificationListener* listener)
     210    @param queue
     211        A pointer to the NotificationQueue the Notification is unregistered for.
     212    */
     213    void NotificationManager::unregisterNotification(Notification* notification, NotificationQueue* queue)
    195214    {
    196215        assert(notification);
    197         assert(listener);
    198 
    199         // Remove the Notification from the list of Notifications of the input NotificationListener.
    200         this->removeNotification(notification, *(this->notificationLists_.find(this->listenerList_.find(listener)->second)->second));
    201 
    202         COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from listener (&" << listener << ")" << std::endl;
     216        assert(queue);
     217
     218        // Remove the Notification from the list of Notifications of the input NotificationQueue.
     219        this->removeNotification(notification, *(this->notificationLists_.find(queue->getName())->second));
     220
     221        COUT(4) << "Notification (&" << notification << ") unregistered with the NotificationManager from NotificationQueue " << queue->getName() << "." << std::endl;
    203222    }
    204223
     
    230249    /**
    231250    @brief
    232         Registers a NotificationListener within the NotificationManager.
    233     @param listener
    234         The NotificationListener to be registered.
    235     @return
    236         Returns true if successful.  Fales if the NotificationListener is already registered.
    237     */
    238     bool NotificationManager::registerListener(NotificationListener* listener)
    239     {
    240         assert(listener);
    241 
    242         // If the NotificationListener is already registered.
    243         if(this->listenerList_.find(listener) != this->listenerList_.end())
    244             return false;
    245 
    246         this->highestIndex_ += 1;
    247         unsigned int index = this->highestIndex_; // An identifier that identifies each registered NotificationListener uniquely.
    248 
    249         this->listenerList_[listener] = index; // Add the NotificationListener to the list of NotificationListeners.
    250 
    251         const std::set<std::string>& set = listener->getTargetsSet();
    252 
    253         // 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.
    254         bool bAll = set.find(NotificationManager::ALL) != set.end();
    255         std::multimap<std::time_t, Notification*>* map = NULL;
    256         if(bAll)
    257             this->notificationLists_[index] = &this->allNotificationsList_;
    258         // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationListeners.
    259         else
    260         {
    261             this->notificationLists_[index] = new std::multimap<std::time_t, Notification*>;
    262             map = this->notificationLists_[index];
    263         }
    264 
    265         // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationListener.
    266         for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
    267         {
    268             if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
    269                 map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
    270         }
    271 
    272         listener->update(); // Update the listener.
    273 
    274         COUT(4) << "NotificationListener registered with the NotificationManager." << std::endl;
    275 
    276         return true;
    277     }
    278 
    279     /**
    280     @brief
    281         Unregisters a NotificationListener within the NotificationManager.
    282     @param listener
    283         The NotificationListener to be unregistered.
    284     */
    285     void NotificationManager::unregisterListener(NotificationListener* listener)
    286     {
    287         assert(listener);
    288 
    289         unsigned int identifier = this->listenerList_.find(listener)->second;
    290         std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(identifier)->second;
    291 
    292         // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
    293         std::multimap<std::time_t, Notification*>::iterator it = map->begin();
    294         if(map != &this->allNotificationsList_)
    295         {
    296             while(it != map->end())
    297             {
    298                 this->unregisterNotification(it->second, listener);
    299                 it = map->begin();
    300             }
    301             delete map;
    302         }
    303 
    304         COUT(4) << "NotificationListener '" << identifier << "' unregistered with the NotificationManager." << std::endl;
    305 
    306         // Remove the NotificationListener from the list of NotificationListeners.
    307         this->listenerList_.erase(listener);
    308         // Remove the Notifications list that was associated with the input NotificationListener.
    309         this->notificationLists_.erase(identifier);
    310     }
    311 
    312     /**
    313     @brief
    314         Fetches the Notifications for a specific NotificationListener in a specified timeframe and stores them in the input map.
    315     @param listener
    316         The NotificationListener the Notifications are fetched for.
     251        Fetches the Notifications for a specific NotificationQueue in a specified timeframe and stores them in the input map.
     252    @param queue
     253        The NotificationQueue the Notifications are fetched for.
    317254    @param map
    318255        A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
     
    324261        Returns true if successful.
    325262    */
    326     void NotificationManager::getNotifications(NotificationListener* listener, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
    327     {
    328         assert(listener);
     263    void NotificationManager::getNotifications(NotificationQueue* queue, std::multimap<std::time_t,Notification*>* map, const std::time_t & timeFrameStart, const std::time_t & timeFrameEnd)
     264    {
     265        assert(queue);
    329266        assert(map);
    330267
    331         std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[this->listenerList_[listener]]; // All the Notifications for the input NotificationListener.
     268        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
    332269
    333270        std::multimap<std::time_t,Notification*>::iterator it, itLowest, itHighest;
     
    342279    /**
    343280    @brief
    344         Enters the edit mode of the NotificationLayer.
    345     */
    346     void NotificationManager::enterEditMode(void)
    347     {
    348         if(GameMode::showsGraphics())
    349         {
    350             GUIManager::getInstance().hideGUI("NotificationLayer");
    351             GUIManager::getInstance().showGUI("NotificationLayer", false, false);
    352             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.enterEditMode()");
     281        Fetches the newest Notifications for a specific NotificationQueue and stores them in the input map.
     282    @param queue
     283        The NotificationQueue the Notifications are fetched for.
     284    @param map
     285        A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
     286    @param numberOfNotifications
     287        The number of newest Notifications to be got.
     288    @return
     289        Returns true if successful.
     290    */
     291    void NotificationManager::getNewestNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int numberOfNotifications)
     292    {
     293        assert(queue);
     294        assert(map);
     295
     296        std::multimap<std::time_t, Notification*>* notifications = this->notificationLists_[queue->getName()]; // All the Notifications for the input NotificationQueue.
     297
     298        if(!notifications->empty()) // If the list of Notifications is not empty.
     299        {
     300            std::multimap<std::time_t,Notification*>::iterator it = notifications->end();
     301            for(int i = 0; i < numberOfNotifications; i++) // Iterate through the Notifications from the newest until we have the specified number of notifications.
     302            {
     303                it--;
     304                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second)); // Add the found Notifications to the map.
     305                if(it == notifications->begin())
     306                    break;
     307            }
    353308        }
    354309    }
     
    357312    @brief
    358313        Registers a NotificationQueue.
    359         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.
     314        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.
    360315    @param queue
    361316        A pointer to the NotificationQueue to be registered.
     
    365320    bool NotificationManager::registerQueue(NotificationQueue* queue)
    366321    {
     322        assert(queue);
     323
     324        // If the NotificationQueue is already registered.
     325        if(this->queues_.find(queue->getName()) != this->queues_.end())
     326            return false;
     327
     328        this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)); // Add the NotificationQueue to the list of NotificationQueues.
     329
     330        const std::set<std::string>& set = queue->getTargetsSet();
     331
     332        // 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.
     333        bool bAll = set.find(NotificationListener::ALL) != set.end();
     334        std::multimap<std::time_t, Notification*>* map = NULL;
     335        if(bAll)
     336            this->notificationLists_[queue->getName()] = &this->allNotificationsList_;
     337        // Else a new list (resp. multimap) is created and added to the list of Notification lists for NotificationQueues.
     338        else
     339        {
     340            this->notificationLists_[queue->getName()] = new std::multimap<std::time_t, Notification*>;
     341            map = this->notificationLists_[queue->getName()];
     342        }
     343
     344        // Iterate through all Notifications to determine whether any of them should belong to the newly registered NotificationQueue.
     345        for(std::multimap<std::time_t, Notification*>::iterator it = this->allNotificationsList_.begin(); it != this->allNotificationsList_.end(); it++)
     346        {
     347            if(!bAll && set.find(it->second->getSender()) != set.end()) // Checks whether the listener has the sender of the current Notification as target.
     348                map->insert(std::pair<std::time_t, Notification*>(it->first, it->second));
     349        }
     350
     351        queue->update(); // Update the queue.
     352       
    367353        COUT(4) << "NotificationQueue '" << queue->getName() << "' registered with the NotificationManager." << std::endl;
    368         return this->queues_.insert(std::pair<const std::string, NotificationQueue*>(queue->getName(), queue)).second;
     354        return true;
    369355    }
    370356
     
    377363    void NotificationManager::unregisterQueue(NotificationQueue* queue)
    378364    {
     365        assert(queue);
     366
     367        std::multimap<std::time_t, Notification*>* map = this->notificationLists_.find(queue->getName())->second;
     368
     369        // If the map is not the map of all Notifications, make sure all Notifications are unregistered.
     370        std::multimap<std::time_t, Notification*>::iterator it = map->begin();
     371        if(map != &this->allNotificationsList_)
     372        {
     373            while(it != map->end())
     374            {
     375                this->unregisterNotification(it->second, queue);
     376                it = map->begin();
     377            }
     378            delete map;
     379        }
     380
     381        // Remove the NotificationQueue from the list of NotificationQueues.
     382        this->queues_.erase(queue->getName());
     383        // Remove the Notifications list that was associated with the input NotificationQueue.
     384        this->notificationLists_.erase(queue->getName());
     385       
    379386        COUT(4) << "NotificationQueue '" << queue->getName() << "' unregistered with the NotificationManager." << std::endl;
    380         this->queues_.erase(queue->getName());
    381     }
    382 
    383     /**
    384     @brief
    385         Loads all the NotificationQueues that should exist.
    386     */
    387     void NotificationManager::loadQueues(void)
    388     {
    389         new NotificationQueue("all");
    390     }
    391 
    392     /**
    393     @brief
    394         Creates a new NotificationQueue.
    395         This is used in lua.
    396     @param name
    397         The name of the new NotificationQueue.
    398     */
    399     void NotificationManager::createQueue(const std::string& name)
    400     {
    401         new NotificationQueue(name);
    402387    }
    403388
     
    420405    }
    421406
     407    /**
     408    @brief
     409        Loads all the NotificationQueues that should exist.
     410    */
     411    void NotificationManager::loadQueues(void)
     412    {
     413        /*NotificationQueueCEGUI* allQueue = new NotificationQueueCEGUI("all");
     414        allQueue->setDisplaySize(Vector2(0.5, 0));
     415        allQueue->setPosition(Vector4(0.0, 10, 0.3, 0));
     416
     417        NotificationQueueCEGUI* infoQueue = new NotificationQueueCEGUI("info", "gameinfo", 1, -1);
     418        infoQueue->setPosition(Vector4(0.2, 0, 0.8, 0));
     419        infoQueue->setFontSize(24);
     420        infoQueue->setFontColor(Vector4(1.0, 1.0, 0.0, 0.8));
     421        infoQueue->setAlignment("HorzCentred");
     422        infoQueue->setDisplaySize(Vector2(0.6, 0.0));*/
     423    }
     424
     425    // Notification class
     426
     427    /**
     428    @brief
     429        Constructor. Creates a Notification with the input message and sender.
     430    @param message
     431        The message of the Notification.
     432    @param sender
     433        The sender of the Notification.
     434    @param type
     435
     436    */
     437    Notification::Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
     438    {
     439        this->initialize();
     440        this->message_ = message;
     441        this->sender_ = sender;
     442        this->type_ = type;
     443    }
     444
     445    /**
     446    @brief
     447        Destructor.
     448    */
     449    Notification::~Notification()
     450    {
     451
     452    }
     453
     454    /**
     455    @brief
     456        Registers the object and sets some default values.
     457    */
     458    void Notification::initialize(void)
     459    {
     460        this->message_.clear();
     461        this->sender_ = NotificationListener::NONE;
     462    }
     463
    422464}
  • code/branches/presentation/src/modules/notifications/NotificationManager.h

    r7552 r8637  
    4242#include <string>
    4343
     44#include "core/OrxonoxClass.h"
    4445#include "util/Singleton.h"
    45 #include "core/OrxonoxClass.h"
     46#include "interfaces/NotificationListener.h"
    4647
    4748namespace orxonox // tolua_export
     
    5051    /**
    5152    @brief
    52         The Singleton NotificationManager functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationListener "NotificationListeners".
    53         It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationListener "NotificationListeners".
    54         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.
     53        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).
     54
     55        A Notification is just a data structure that is used internally by the Notifications module.
     56
     57    @author
     58        Damian 'Mozork' Frick
     59
     60    @ingroup Notifications
     61    */
     62    class _NotificationsExport Notification
     63    {
     64        public:
     65            Notification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
     66            virtual ~Notification();
     67
     68            /**
     69            @brief Destroys the Notification.
     70            */
     71            void destroy(void)
     72                { delete this; }
     73
     74            /**
     75            @brief Get the message of the Notification.
     76            @return Returns the message of the Notification.
     77            */
     78            inline const std::string & getMessage(void) const
     79                { return this->message_; }
     80
     81            /**
     82            @brief Get the sender of the Notification.
     83            @return Returns the sender of the Notification.
     84            */
     85            inline const std::string & getSender(void) const
     86                { return this->sender_; }
     87
     88            /**
     89            @brief Get the type of the Notification.
     90            @return Returns an enum with the type of the Notification.
     91            */
     92            inline notificationMessageType::Value getType(void) const
     93                { return this->type_; }
     94
     95        private:
     96            std::string message_; //!< The Notification message.
     97            std::string sender_; //!< The sender of the notification.
     98            notificationMessageType::Value type_; //!< The type of the notification.
     99
     100            void initialize(void); //!< Registers the object and sets some default values.
     101
     102    };
     103
     104    /**
     105    @brief
     106        The Singleton NotificationManager is a NotificationListener and functions as a gateway between @ref orxonox::Notification "Notifications" and @ref orxonox::NotificationQueue "NotificationQueues".
     107        It receives, organizes @ref orxonox::Notification "Notifications" and the redistributes them to the specific @ref orxonox::NotificationQueue "NotificationQueues".
     108        It also works as a liaison between the @ref orxonox::NotificationQueue "NotificationQueues" and the GUI that displays notification, called NotificationLayer.
    55109
    56110    @author
     
    60114    */
    61115    class _NotificationsExport NotificationManager // tolua_export
    62         : public Singleton<NotificationManager>, public OrxonoxClass
     116        : public Singleton<NotificationManager>, public NotificationListener
    63117    { // tolua_export
    64118            friend class Singleton<NotificationManager>;
     
    67121            virtual ~NotificationManager();
    68122
    69             virtual void preDestroy(void); //!< Is called before the object is destroyed.
     123            virtual void preDestroy(void); // Is called before the object is destroyed.
    70124
    71125            /**
     
    75129            static NotificationManager& getInstance() { return Singleton<NotificationManager>::getInstance(); } // tolua_export
    76130
    77             static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationListeners.
    78             static const std::string NONE; //!< Static string to indicare a sender that sends to no specific NotificationListener.
     131            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type);
     132            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender);
    79133
    80             //! Sends a Notification with the specified message to the specified client from the specified sender.
    81             static void sendNotification(const std::string& message, unsigned int clientId, const std::string& sender = NotificationManager::NONE, bool isLocal = false);
     134            bool registerNotification(Notification* notification); // Registers a Notification within the NotificationManager.
     135            void unregisterNotification(Notification* notification, NotificationQueue* queue); // Unregisters a Notification within the NotificationManager for a given NotificationQueue.
    82136
    83             bool registerNotification(Notification* notification); //!< Registers a Notification within the NotificationManager.
    84             void unregisterNotification(Notification* notification, NotificationListener* listener); //!< Unregisters a Notification within the NotificationManager for a given NotificationListener.
    85             bool registerListener(NotificationListener* listener); //!< Registers a NotificationListener within the NotificationManager.
    86             void unregisterListener(NotificationListener* listener); //!< Unregisters a NotificationListener withing the NotificationManager.
    87 
    88             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.
     137            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.
    89138
    90139            /**
    91             @brief Fetches the Notifications for a specific NotificationListener in a timeframe from now-timeDelay to now and stores them in the input map.
    92             @param listener The NotificationListener the Notifications are fetched for.
     140            @brief Fetches the Notifications for a specific NotificationQueue in a timeframe from (now-timeDelay) to now and stores them in the input map.
     141            @param queue The NotificationQueue the Notifications are fetched for.
    93142            @param map A pointer to a multimap, in which the notifications are stored. The map needs to have been allocated.
    94143            @param timeDelay The timespan.
    95144            @return Returns true if successful.
    96145            */
    97             void getNotifications(NotificationListener* listener, std::multimap<std::time_t, Notification*>* map, int timeDelay)
    98                 { this->getNotifications(listener, map, std::time(0)-timeDelay, std::time(0)); }
     146            void getNotifications(NotificationQueue* queue, std::multimap<std::time_t, Notification*>* map, int timeDelay)
     147                { this->getNotifications(queue, map, std::time(0)-timeDelay, std::time(0)); }
    99148
    100             void enterEditMode(void); //!< Enters the edit mode of the NotificationLayer.
     149            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.
    101150
    102             bool registerQueue(NotificationQueue* queue); //!< Registers a NotificationQueue.
    103             void unregisterQueue(NotificationQueue* queue); //!< Unregisters a NotificationQueue.
     151            bool registerQueue(NotificationQueue* queue); // Registers a NotificationQueue.
     152            void unregisterQueue(NotificationQueue* queue); // Unregisters a NotificationQueue.
    104153
    105             // tolua_begin
    106             void loadQueues(void); //!< Loads all the NotificationQueues that should exist.
    107             void createQueue(const std::string& name); //!< Creates a new NotificationQueue.
    108             orxonox::NotificationQueue* getQueue(const std::string & name); //!< Get the NotificationQueue with the input name.
    109             // tolua_end
     154            void loadQueues(void); // tolua_export // Loads all the NotificationQueues that should exist.
     155
     156            NotificationQueue* getQueue(const std::string & name); // Get the NotificationQueue with the input name.
    110157
    111158        private:
    112159            static NotificationManager* singletonPtr_s;
    113160
    114             unsigned int highestIndex_; //!< This variable holds the highest index (resp. key) in notificationLists_s, to secure that no key appears twice.
    115 
    116161            std::multimap<std::time_t, Notification*> allNotificationsList_; //!< Container where all Notifications are stored.
    117             std::map<NotificationListener*, unsigned int> listenerList_; //!< Container where all NotificationListeners are stored with a number as identifier.
    118             std::map<int,std::multimap<std::time_t, Notification*>*> notificationLists_; //!< Container where all Notifications, for each identifier (associated with a NotificationListener), are stored.
     162            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.
    119163
    120164            std::map<const std::string, NotificationQueue*> queues_; //!< The list of NotificationQueues created by the NotificationManager.
    121165
    122             bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); //!< Helper method that removes an input Notification form an input map.
     166            bool removeNotification(Notification* notification, std::multimap<std::time_t, Notification*>& map); // Helper method that removes an input Notification form an input map.
     167           
     168            // Commands
     169            bool commandClear(const std::string& sender); // The clear command. Clears all NotificationQueues that have its sender as a target.
    123170
    124171    }; // tolua_export
  • code/branches/presentation/src/modules/notifications/NotificationQueue.cc

    r8079 r8637  
    3838
    3939#include "core/CoreIncludes.h"
    40 #include "core/GameMode.h"
    41 #include "core/GUIManager.h"
    42 #include "core/LuaState.h"
    43 #include "util/Convert.h"
     40#include "core/XMLPort.h"
    4441#include "util/SubString.h"
    45 
    46 #include "Notification.h"
    4742
    4843namespace orxonox
    4944{
    5045
    51     /**
    52     @brief
    53         Constructor. Creates and initializes the object.
     46    CreateFactory(NotificationQueue);
     47   
     48    /**
     49    @brief
     50        Default constructor. Registers and initializes the object.
     51    @param creator
     52        The creator of the NotificationQueue.
     53    */
     54    NotificationQueue::NotificationQueue(BaseObject* creator) : BaseObject(creator), registered_(false)
     55    {
     56        RegisterObject(NotificationQueue);
     57
     58        this->initialize();
     59    }
     60
     61    // TODO move to docu.
     62    /**
     63    @brief
     64        Constructor. Registers and initializes the object.
     65    @param creator
     66        The creator of the NotificationQueue
    5467    @param name
    5568        The name of the new NotificationQueue. It needs to be unique
     
    6275        The time during which a Notification is (at most) displayed.
    6376    */
    64     NotificationQueue::NotificationQueue(const std::string& name, const std::string& senders, unsigned int size, unsigned int displayTime)
    65     {
    66         this->registered_ = false;
    67 
    68         RegisterRootObject(NotificationQueue);
    69 
    70         // Initialize.
     77
     78    /**
     79    @brief
     80        Destructor.
     81    */
     82    NotificationQueue::~NotificationQueue()
     83    {
     84        this->targets_.clear();
     85
     86        if(this->isRegistered()) // If the NotificationQueue is registered.
     87        {
     88            this->clear(true);
     89
     90            // Unregister with the NotificationManager.
     91            NotificationManager::getInstance().unregisterQueue(this);
     92        }
     93    }
     94
     95    /**
     96    @brief
     97        Initializes the NotificationQueue.
     98    */
     99    void NotificationQueue::initialize(void)
     100    {
    71101        this->size_ = 0;
    72102        this->tickTime_ = 0.0f;
    73 
    74         // Sets the input values.
    75         this->setTargets(senders);
    76         this->name_ = name;
    77         this->maxSize_ = size;
    78         this->setDisplayTime(displayTime);
    79 
     103        this->maxSize_ = NotificationQueue::DEFAULT_SIZE;
     104        this->displayTime_ = NotificationQueue::DEFAULT_DISPLAY_TIME;
     105
     106        this->creationTime_ = std::time(0);
     107    }
     108
     109    /**
     110    @brief
     111        Creates the NotificationQueue.
     112    */
     113    void NotificationQueue::create(void)
     114    {
    80115        // Register the NotificationQueue with the NotificationManager.
    81116        bool queueRegistered = NotificationManager::getInstance().registerQueue(this);
     
    88123        }
    89124
    90         this->create(); // Creates the NotificationQueue in lua.
    91 
    92         // Register the NotificationQueue as NotificationListener with the NotificationManager.
    93         bool listenerRegistered = NotificationManager::getInstance().registerListener(this);
    94         if(!listenerRegistered) // If the registration has failed.
    95         {
    96             this->registered_ = false;
    97             // Remove the NotificationQueue in lua.
    98             if(GameMode::showsGraphics())
    99                 GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
    100             NotificationManager::getInstance().unregisterQueue(this);
    101             COUT(1) << "Error: NotificationQueue '" << this->getName() << "' could not be registered." << std::endl;
    102             return;
    103         }
    104 
    105125        COUT(3) << "NotificationQueue '" << this->getName() << "' created." << std::endl;
    106     }
    107 
    108     /**
    109     @brief
    110         Destructor.
    111     */
    112     NotificationQueue::~NotificationQueue()
    113     {
    114         this->targets_.clear();
    115 
    116         if(this->registered_) // If the NotificationQueue is registered.
    117         {
    118             this->clear(true);
    119 
    120             // Unregister with the NotificationManager.
    121             NotificationManager::getInstance().unregisterListener(this);
    122             NotificationManager::getInstance().unregisterQueue(this);
    123         }
    124     }
    125 
    126     /**
    127     @brief
    128         Destroys the NotificationQueue.
    129         Used in lua and NotificationManager.
    130     @param noGraphics
    131         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.
    132     */
    133     void NotificationQueue::destroy(bool noGraphics)
    134     {
    135         // Remove the NotificationQueue in lua.
    136         if(GameMode::showsGraphics() && !noGraphics)
    137             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeQueue(\"" + this->getName() +  "\")");
    138 
    139         COUT(3) << "NotificationQueue '" << this->getName() << "' destroyed." << std::endl;
    140 
    141         this->OrxonoxClass::destroy();
    142     }
    143 
    144     /**
    145     @brief
    146         Creates the NotificationQueue in lua.
    147     */
    148     void NotificationQueue::create(void)
    149     {
    150         if(GameMode::showsGraphics())
    151             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.createQueue(\"" + this->getName() +  "\", " + multi_cast<std::string>(this->getMaxSize()) + ")");
    152126    }
    153127
     
    161135    {
    162136        this->tickTime_ += dt; // Add the time interval that has passed to the time counter.
    163         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.
    164         {
    165             this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containig the current time.
     137        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.
     138        {
     139            this->timeLimit_.time = std::time(0)-this->displayTime_; // Container containing the current time.
    166140
    167141            std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator it = this->ordering_.begin();
     
    177151    }
    178152
     153    void NotificationQueue::XMLPort(Element& xmlelement, XMLPort::Mode mode)
     154    {
     155        SUPER(NotificationQueue, XMLPort, xmlelement, mode);
     156
     157        XMLPortParam(NotificationQueue, "targets", setTargets, getTargets, xmlelement, mode).defaultValues(NotificationListener::ALL);
     158        XMLPortParam(NotificationQueue, "size", setMaxSize, getMaxSize, xmlelement, mode);
     159        XMLPortParam(NotificationQueue, "displayTime", setDisplayTime, getDisplayTime, xmlelement, mode);
     160
     161        this->create();
     162    }
     163
    179164    /**
    180165    @brief
    181166        Updates the NotificationQueue.
    182167        Updates by clearing the queue and requesting all relevant Notifications from the NotificationManager and inserting them into the queue.
     168        This is called by the NotificationManager when the Notifications have changed so much, that the NotificationQueue may have to re-initialize his operations.
    183169    */
    184170    void NotificationQueue::update(void)
     
    188174        std::multimap<std::time_t, Notification*>* notifications = new std::multimap<std::time_t, Notification*>;
    189175        // Get the Notifications sent in the interval from now to now minus the display time.
    190         NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
     176        if(this->displayTime_ == INF)
     177            NotificationManager::getInstance().getNewestNotifications(this, notifications, this->getMaxSize());
     178        else
     179            NotificationManager::getInstance().getNotifications(this, notifications, this->displayTime_);
    191180
    192181        if(!notifications->empty())
    193182        {
    194             // Add all Notifications.
     183            // Add all Notifications that have been created after this NotificationQueue was created.
    195184            for(std::multimap<std::time_t, Notification*>::iterator it = notifications->begin(); it != notifications->end(); it++)
    196                 this->push(it->second, it->first);
     185            {
     186                if(it->first >= this->creationTime_)
     187                    this->push(it->second, it->first);
     188            }
    197189        }
    198190
     
    246238        this->notifications_.insert(this->notifications_.begin(), container);
    247239
    248         // Push the Notification to the GUI.
    249         if(GameMode::showsGraphics())
    250             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.pushNotification(\"" + this->getName() + "\", \"" + notification->getMessage() + "\")");
     240        // Inform that a Notification was pushed.
     241        this->notificationPushed(notification);
    251242
    252243        COUT(5) << "Notification \"" << notification->getMessage() << "\" pushed to NotificationQueue '" << this->getName() << "'" << endl;
     244        COUT(3) << "NotificationQueue \"" << this->getName() << "\": " << notification->getMessage() << endl;
    253245    }
    254246
     
    279271        delete container;
    280272
    281         // Pops the Notification from the GUI.
    282         if(GameMode::showsGraphics())
    283             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.popNotification(\"" + this->getName() + "\")");
     273        // Inform that a Notification was popped.
     274        this->notificationPopped();
    284275    }
    285276
     
    305296        delete *containerIterator;
    306297
    307         // Removes the Notification from the GUI.
    308         if(GameMode::showsGraphics())
    309             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.removeNotification(\"" + this->getName() + "\", " + multi_cast<std::string>(index) + ")");
     298        // TODO: index automatically cast?
     299        // Inform that a Notification was removed.
     300        this->notificationRemoved(index);
    310301    }
    311302
     
    314305        Clears the NotificationQueue by removing all NotificationContainers.
    315306    @param noGraphics
    316         If this is eset to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
     307        If this is set to true the GUI is not informed of the clearing of the NotificationQueue. This is needed only internally.
    317308    */
    318309    void NotificationQueue::clear(bool noGraphics)
     
    326317        this->notifications_.clear();
    327318        this->size_ = 0;
    328 
    329         // Clear the NotificationQueue in the GUI.
    330         if(GameMode::showsGraphics() && !noGraphics)
    331             GUIManager::getInstance().getLuaState()->doString("NotificationLayer.clearQueue(\"" + this->getName() + "\")");
    332319    }
    333320
     
    354341            return;
    355342
     343        if(size == 0)
     344        {
     345            COUT(2) << "Trying to set maximal size of NotificationQueue '" << this->getName() << "' to 0. Ignoring..." << endl;
     346            return;
     347        }
     348       
    356349        this->maxSize_ = size;
    357350
    358         if(this->registered_)
     351        if(this->isRegistered())
    359352            this->update();
    360353    }
     
    364357        Sets the maximum number of seconds a Notification is displayed.
    365358    @param time
    366         The number of seconds the Notifications is displayed.
    367     @return
    368         Returns true if successful.
    369     */
    370     void NotificationQueue::setDisplayTime(unsigned int time)
     359        The number of seconds a Notification is displayed.
     360    */
     361    void NotificationQueue::setDisplayTime(int time)
    371362    {
    372363        if(this->displayTime_ == time)
    373364            return;
    374365
     366        if(time != NotificationQueue::INF && time <= 0)
     367        {
     368            COUT(2) << "Trying to set display time of NotificationQueue '" << this->getName() << "' to non-positive value. Ignoring..." << endl;
     369        }
     370           
    375371        this->displayTime_ = time;
    376372
    377         if(this->registered_)
     373        if(this->isRegistered())
    378374            this->update();
    379375    }
     
    381377    /**
    382378    @brief
    383         Produces all targets of the NotificationQueue concatinated as string, with commas (',') as seperators.
     379        Produces all targets of the NotificationQueue concatenated as string, with commas (',') as separators.
    384380    @return
    385381        Returns the targets as a string.
     
    407403        The targets are the senders whose Notifications are displayed in this queue.
    408404    @param targets
    409         Accepts a string of targets, each seperated by commas (','), spaces are ignored.
     405        Accepts a string of targets, each separated by commas (','), spaces are ignored.
    410406    */
    411407    void NotificationQueue::setTargets(const std::string & targets)
     
    417413            this->targets_.insert(string[i]);
    418414
    419         if(this->registered_)
    420         {
    421             NotificationManager::getInstance().unregisterListener(this);
    422             NotificationManager::getInstance().registerListener(this);
    423         }
     415        // TODO: Why?
     416        if(this->isRegistered())
     417        {
     418            NotificationManager::getInstance().unregisterQueue(this);
     419            NotificationManager::getInstance().registerQueue(this);
     420        }
     421    }
     422
     423    /**
     424    @brief
     425        Pops all Notifications from the NotificationQueue.
     426    @return
     427        Returns true if successful, false if not.
     428    */
     429    bool NotificationQueue::tidy(void)
     430    {
     431        while(this->size_ > 0)
     432            this->pop();
     433        return true;
    424434    }
    425435
  • code/branches/presentation/src/modules/notifications/NotificationQueue.h

    r7552 r8637  
    4545#include "NotificationManager.h"
    4646
     47#include "core/BaseObject.h"
    4748#include "tools/interfaces/Tickable.h"
    48 #include "interfaces/NotificationListener.h"
    49 
    50 namespace orxonox // tolua_export
    51 { // tolua_export
     49
     50namespace orxonox
     51{
    5252
    5353    /**
     
    7878        Displays @ref orxonox::Notification "Notifications" from specific senders.
    7979
    80         There are quite some parameters that influence the behaviour of the NotificationQueue:
     80        There are quite some parameters that influence the behavior of the NotificationQueue:
    8181        - @b name The name of the NotificationQueue. It needs to be unique.
    8282        - @b senders The senders that are targets of this NotificationQueue, i.e. the names of senders whose Notifications this NotificationQueue displays.
     
    8989    @ingroup Notifications
    9090    */
    91     class _NotificationsExport NotificationQueue // tolua_export
    92         : public Tickable, public NotificationListener
    93     { // tolua_export
     91    class _NotificationsExport NotificationQueue : public BaseObject, public Tickable
     92    {
    9493
    9594        public:
    96             NotificationQueue(const std::string& name, const std::string& senders = NotificationManager::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
     95            NotificationQueue(BaseObject* creator);
     96            NotificationQueue(BaseObject* creator, const std::string& name, const std::string& senders = NotificationListener::ALL, unsigned int size = NotificationQueue::DEFAULT_SIZE, unsigned int displayTime = NotificationQueue::DEFAULT_DISPLAY_TIME);
    9797            virtual ~NotificationQueue();
    9898
    99             //! Destroys the NotificationQueue.
    100             void destroy(bool noGraphics = false); // tolua_export
    101 
    102             virtual void tick(float dt); //!< To update from time to time.
    103 
    104             void update(void); //!< Updates the NotificationQueue.
    105             void update(Notification* notification, const std::time_t & time); //!< Updates the NotificationQueue by adding an new Notification.
     99            virtual void tick(float dt); // To update from time to time.
     100            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
     101
     102            void update(void); // Updates the NotificationQueue.
     103            void update(Notification* notification, const std::time_t & time); // Updates the NotificationQueue by adding an new Notification.
    106104
    107105            // tolua_begin
     
    110108            @return Returns the name.
    111109            */
    112             inline const std::string& getName() const
    113                 { return this->name_; }
    114 
    115             void setMaxSize(unsigned int size); //!< Sets the maximum number of displayed Notifications.
     110            inline const std::string& getName(void) const
     111                { return this->BaseObject::getName(); }
     112
     113            void setMaxSize(unsigned int size); // Sets the maximum number of displayed Notifications.
    116114            /**
    117115            @brief Returns the maximum number of Notifications displayed.
    118116            @return Returns maximum size.
    119117            */
    120             inline unsigned int getMaxSize() const
     118            inline unsigned int getMaxSize(void) const
    121119                { return this->maxSize_; }
    122120
    123             void setDisplayTime(unsigned int time); //!< Sets the maximum number of seconds a Notification is displayed.
     121            void setDisplayTime(int time); // Sets the maximum number of seconds a Notification is displayed.
    124122            /**
    125123            @brief Returns the time interval the Notification is displayed.
    126124            @return Returns the display time.
    127125            */
    128             inline unsigned int getDisplayTime() const
     126            inline int getDisplayTime(void) const
    129127                { return this->displayTime_; }
    130128            // tolua_end
     
    134132            @return Returns the size of the NotificationQueue.
    135133            */
    136             inline unsigned int getSize() const
     134            inline unsigned int getSize(void) const
    137135                { return this->size_; }
    138136
     
    141139            @return Returns a set of strings holding the different targets.
    142140            */
    143             inline const std::set<std::string> & getTargetsSet()
     141            inline const std::set<std::string> & getTargetsSet(void)
    144142                { return this->targets_; }
    145143
    146             // tolua_begin
    147             void setTargets(const std::string & targets); //!< Set the targets of this NotificationQueue.
    148             const std::string& getTargets(void) const; //!< Returns a string consisting of the concatination of the targets.
    149             // tolua_end
    150 
    151         private:
     144            void setTargets(const std::string & targets); // Set the targets of this NotificationQueue.
     145            const std::string& getTargets(void) const; // Returns a string consisting of the concatenation of the targets.
     146
     147            /**
     148            @brief Check whether the NotificationQueue is registered with the NotificationManager.
     149            @return Returns true if it is registered, false if not.
     150            */
     151            inline bool isRegistered(void)
     152                { return this->registered_; }
     153
     154            bool tidy(void); // Pops all Notifications from the NotificationQueue.
     155           
     156        protected:
     157            /**
     158            @brief Is called when a notification was pushed.
     159            @param notification The Notification that was pushed.
     160            */
     161            virtual void notificationPushed(Notification* notification) {}
     162            /**
     163            @brief Is called when a notification was popped.
     164            */
     165            virtual void notificationPopped(void) {}
     166            /**
     167            @brief Is called when a notification was removed.
     168            @param index The index the removed notification was at.
     169            */
     170            virtual void notificationRemoved(unsigned int index) {}
     171           
     172            virtual void clear(bool noGraphics = false); // Clears the NotificationQueue by removing all NotificationContainers.
     173
     174        protected:
    152175            static const unsigned int DEFAULT_SIZE = 5; //!< The default maximum number of Notifications displayed.
    153176            static const unsigned int DEFAULT_DISPLAY_TIME = 30; //!< The default display time.
    154 
    155             std::string name_; //!< The name of the NotificationQueue.
    156 
     177            static const int INF = -1; //!< Constant denoting infinity.
     178
     179            virtual void create(void); // Creates the NotificationQueue.
     180
     181        private:
     182            void initialize(void); // Initializes the NotificationQueue.
     183
     184            time_t creationTime_; // The time this NotificationQueue was created.
     185           
    157186            unsigned int maxSize_; //!< The maximal number of Notifications displayed.
    158187            unsigned int size_; //!< The number of Notifications displayed.
    159             unsigned int displayTime_; //!< The time a Notification is displayed.
     188            int displayTime_; //!< The time a Notification is displayed.
    160189
    161190            bool registered_; //!< Helper variable to remember whether the NotificationQueue is registered already.
     
    169198            NotificationContainer timeLimit_; //!< Helper object to check against to determine whether Notifications have expired.
    170199
    171             void create(void); //!< Creates the NotificationQueue in lua.
    172 
    173200            void setName(const std::string& name); //!< Sets the name of the NotificationQueue.
    174201
    175             void push(Notification* notification, const std::time_t & time); //!< Adds (pushes) a Notification to the NotificationQueue.
    176             void pop(void); //!< Removes (pops) the least recently added Notification form the NotificationQueue.
    177             void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); //!< Removes the Notification that is stored in the input NotificationContainer.
    178 
    179             void clear(bool noGraphics = false); //!< Clears the NotificationQueue by removing all NotificationContainers.
    180 
    181     }; // tolua_export
    182 
    183 } // tolua_export
    184 
    185 #endif /* _NotificationOverlay_H__ */
     202            void push(Notification* notification, const std::time_t & time); // Adds (pushes) a Notification to the NotificationQueue.
     203            void pop(void); // Removes (pops) the least recently added Notification form the NotificationQueue.
     204            void remove(const std::multiset<NotificationContainer*, NotificationContainerCompare>::iterator& containerIterator); // Removes the Notification that is stored in the input NotificationContainer.
     205
     206    };
     207
     208}
     209
     210#endif /* _NotificationQueue_H__ */
  • code/branches/presentation/src/modules/objects/triggers/DistanceTrigger.cc

    r8213 r8637  
    280280        Check whether the DistanceTrigger is triggered.
    281281        It is triggered if it is triggered according only to its mode (i.e. its sub-triggers) and if a target is in range.
    282     @param
     282    @param mode
     283        The mode for which it is tested, whether the DistanceTrigger is triggered.
     284    @return
    283285        Returns true if it is triggered ,false if not.
    284286    */
  • code/branches/presentation/src/modules/objects/triggers/DistanceTrigger.h

    r8213 r8637  
    7171        - @b target Which specifies the class of objects that can trigger the DistanceTrigger. Default is <code>"Pawn"</code>.
    7272        - @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>).
    7474
    7575        A simple DistanceTrigger could look like this:
  • code/branches/presentation/src/modules/objects/triggers/EventTrigger.h

    r8213 r8637  
    6060
    6161    @see Trigger
    62         For more information on @ref oroxnox::Trigger "Triggers".
     62        For more information on @ref orxonox::Trigger "Triggers".
    6363
    6464    @author
  • code/branches/presentation/src/modules/objects/triggers/MultiTrigger.cc

    r8561 r8637  
    198198                        if(bActive ^ this->isActive(state->originator))
    199199                        {
    200 
    201200                            bool bFire = true;
    202201
  • code/branches/presentation/src/modules/objects/triggers/TriggerBase.h

    r8213 r8637  
    133133            inline int getActivations(void) const
    134134                { return this->remainingActivations_; }
     135            /**
     136            @brief Check whether the trigger has still at least one remaining activation.
     137            @return Returns true if the trigger has remaining activations (i.e. the number of remaining activations is not zero).
     138            */
     139            inline bool hasRemainingActivations(void) const
     140                { return this->remainingActivations_ > 0 || this->remainingActivations_ == INF_s; }
    135141
    136142            /**
  • code/branches/presentation/src/modules/overlays/hud/CMakeLists.txt

    r8178 r8637  
    77  HUDTimer.cc
    88  ChatOverlay.cc
    9   GametypeStatus.cc
    109  AnnounceMessage.cc
    1110  KillMessage.cc
  • code/branches/presentation/src/modules/questsystem/QuestDescription.cc

    r7474 r8637  
    4040#include "infos/PlayerInfo.h"
    4141
    42 #include "notifications/NotificationManager.h"
     42#include "interfaces/NotificationListener.h"
    4343
    4444namespace orxonox
     
    119119        }
    120120
    121         NotificationManager::sendNotification(message, player->getClientID(), QuestDescription::SENDER);
     121        NotificationListener::sendNotification(message, QuestDescription::SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
    122122        return true;
    123123    }
  • code/branches/presentation/src/modules/questsystem/QuestManager.cc

    r8079 r8637  
    274274    int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
    275275    {
     276        if(quest == NULL)
     277            return this->getNumRootQuests(player);
     278
    276279        std::list<Quest*> quests = quest->getSubQuestList();
    277280        int numQuests = 0;
     
    296299    Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
    297300    {
     301        if(quest == NULL)
     302            return this->getRootQuest(player, index);
     303
    298304        std::list<Quest*> quests = quest->getSubQuestList();
    299305        for(std::list<Quest*>::iterator it = quests.begin(); it != quests.end(); it++)
     
    312318    @param player
    313319        The player.
    314     @return Returns the number of QuestHints of the input Quest for the input player.
     320    @return
     321        Returns the number of QuestHints of the input Quest for the input player.
    315322    */
    316323    int QuestManager::getNumHints(Quest* quest, PlayerInfo* player)
     
    335342    @param index
    336343        The index of the QuestHint.
     344    @return
     345        Returns a pointer to the index-th QuestHint of the input Quest for the input player.
    337346    */
    338347    QuestHint* QuestManager::getHints(Quest* quest, PlayerInfo* player, int index)
     
    345354        }
    346355        return NULL;
     356    }
     357
     358    /**
     359    @brief
     360        Get the parent-quest of the input Quest.
     361    @param quest
     362        The Quest to get the parent-quest of.
     363    @return
     364        Returns a pointer to the parent-quest of the input Quest.
     365    */
     366    Quest* QuestManager::getParentQuest(Quest* quest)
     367    {
     368        return quest->getParentQuest();
    347369    }
    348370
     
    375397    /**
    376398    @brief
     399        Get the id of the input Quest.
     400    @param item
     401        The Quest to get the id of.
     402    @return
     403        Returns the id of the input Quest.
     404    */
     405    const std::string QuestManager::getId(Quest* item) const
     406    {
     407        return item->getId();
     408    }
     409
     410    /**
     411    @brief
     412        Get the id of the input QuestHint.
     413    @param item
     414        The QuestHint to get the id of.
     415    @return
     416        Returns the id of the input QuestHint.
     417    */
     418    const std::string QuestManager::getId(QuestHint* item) const
     419    {
     420        return item->getId();
     421    }
     422
     423    /**
     424    @brief
    377425        Retrieve the player for a certain GUI.
    378426    @param guiName
  • code/branches/presentation/src/modules/questsystem/QuestManager.h

    r7552 r8637  
    8181            QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index); //!< Get the index-th QuestHint of the input Quest for the input player.
    8282
    83             QuestDescription* getDescription(Quest* item);
    84             QuestDescription* getDescription(QuestHint* item);
     83            Quest* getParentQuest(Quest* quest); //!< Get the parent-quest of the input Quest.
     84
     85            QuestDescription* getDescription(Quest* item); //!< Get the QuestDescription of the input Quest.
     86            QuestDescription* getDescription(QuestHint* item); //!< Get the QuestDescription of the input QuestHint.
     87
     88            const std::string getId(Quest* item) const; //!< Get the id of the input Quest.
     89            const std::string getId(QuestHint* item) const; //!< Get the id of the input QuestHint.
    8590            // tolua_end
    8691
  • code/branches/presentation/src/orxonox/LevelManager.cc

    r8079 r8637  
    222222                this->nextLevel_ = this->availableLevels_.begin();
    223223            }
     224
    224225            while(this->nextIndex_ != index)
    225226            {
  • code/branches/presentation/src/orxonox/gametypes/Gametype.cc

    r8631 r8637  
    5858
    5959        this->defaultControllableEntity_ = Class(Spectator);
    60 
     60       
    6161        this->bAutoStart_ = false;
    6262        this->bForceSpawn_ = false;
     
    121121        }
    122122
    123         if (this->gtinfo_->bStartCountdownRunning_ && !this->gtinfo_->bStarted_)
    124             this->gtinfo_->startCountdown_ -= dt;
    125 
    126         if (!this->gtinfo_->bStarted_)
     123        if (this->gtinfo_->isStartCountdownRunning() && !this->gtinfo_->hasStarted())
     124            this->gtinfo_->countdownStartCountdown(dt);
     125
     126        if (!this->gtinfo_->hasStarted())
     127        {
     128            for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
     129            {
     130                // Inform the GametypeInfo that the player is ready to spawn.
     131                if(it->first->isHumanPlayer() && it->first->isReadyToSpawn())
     132                    this->gtinfo_->playerReadyToSpawn(it->first);
     133            }
     134                   
    127135            this->checkStart();
    128         else if (!this->gtinfo_->bEnded_)
     136        }
     137        else if (!this->gtinfo_->hasEnded())
    129138            this->spawnDeadPlayersIfRequested();
    130139
     
    136145        this->addBots(this->numberOfBots_);
    137146
    138         this->gtinfo_->bStarted_ = true;
     147        this->gtinfo_->start();
    139148
    140149        this->spawnPlayersIfRequested();
     
    143152    void Gametype::end()
    144153    {
    145         this->gtinfo_->bEnded_ = true;
     154        this->gtinfo_->end();
    146155
    147156        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
     
    173182    {
    174183        this->players_[player].state_ = PlayerState::Joined;
     184        this->gtinfo_->playerEntered(player);
    175185    }
    176186
     
    269279                    }
    270280                }
     281
     282                if(victim->getPlayer()->isHumanPlayer())
     283                    this->gtinfo_->pawnKilled(victim->getPlayer());
    271284
    272285                ControllableEntity* entity = this->defaultControllableEntity_.fabricate(victim->getCreator());
     
    345358                it->second.state_ = PlayerState::Dead;
    346359
    347                 if (!it->first->isReadyToSpawn() || !this->gtinfo_->bStarted_)
     360                if (!it->first->isReadyToSpawn() || !this->gtinfo_->hasStarted())
    348361                {
    349362                    this->spawnPlayerAsDefaultPawn(it->first);
     
    356369    void Gametype::checkStart()
    357370    {
    358         if (!this->gtinfo_->bStarted_)
    359         {
    360             if (this->gtinfo_->bStartCountdownRunning_)
    361             {
    362                 if (this->gtinfo_->startCountdown_ <= 0)
    363                 {
    364                     this->gtinfo_->bStartCountdownRunning_ = false;
    365                     this->gtinfo_->startCountdown_ = 0;
     371        if (!this->gtinfo_->hasStarted())
     372        {
     373            if (this->gtinfo_->isStartCountdownRunning())
     374            {
     375                if (this->gtinfo_->getStartCountdown() <= 0.0f)
     376                {
     377                    this->gtinfo_->stopStartCountdown();
     378                    this->gtinfo_->setStartCountdown(0.0f);;
    366379                    this->start();
    367380                }
     
    388401                        // If in developer's mode, there is no start countdown.
    389402                        if(Core::getInstance().inDevMode())
    390                             this->gtinfo_->startCountdown_ = 0;
     403                            this->start();
    391404                        else
    392                             this->gtinfo_->startCountdown_ = this->initialStartCountdown_;
    393                         this->gtinfo_->bStartCountdownRunning_ = true;
     405                            this->gtinfo_->setStartCountdown(this->initialStartCountdown_);
     406                        this->gtinfo_->startStartCountdown();
    394407                    }
    395408                }
     
    401414    {
    402415        for (std::map<PlayerInfo*, Player>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
     416        {
    403417            if (it->first->isReadyToSpawn() || this->bForceSpawn_)
    404418                this->spawnPlayer(it->first);
     419        }
    405420    }
    406421
     
    421436            player->startControl(spawnpoint->spawn());
    422437            this->players_[player].state_ = PlayerState::Alive;
     438
     439            if(player->isHumanPlayer())
     440                this->gtinfo_->playerSpawned(player);
     441           
    423442            this->playerPostSpawn(player);
    424443        }
  • code/branches/presentation/src/orxonox/gametypes/Gametype.h

    r8178 r8637  
    7878
    7979            inline bool hasStarted() const
    80                 { return this->gtinfo_->bStarted_; }
     80                { return this->gtinfo_->hasStarted(); }
    8181            inline bool hasEnded() const
    82                 { return this->gtinfo_->bEnded_; }
     82                { return this->gtinfo_->hasEnded(); }
    8383
    8484            virtual void start();
     
    114114
    115115            inline bool isStartCountdownRunning() const
    116                 { return this->gtinfo_->bStartCountdownRunning_; }
     116                { return this->gtinfo_->isStartCountdownRunning(); }
    117117            inline float getStartCountdown() const
    118                 { return this->gtinfo_->startCountdown_; }
     118                { return this->gtinfo_->getStartCountdown(); }
    119119
    120120            inline void setHUDTemplate(const std::string& name)
    121                 { this->gtinfo_->hudtemplate_ = name; }
     121                { this->gtinfo_->setHUDTemplate(name); }
    122122            inline const std::string& getHUDTemplate() const
    123                 { return this->gtinfo_->hudtemplate_; }
     123                { return this->gtinfo_->getHUDTemplate(); }
    124124
    125125            void addBots(unsigned int amount);
     
    167167
    168168            SmartPtr<GametypeInfo> gtinfo_;
    169 
     169           
    170170            bool bAutoStart_;
    171171            bool bForceSpawn_;
  • code/branches/presentation/src/orxonox/infos/GametypeInfo.cc

    r8327 r8637  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      Damian 'Mozork' Frick
    2626 *
    2727 */
     28
     29/**
     30    @file GametypeInfo.cc
     31    @brief Implementation of the GametypeInfo class
     32*/
    2833
    2934#include "GametypeInfo.h"
     
    3136#include "core/CoreIncludes.h"
    3237#include "core/GameMode.h"
     38#include "network/Host.h"
    3339#include "network/NetworkFunction.h"
    34 #include "network/Host.h"
     40#include "util/Convert.h"
     41
     42#include "controllers/HumanController.h"
    3543#include "interfaces/GametypeMessageListener.h"
     44#include "interfaces/NotificationListener.h"
     45
     46#include "PlayerInfo.h"
    3647
    3748namespace orxonox
     
    4556    registerMemberNetworkFunction(GametypeInfo, dispatchFadingMessage);
    4657
     58    registerMemberNetworkFunction(GametypeInfo, changedReadyToSpawn);
     59    registerMemberNetworkFunction(GametypeInfo, changedSpawned);
     60
     61    /*static*/ const std::string GametypeInfo::NOTIFICATION_SENDER("gameinfo");
     62
     63    /**
     64    @brief
     65        Registers and initializes the object.
     66    */
    4767    GametypeInfo::GametypeInfo(BaseObject* creator) : Info(creator)
    4868    {
    4969        RegisterObject(GametypeInfo);
    50 
     70       
    5171        this->bStarted_ = false;
    5272        this->bEnded_ = false;
    53         this->startCountdown_ = 0;
     73        this->startCountdown_ = 0.0f;
    5474        this->bStartCountdownRunning_ = false;
     75        this->counter_ = 0;
     76        this->spawned_ = false;
     77        this->readyToSpawn_ = false;
    5578
    5679        this->registerVariables();
     
    6386    void GametypeInfo::registerVariables()
    6487    {
    65         registerVariable(this->bStarted_,               VariableDirection::ToClient);
    66         registerVariable(this->bEnded_,                 VariableDirection::ToClient);
     88        registerVariable(this->bStarted_,               VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStarted));
     89        registerVariable(this->bEnded_,                 VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedEnded));
     90        registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedStartCountdownRunning));
    6791        registerVariable(this->startCountdown_,         VariableDirection::ToClient);
    68         registerVariable(this->bStartCountdownRunning_, VariableDirection::ToClient);
     92        registerVariable(this->counter_,                VariableDirection::ToClient, new NetworkCallback<GametypeInfo>(this, &GametypeInfo::changedCountdownCounter));
    6993        registerVariable(this->hudtemplate_,            VariableDirection::ToClient);
    7094    }
     95
     96    /**
     97    @brief
     98        Is called when the game has changed to started.
     99    */
     100    void GametypeInfo::changedStarted(void)
     101    {
     102       
     103    }
     104
     105    /**
     106    @brief
     107        Is called when the game has changed to ended.
     108    */
     109    void GametypeInfo::changedEnded(void)
     110    {
     111        // If the game has ended, a "Game has ended" notification is displayed.
     112        if(this->hasEnded())
     113            NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER);
     114    }
     115
     116    /**
     117    @brief
     118        Is called when the start countdown has been either started or stopped.
     119    */
     120    void GametypeInfo::changedStartCountdownRunning(void)
     121    {
     122        // Send first countdown notification if the countdown has started.
     123        if(this->isReadyToSpawn() && !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
     124            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
     125    }
     126
     127    /**
     128    @brief
     129        Is called when the start countdown counter has changed.
     130    */
     131    void GametypeInfo::changedCountdownCounter(void)
     132    {
     133        // Send countdown notification if the counter has gone down.
     134        if(this->isReadyToSpawn() &&  !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
     135            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
     136    }
     137
     138    /**
     139    @brief
     140        Inform the GametypeInfo that the local player has changed its ready to spawn status.
     141    @param ready
     142        Whether the player has become ready to spawn or not.
     143    */
     144    void GametypeInfo::changedReadyToSpawn(bool ready)
     145    {
     146        if(this->readyToSpawn_ == ready)
     147            return;
     148
     149        this->readyToSpawn_ = ready;
     150
     151        // Send "Waiting for other players" if the player is ready to spawn but the game has not yet started nor is the countdown running.
     152        if(this->readyToSpawn_ && !this->hasStarted() && !this->isStartCountdownRunning() && !this->hasEnded())
     153            NotificationListener::sendNotification("Waiting for other players", GametypeInfo::NOTIFICATION_SENDER);
     154        // Send current countdown if the player is ready to spawn and the countdown has already started.
     155        else if(this->readyToSpawn_ && !this->hasStarted() && this->isStartCountdownRunning() && !this->hasEnded())
     156            NotificationListener::sendNotification(multi_cast<std::string>(this->counter_), GametypeInfo::NOTIFICATION_SENDER);
     157    }
     158
     159    /**
     160    @brief
     161        Inform the GametypeInfo that the game has started.
     162    */
     163    void GametypeInfo::start(void)
     164    {
     165        if(this->bStarted_)
     166            return;
     167       
     168        this->bStarted_ = true;
     169        this->changedStarted();
     170    }
     171
     172    /**
     173    @brief
     174        Inform the GametypeInfo that the game has ended.
     175    */
     176    void GametypeInfo::end(void)
     177    {
     178        if(this->bEnded_)
     179            return;
     180
     181        this->bEnded_ = true;
     182        this->changedEnded();
     183    }
     184
     185    /**
     186    @brief
     187        Set the start countdown to the input value.
     188    @param countdown
     189        The countdown to be set.
     190    */
     191    void GametypeInfo::setStartCountdown(float countdown)
     192    {
     193        if(this->startCountdown_ == countdown || countdown < 0.0f)
     194            return;
     195       
     196        this->startCountdown_ = countdown;
     197        // Set the counter to the ceiling of the current countdown.
     198        this->counter_ = ceil(countdown);
     199        this->changedCountdownCounter();
     200    }
     201
     202    /**
     203    @brief
     204        Count down the start countdown by the specified value.
     205    @param countDown
     206        The amount by which we count down.
     207    */
     208    void GametypeInfo::countdownStartCountdown(float countDown)
     209    {
     210        float newCountdown = this->startCountdown_ - countDown;
     211        // If we have switched integers or arrived at zero, we also count down the start countdown counter.
     212        if(ceil(newCountdown) != ceil(this->startCountdown_) || newCountdown <= 0.0f)
     213            this->countDown();
     214        this->startCountdown_ = newCountdown;
     215    }
     216
     217    /**
     218    @brief
     219        Count down the start countdown counter.
     220    */
     221    void GametypeInfo::countDown()
     222    {
     223        if(this->counter_ == 0)
     224            return;
     225       
     226        this->counter_--;
     227        this->changedCountdownCounter();
     228    }
     229
     230    /**
     231    @brief
     232        Inform the GametypeInfo about the start of the start countdown.
     233    */
     234    void GametypeInfo::startStartCountdown(void)
     235    {
     236        if(GameMode::isMaster())
     237        {
     238            if(this->bStartCountdownRunning_)
     239                return;
     240
     241            this->bStartCountdownRunning_ = true;
     242            this->changedStartCountdownRunning();
     243        }
     244    }
     245
     246    /**
     247    @brief
     248        Inform the GametypeInfo about the stop of the start countdown.
     249    */
     250    void GametypeInfo::stopStartCountdown(void)
     251    {
     252        if(GameMode::isMaster())
     253        {
     254            if(!this->bStartCountdownRunning_)
     255                return;
     256
     257            this->bStartCountdownRunning_ = false;
     258            this->changedStartCountdownRunning();
     259        }
     260    }
     261
     262    /**
     263    @brief
     264        Inform the GametypeInfo about a player that is ready to spawn.
     265    @param player
     266        The player that is ready to spawn.
     267    */
     268    void GametypeInfo::playerReadyToSpawn(PlayerInfo* player)
     269    {
     270        if(GameMode::isMaster())
     271        {
     272            // If the player has spawned already.
     273            if(this->spawnedPlayers_.find(player) != this->spawnedPlayers_.end())
     274                return;
     275
     276            this->spawnedPlayers_.insert(player);
     277            this->setReadyToSpawnHelper(player, true);
     278        }
     279    }
     280
     281    /**
     282    @brief
     283        Inform the GametypeInfo about a player whose Pawn has been killed.
     284    @param player
     285        The player whose Pawn has been killed.
     286    */
     287    void GametypeInfo::pawnKilled(PlayerInfo* player)
     288    {
     289        if(GameMode::isMaster())
     290        {
     291            NotificationListener::sendNotification("Press [Fire] to respawn", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
     292            // Remove the player from the list of players that have spawned, since it currently is not.
     293            this->spawnedPlayers_.erase(player);
     294            this->setReadyToSpawnHelper(player, false);
     295            this->setSpawnedHelper(player, false);
     296        }
     297    }
     298
     299    /**
     300    @brief
     301        Inform the GametypeInfo about a player that has spawned.
     302    @param player
     303        The player that has spawned.
     304    */
     305    void GametypeInfo::playerSpawned(PlayerInfo* player)
     306    {
     307        if(GameMode::isMaster())
     308        {
     309            if(this->hasStarted() && !this->hasEnded())
     310            {
     311                //NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER, notificationSendMode::network, player->getClientID());
     312                this->setSpawnedHelper(player, true);
     313            }
     314        }
     315    }
     316
     317    /**
     318    @brief
     319        Inform the GametypeInfo that the local player has changed its spawned status.
     320    @param spawned
     321        Whether the local player has changed to spawned or to not spawned.
     322    */
     323    void GametypeInfo::changedSpawned(bool spawned)
     324    {
     325        if(this->spawned_ == spawned)
     326            return;
     327       
     328        this->spawned_ = spawned;
     329        // Clear the notifications if the Player has spawned.
     330        if(this->spawned_ && !this->hasEnded())
     331            NotificationListener::sendCommand("clear", GametypeInfo::NOTIFICATION_SENDER);
     332    }
     333
     334    /**
     335    @brief
     336        Inform the GametypeInfo about a player that has entered,
     337    @param player
     338        The player that has entered.
     339    */
     340    void GametypeInfo::playerEntered(PlayerInfo* player)
     341    {
     342        if(GameMode::isMaster())
     343        {
     344            // Display "Press [Fire] to start the match" if the game has not yet ended.
     345            if(!this->hasEnded())
     346                NotificationListener::sendNotification("Press [Fire] to start the match", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
     347            // Else display "Game has ended".
     348            else
     349                NotificationListener::sendNotification("Game has ended", GametypeInfo::NOTIFICATION_SENDER, notificationMessageType::info, notificationSendMode::network, player->getClientID());
     350        }
     351    }
     352
     353    /**
     354    @brief
     355        Helper method. Sends changedReadyToSpawn notifiers over the network.
     356    @param player
     357        The player that has changed its ready to spawn status.
     358    @param ready
     359        The new ready to spawn status.
     360    */
     361    void GametypeInfo::setReadyToSpawnHelper(PlayerInfo* player, bool ready)
     362    {
     363        if(GameMode::isMaster())
     364        {
     365            if(player->getClientID() == CLIENTID_SERVER)
     366                this->changedReadyToSpawn(ready);
     367            else
     368                callMemberNetworkFunction(GametypeInfo, changedReadyToSpawn, this->getObjectID(), player->getClientID(), ready);
     369        }
     370    }
     371
     372    /**
     373    @brief
     374        Helper method. Sends changedSpawned notifiers over the network.
     375    @param player
     376        The player that has changed its spawned status.
     377    @param ready
     378        The new spawned status.
     379    */
     380    void GametypeInfo::setSpawnedHelper(PlayerInfo* player, bool spawned)
     381    {
     382        if(GameMode::isMaster())
     383        {
     384            if(player->getClientID() == CLIENTID_SERVER)
     385                    this->changedSpawned(spawned);
     386            else
     387                callMemberNetworkFunction(GametypeInfo, changedSpawned, this->getObjectID(), player->getClientID(), spawned);
     388        }
     389    }
     390
     391    // Announce messages.
     392    // TODO: Replace with notifications.
    71393
    72394    void GametypeInfo::sendAnnounceMessage(const std::string& message)
  • code/branches/presentation/src/orxonox/infos/GametypeInfo.h

    r7163 r8637  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      Damian 'Mozork' Frick
    2626 *
    2727 */
     28
     29/**
     30    @file GametypeInfo.h
     31    @brief Definition of the GametypeInfo class
     32*/
    2833
    2934#ifndef _GametypeInfo_H__
     
    3338
    3439#include <string>
     40
    3541#include "Info.h"
    3642
    3743namespace orxonox
    3844{
     45
     46    /**
     47    @brief
     48        The GametypeInfo class keeps track of the state of the game and provides facilities to inform the player about it.
     49
     50    @author
     51        Fabian 'x3n' Landau
     52    @author
     53        Damian 'Mozork' Frick
     54    */
    3955    class _OrxonoxExport GametypeInfo : public Info
    4056    {
     
    4561            virtual ~GametypeInfo();
    4662
     63            /**
     64            @brief Get whether the game has started yet.
     65            @return Returns true if the game has started, false if not.
     66            */
    4767            inline bool hasStarted() const
    4868                { return this->bStarted_; }
     69            void changedStarted(void); // Is called when the game has changed to started.
     70           
     71            /**
     72            @brief Get whether the game has ended yet.
     73            @return Returns true if the game has ended, false if not.
     74            */
    4975            inline bool hasEnded() const
    5076                { return this->bEnded_; }
     77            void changedEnded(void); // Is called when the game has changed to ended.
    5178
     79            /**
     80            @brief Get whether the start countdown is currently running.
     81            @return Returns true if the countdown is running, false if not.
     82            */
    5283            inline bool isStartCountdownRunning() const
    5384                { return this->bStartCountdownRunning_; }
     85            void changedStartCountdownRunning(void); // Is called when the start countdown has been either started or stopped.
     86
     87            /**
     88            @brief Get the current value of the start countdown.
     89            @return Returns the current value of the start countdown.
     90            */
    5491            inline float getStartCountdown() const
    5592                { return this->startCountdown_; }
     93
     94            /**
     95            @brief Get the current start countdown counter.
     96                   The start countdown counter only has integer values that correspond to the actually displayed countdown.
     97            @return Returns the current integer countdown counter.
     98            */
     99            inline unsigned int getStartCountdownCounter() const
     100                { return this->counter_; }
     101            void changedCountdownCounter(void); // Is called when the start countdown counter has changed.
     102
     103            /**
     104            @brief Get whether the local player is ready to spawn.
     105            @return Returns true if the player is ready to spawn, false if not.
     106            */
     107            inline bool isReadyToSpawn() const
     108                { return this->readyToSpawn_; }
     109            void changedReadyToSpawn(bool ready); // Inform the GametypeInfo that the local player has changed its spawned status.
     110           
     111            /**
     112            @brief Get whether the local player is spawned.
     113            @return Returns true if the local player is currently spawned, false if not.
     114            */
     115            inline bool isSpawned() const
     116                { return this->spawned_; }
     117            void changedSpawned(bool spawned); // Inform the GametypeInfo that the local player has changed its spawned status.
    56118
    57119            inline const std::string& getHUDTemplate() const
     
    70132            void dispatchStaticMessage(const std::string& message,const ColourValue& colour);
    71133            void dispatchFadingMessage(const std::string& message);
     134           
     135        protected:
     136            void start(void); // Inform the GametypeInfo that the game has started.
     137            void end(void); // Inform the GametypeInfo that the game has ended.
     138            void setStartCountdown(float countdown); // Set the start countdown to the input value.
     139            void countdownStartCountdown(float countDown); // Count down the start countdown by the specified value.
     140            void countDown(); // Count down the start countdown counter.
     141            void startStartCountdown(void); // Inform the GametypeInfo about the start of the start countdown.
     142            void stopStartCountdown(void); // Inform the GametypeInfo about the stop of the start countdown.
     143            void playerReadyToSpawn(PlayerInfo* player); // Inform the GametypeInfo about a player that is ready to spawn.
     144            void pawnKilled(PlayerInfo* player); // Inform the GametypeInfo about a player whose Pawn has been killed.
     145            void playerSpawned(PlayerInfo* player); // Inform the GametypeInfo about a player that has spawned.
     146            void playerEntered(PlayerInfo* player); // Inform the GametypeInfo about a player that has entered,
     147
     148            inline void setHUDTemplate(const std::string& templateName)
     149                { this->hudtemplate_ = templateName; };
    72150
    73151        private:
    74152            void registerVariables();
     153            void setSpawnedHelper(PlayerInfo* player, bool spawned); // Helper method. Sends changedReadyToSpawn notifiers over the network.
     154            void setReadyToSpawnHelper(PlayerInfo* player, bool ready); // Helper method. Sends changedSpawned notifiers over the network.
    75155
    76             bool bStarted_;
    77             bool bEnded_;
    78             bool bStartCountdownRunning_;
    79             float startCountdown_;
     156            static const std::string NOTIFICATION_SENDER; //!< The name of the sender for the sending of notifications.
     157
     158            bool bStarted_; //!< Whether the game has started,
     159            bool bEnded_; //!< Whether the game has ended.
     160            bool bStartCountdownRunning_; //!< Whether the start countdown is running.
     161            float startCountdown_; //!< The current value of the start countdown.
     162            unsigned int counter_; //!< The current integer value of the start countdown, the start countdown counter.
    80163            std::string hudtemplate_;
     164           
     165            std::set<PlayerInfo*> spawnedPlayers_; //!< A set of players that are currently spawned.
     166            bool spawned_; //!< Whether the local Player is currently spawned.
     167            bool readyToSpawn_; //!< Whether the local Player is ready to spawn.
    81168    };
    82169}
  • code/branches/presentation/src/orxonox/interfaces/CMakeLists.txt

    r7504 r8637  
    11ADD_SOURCE_FILES(ORXONOX_SRC_FILES
    22  InterfaceCompilation.cc
     3  NotificationListener.cc
    34  Pickupable.cc
    45  PickupCarrier.cc
  • code/branches/presentation/src/orxonox/interfaces/InterfaceCompilation.cc

    r7606 r8637  
    8686        RegisterRootObject(Rewardable);
    8787    }
    88 
    89     //----------------------------
    90     // NotificationListener
    91     //----------------------------
    92     NotificationListener::NotificationListener()
    93     {
    94         RegisterRootObject(NotificationListener);
    95     }
    9688}
  • code/branches/presentation/src/orxonox/interfaces/NotificationListener.h

    r7552 r8637  
    2121 *
    2222 *   Author:
    23  *      Fabian 'x3n' Landau
     23 *      Damian 'Mozork' Frick
    2424 *   Co-authors:
    2525 *      ...
     
    4848namespace orxonox
    4949{
    50     class Notification;
     50    // TODO: Document.
     51    namespace notificationMessageType
     52    {
     53        enum Value {
     54            info,
     55            important
     56        };
     57    }
     58   
     59    namespace notificationSendMode
     60    {
     61        enum Value {
     62            local,
     63            network,
     64            broadcast
     65        };
     66    }
     67   
     68    namespace notificationCommand
     69    {
     70        enum Value {
     71            none,
     72            clear
     73        };
     74    }
    5175
     76    // TODO: Update doc.
    5277    /**
    5378    @brief
    5479        NotificationListener interface.
    5580
    56         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)
    57         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".
     81        The NotificationListener interface (or more precisely abstract class) presents a means of being informed when a new @ref orxonox::Notification "Notification" is sent.
     82        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.
     83
     84        When inheriting from a NotificationListener it is important to provide an appropriate implementation of registerNotification() and executeCommand().
    5885
    5986    @author
    60         Fabian 'x3n' Landau
    61 
     87        Damian 'Mozork' Frick
     88       
    6289    @ingroup Notifications
     90    @todo Consistent terminology between message, notification and command.
    6391    */
    6492    class _OrxonoxExport NotificationListener : virtual public OrxonoxClass
     
    6997
    7098            /**
    71             @brief Get the senders that are targets of this NotificationListener.
    72             @return Returns the set of senders that are targets of this NotificationListener.
     99            @brief Sends a Notification with the specified message to the specified client from the specified sender.
     100            @param message The message that should be sent.
     101            @param sender The sender that sent the notification. Default is 'none'.
     102            @param messageType The type of the message, can be either 'info' or 'important'. Default is 'info'.
     103            @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.
     104            @param clientId The id of the client the notification should be sent to. Default is 0.
    73105            */
    74             virtual const std::set<std::string> & getTargetsSet(void) = 0;
     106            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)
     107                { NotificationListener::sendNetworkHelper(message, sender, sendMode, clientId, false, messageType); }
     108            /**
     109            @brief Sends a specified command to the specified client from the specified sender.
     110            @param command The command that should be sent (and later executed).
     111            @param sender The sender that sent the notification. Default is 'none'.
     112            @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.
     113            @param clientId The id of the client the command should be sent to. Default is 0.
     114            */
     115            static void sendCommand(const std::string& command, const std::string& sender = NotificationListener::NONE, notificationSendMode::Value sendMode = notificationSendMode::local, unsigned int clientId = 0)
     116                { NotificationListener::sendNetworkHelper(command, sender, sendMode, clientId, true); }
    75117
     118            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.
     119
     120            //TODO: Make protected?
     121           
    76122            /**
    77             @brief Updates the whole NotificationListener.
    78                    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.
     123            @brief Registers a notification with the NotificationListener.
     124                   This needs to be overloaded by each class inheriting from NotificationListener.
     125            @param message The notification's message.
     126            @param sender The sender of the notification.
     127            @param type The type of the notification.
     128            @return Returns true if the notification was successfully registered, false if not.
    79129            */
    80             virtual void update(void) = 0;
     130            virtual bool registerNotification(const std::string& message, const std::string& sender, notificationMessageType::Value type)
     131                { return false; }
    81132            /**
    82             @brief Updates the NotificationListener, when a new Notification has come in at the specified time.
    83             @param notification A pointer to the @ref orxonox::Notification "Notification".
    84             @param time The time the @ref orxonox::Notification "Notification" has come in.
     133            @brief Executes a command with the NotificationListener
     134                   This needs to be overloaded by each class inheriting from NotificationListener.
     135            @param command The command to be executed.
     136            @param sender The sender of the command.
     137            @return Returns true if the command was successfully executed, false if not.
    85138            */
    86             virtual void update(Notification* notification, const std::time_t & time) = 0;
     139            virtual bool executeCommand(notificationCommand::Value command, const std::string& sender) { return false; }
     140
     141        public:
     142           
     143            static const std::string ALL; //!< Static string to indicate a sender that sends to all NotificationQueues.
     144            static const std::string NONE; //!< Static string to indicate a sender that sends to no specific NotificationQueues.
     145           
     146            //! Commands
     147            static const std::string COMMAND_CLEAR;
     148            static const std::string COMMAND_NONE;
     149           
     150        protected:
     151            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.
     152
     153            static notificationCommand::Value str2Command(const std::string& string); // Helper method. Converts a string into the enum for a command.
     154            static const std::string& command2Str(notificationCommand::Value command); // Helper method. Converts a command enum into its corresponding string.
    87155    };
    88156}
Note: See TracChangeset for help on using the changeset viewer.