Changeset 7456 for code/trunk/src

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

r7413	r7456
28	28
29	29	/**
30		@file
	30	@file Notification.cc
31	31	@brief Implementation of the Notification class.
32	32	*/

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

-                      r7403
+                      r7456
 /**
     @file
+    @file Notification.h
     @brief Definition of the Notification class.
+    @ingroup Notifications
 */

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

r7408	r7456
28	28
29	29	/**
30		@file
	30	@file NotificationDispatcher.cc
31	31	@brief Implementation of the NotificationDispatcher class.
32	32	*/

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

-                      r7407
+                      r7456
 /**
     @file
+    @file NotificationDispatcher.h
     @brief Definition of the NotificationDispatcher class.
+    @ingroup Notifications
 */

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

r7403	r7456
30	30	@file NotificationManager.h
31	31	@brief Definition of the NotificationManager class.
	32	@ingroup Notifications
32	33	*/
33	34

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

r7417	r7456
30	30	@file NotificationQueue.h
31	31	@brief Definition of the NotificationQueue class.
	32	@ingroup Notifications
32	33	*/
33	34

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

r7403	r7456
28	28
29	29	/**
30		@file
	30	@file CommandNotification.cc
31	31	@brief Implementation of the CommandNotification class.
32	32	*/

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

-                      r7403
+                      r7456
 /**
     @file
+    @file CommandNotification.h
     @brief Definition of the CommandNotification class.
+    @ingroup NotificationDispatchers
 */

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

-                      r7285
+                      r7456
+ *
  */
+/**
+    @file SimpleNotification.cc
+    @brief Implementation of the SimpleNotification class.
+*/
 #include "SimpleNotification.h"

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

-                      r7285
+                      r7456
+ *
  */
+/**
+    @file SimpleNotification.h
+    @brief Declaration of the SimpleNotification class.
+    @ingroup NotificationDispatchers
+*/
 #ifndef _SimpleNotification_H__

code/trunk/src/modules/pickup/CollectiblePickup.h

r7285	r7456
30	30	@file CollectiblePickup.h
31	31	@brief Definition of the CollectiblePickup class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/DroppedPickup.h

r7163	r7456
30	30	@file DroppedPickup.h
31	31	@brief Definition of the DroppedPickup class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/Pickup.h

r7208	r7456
30	30	@file Pickup.h
31	31	@brief Declaration of the Pickup class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/PickupCollection.h

r7163	r7456
30	30	@file PickupCollection.h
31	31	@brief Declaration of PickupCollection.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/PickupCollectionIdentifier.h

r7163	r7456
30	30	@file PickupCollectionIdentifier.h
31	31	@brief Declaration of PickupCollectionIdentifier.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/PickupManager.h

r7206	r7456
30	30	@file PickupManager.h
31	31	@brief Definition of the PickupManager class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/PickupRepresentation.h

r7163	r7456
30	30	@file PickupRepresentation.h
31	31	@brief Definition of the PickupRepresentation class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/PickupSpawner.h

r7163	r7456
30	30	@file PickupSpawner.h
31	31	@brief Definition of the PickupSpawner class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/modules/pickup/items/DronePickup.h

r7163	r7456
30	30	@file DronePickup.h
31	31	@brief Declaration of the DronePickup class.
	32	@ingroup PickupItems
32	33	*/
33	34

code/trunk/src/modules/pickup/items/HealthPickup.h

r7163	r7456
30	30	@file HealthPickup.h
31	31	@brief Declaration of the HealthPickup class.
	32	@ingroup PickupItems
32	33	*/
33	34

code/trunk/src/modules/pickup/items/InvisiblePickup.h

r7208	r7456
30	30	@file InvisiblePickup.h
31	31	@brief Declaration of the InvisiblePickup class.
	32	@ingroup PickupItems
32	33	*/
33	34

code/trunk/src/modules/pickup/items/MetaPickup.h

r7163	r7456
30	30	@file MetaPickup.h
31	31	@brief Definition of the MetaPickup class.
	32	@ingroup PickupItems
32	33	*/
33	34

code/trunk/src/modules/pickup/items/ShieldPickup.h

r7208	r7456
31	31	@file ShieldPickup.h
32	32	@brief Declaration of the ShieldPickup class.
	33	@ingroup PickupItems
33	34	*/
34	35

code/trunk/src/modules/pickup/items/SpeedPickup.h

r7208	r7456
30	30	@file SpeedPickup.h
31	31	@brief Declaration of the SpeedPickup class.
	32	@ingroup PickupItems
32	33	*/
33	34

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

-                      r7163
+                      r7456
 /**
     @file
+    @file GlobalQuest.cc
     @brief Implementation of the GlobalQuest class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "QuestEffect.h"
 …
     bool GlobalQuest::fail(PlayerInfo* player)
+    {
         if(!this->isFailable(player)) //!< Check whether the Quest can be failed.
+        if(!this->isFailable(player)) // Check whether the Quest can be failed.
+        {
             COUT(4) << "A non-completable quest was trying to be failed." << std::endl;
 …
         Quest::fail(player);
+    //! Iterate through all players possessing this Quest.
+    for(std::set<PlayerInfo*>::const_iterator it = players_.begin(); it != players_.end(); it++)
+    {
+        QuestEffect::invokeEffects(*it, this->getFailEffectList());
+    }
+    return true;
+        // Iterate through all players possessing this Quest.
+        for(std::set<PlayerInfo*>::const_iterator it = players_.begin(); it != players_.end(); it++)
+            QuestEffect::invokeEffects(*it, this->getFailEffectList());
+        return true;
+    }
 …
     bool GlobalQuest::complete(PlayerInfo* player)
+    {
         if(!this->isCompletable(player)) //!< Check whether the Quest can be completed.
+        if(!this->isCompletable(player)) // Check whether the Quest can be completed.
+        {
             COUT(4) << "A non-completable quest was trying to be completed." << std::endl;
 …
+        }
         //! Iterate through all players possessing the Quest.
+        // Iterate through all players possessing the Quest.
         for(std::set<PlayerInfo*>::const_iterator it = players_.begin(); it != players_.end(); it++)
+        {
             QuestEffect::invokeEffects(*it, this->getCompleteEffectList());
+        }
         Quest::complete(player);
         QuestEffect::invokeEffects(player, this->rewards_); //!< Invoke reward QuestEffects on the player completing the Quest.
+        QuestEffect::invokeEffects(player, this->rewards_); // Invoke reward QuestEffects on the player completing the Quest.
         return true;
+    }
 …
+    {
         if(!(this->getParentQuest() == NULL || this->getParentQuest()->isActive(player)))
+        {
+            return false;
+        }
+            return false;
         return (this->isInactive(player) && !(this->status_ == QuestStatus::Completed || this->status_ == QuestStatus::Failed));
+    }
 …
     QuestStatus::Value GlobalQuest::getStatus(const PlayerInfo* player) const
+    {
         if(player == NULL) //!< We don't want NULL-Pointers!
+        {
+        //TODO: Replace with assert.
+        if(player == NULL) // We don't want NULL-Pointers!
             ThrowException(Argument, "The input PlayerInfo* is NULL.");
+        }
+        //! Find the player.
+        // Find the player.
         std::set<PlayerInfo*>::const_iterator it = this->players_.find((PlayerInfo*)(void*)player);
+        if (it != this->players_.end()) //!< If the player was found.
+        {
+        if (it != this->players_.end()) // If the player was found.
             return this->status_;
+        }
         return QuestStatus::Inactive;
 …
     bool GlobalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)
+    {
+        if(player == NULL) //!< We don't want NULL-Pointers!
+        {
+            return false;
+        }
+        //! Find the player.
+        //TODO: Replace with assert.
+        if(player == NULL) // We don't want NULL-Pointers!
+            return false;
+        // Find the player.
         std::set<PlayerInfo*>::const_iterator it = this->players_.find(player);
+        if (it == this->players_.end()) //!< Player is not yet in the list.
+        {
+            this->players_.insert(player); //!< Add the player to the set.
+        }
+        this->status_ = status; //!< Set the status, which is global, remember...?
+        if (it == this->players_.end()) // Player is not yet in the list.
+            this->players_.insert(player); // Add the player to the set.
+        this->status_ = status; // Set the status, which is global, remember...?
         return true;
+    }
 …
     bool GlobalQuest::addRewardEffect(QuestEffect* effect)
+    {
+        if(effect == NULL) //!< We don't want NULL-Pointers!
+        //TODO: Replace with assert?
+        if(effect == NULL) // We don't want NULL-Pointers!
+        {
             COUT(2) << "The reward effect to be added to quest {" << this->getId() << "} was NULL." << std::endl;
 …
+        }
         this->rewards_.push_back(effect); //!< Add the QuestEffect to the list.
+        this->rewards_.push_back(effect); // Add the QuestEffect to the list.
         COUT(4) << "Reward effect was added to Quest {" << this->getId() << "}." << std::endl;
 …
+        {
             if(i == 0)
+            {
                return *effect;
+            }
             i--;
+        }
 …
+    }
+}

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

-                      r7401
+                      r7456
 /**
     @file
+    @file GlobalQuest.h
     @brief Definition of the GlobalQuest class.
+    @ingroup Questsystem
 */
 …
     /**
     @brief
         GlobalQuests are Quests, that have the same status for all players.
+        GlobalQuests are @ref orxonox::Quest "Quests", that have the same status for all players.
         This means, that when a player successfully completes a GlobalQuest, it is completed for all players that have it.
         Creating a GlobalQuest through XML goes as follows:
         @code
         <GlobalQuest id="questId">

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

-                      r7163
+                      r7456
 /**
     @file
+    @file LocalQuest.cc
     @brief Implementation of the LocalQuest class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "QuestEffect.h"
 …
     bool LocalQuest::fail(PlayerInfo* player)
+    {
         if(!this->isFailable(player)) //!< Checks whether the quest can be failed.
+        if(!this->isFailable(player)) // Checks whether the quest can be failed.
+        {
             COUT(4) << "A non-failable quest was trying to be failed." << std::endl;
 …
         Quest::fail(player);
         QuestEffect::invokeEffects(player, this->getFailEffectList()); //!< Invoke the failEffects.
+        QuestEffect::invokeEffects(player, this->getFailEffectList()); // Invoke the failEffects.
         return true;
+    }
 …
     bool LocalQuest::complete(PlayerInfo* player)
+    {
         if(!this->isCompletable(player)) //!< Checks whether the Quest can be completed.
+        if(!this->isCompletable(player)) // Checks whether the Quest can be completed.
+        {
             COUT(4) << "A non-completable quest was trying to be completed." << std::endl;
 …
         Quest::complete(player);
         QuestEffect::invokeEffects(player, this->getCompleteEffectList()); //!< Invoke the complete QuestEffects.
+        QuestEffect::invokeEffects(player, this->getCompleteEffectList()); // Invoke the complete QuestEffects.
         return true;
+    }
 …
+    {
         if(!(this->getParentQuest() == NULL || this->getParentQuest()->isActive(player)))
+        {
+            return false;
+        }
+            return false;
         return this->isInactive(player);
+    }
 …
     QuestStatus::Value LocalQuest::getStatus(const PlayerInfo* player) const
+    {
         if(player == NULL) //!< No player has no defined status.
+        {
+        //TODO: Replace with assert.
+        if(player == NULL) // No player has no defined status.
             ThrowException(Argument, "The input PlayerInfo* is NULL.");
+        }
         std::map<const PlayerInfo*, QuestStatus::Value>::const_iterator it = this->playerStatus_.find(player);
+        if (it != this->playerStatus_.end()) //!< If there is a player in the map.
+        {
+        if (it != this->playerStatus_.end()) // If there is a player in the map.
             return it->second;
+        }
+        return QuestStatus::Inactive; //!< If the player is not yet in the map, that means the status of the quest form him is 'inactive'.
+        return QuestStatus::Inactive; // If the player is not yet in the map, that means the status of the quest form him is 'inactive'.
+    }
 …
     bool LocalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)
+    {
+        if(player == NULL) //!< We can't set a status for no player.
+        {
+            return false;
+        }
+        //TODO: Replace with assert.
+        if(player == NULL) // We can't set a status for no player.
+            return false;
         this->playerStatus_[player] = status;

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

-                      r7401
+                      r7456
 /**
     @file
+    @file LocalQuest.h
     @brief Definition of the LocalQuest class.
+    @ingroup Questsystem
 */
 …
     /**
     @brief
         Handles Quests which have different states for different players.
         LocalQuests have (as opposed to GlobalQuests) a different state for each player, that means if for one player the status of the Quest changes it does not for all the other players which also possess this quest.
+        Handles @ref orxonox::Quest "Quests" which have different states for different players.
+        LocalQuests have (as opposed to @ref orxonox::GlobalQuest "GlobalQuests") a different state for each player, that means if for one player the status of the @ref orxonox::Quest "Quest" changes it does not for all the other players which also possess this quest.
         Creating a LocalQuest through XML goes as follows:
         @code
         <LocalQuest id="questId">

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

-                      r7403
+                      r7456
 /**
     @file
+    @file Quest.cc
     @brief Implementation of the Quest class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "QuestDescription.h"
+#include "QuestEffect.h"
+#include "QuestHint.h"
+#include "QuestListener.h"
 #include "QuestManager.h"
-#include "QuestDescription.h"
-#include "QuestHint.h"
-#include "QuestEffect.h"
-#include "QuestListener.h"
 namespace orxonox
 …
         XMLPortObject(Quest, QuestEffect, "complete-effects", addCompleteEffect, getCompleteEffect, xmlelement, mode);
         QuestManager::getInstance().registerQuest(this); //!<Registers the Quest with the QuestManager.
+    }
     /**
     @brief
         Sets the parentquest of the Quest.
+        QuestManager::getInstance().registerQuest(this); // Registers the Quest with the QuestManager.
+    }
+    /**
+    @brief
+        Sets the parent-quest of the Quest.
     @param quest
         A pointer to the Quest to be set as parentquest.
     @return
         Returns true if the parentquest could be set.
+        A pointer to the Quest to be set as parent-quest.
+    @return
+        Returns true if the parent-quest could be set.
     */
     bool Quest::setParentQuest(Quest* quest)
+    {
+        if(quest == NULL) //!< We don't want to set NULL-Pointers.
+        //TODO: Replace with assert.
+        if(quest == NULL) // We don't want to set NULL-Pointers.
+        {
             COUT(2) << "The parentquest to be added to quest {" << this->getId() << "} was NULL." << std::endl;
 …
     /**
     @brief
         Adds a subquest to the Quest.
+        Adds a sub-quest to the Quest.
     @param quest
         A pointer to the Quest to be set as subquest.
     @return
         Returns true if the subquest could be set.
+        A pointer to the Quest to be set as sub-quest.
+    @return
+        Returns true if the sub-quest could be set.
     */
     bool Quest::addSubQuest(Quest* quest)
+    {
+        if(quest == NULL) //!< We don't want to set NULL-Pointers.
+        //TODO: Replace with assert.
+        if(quest == NULL) // We don't want to set NULL-Pointers.
+        {
             COUT(2) << "The subquest to be added to quest {" << this->getId() << "} was NULL." << std::endl;
 …
+        }
         quest->setParentQuest(this); //!< Sets the currentQuest (this) as parentquest for the added subquest.
         this->subQuests_.push_back(quest); //!< Adds the Quest to the end of the list of subquests.
+        quest->setParentQuest(this); // Sets the currentQuest (this) as parent-quest for the added sub-quest.
+        this->subQuests_.push_back(quest); // Adds the Quest to the end of the list of sub-quests.
         COUT(4) << "Sub Quest {" << quest->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
 …
     bool Quest::addHint(QuestHint* hint)
+    {
+        if(hint == NULL) //!< We don't want to set NULL-Pointers. Seriously!
+        //TODO: Replace with assert.
+        if(hint == NULL) // We don't want to set NULL-Pointers. Seriously!
+        {
             COUT(2) << "A NULL-QuestHint was trying to be added." << std::endl;
 …
+        }
         hint->setQuest(this); //!< Sets the current Quest (this) as Quest for the added QuestHint.
         this->hints_.push_back(hint); //!< Adds the QuestHint to the end of the list of QuestHints.
+        hint->setQuest(this); // Sets the current Quest (this) as Quest for the added QuestHint.
+        this->hints_.push_back(hint); // Adds the QuestHint to the end of the list of QuestHints.
         COUT(4) << "QuestHint {" << hint->getId() << "} was added to Quest {" << this->getId() << "}." << std::endl;
 …
     bool Quest::addFailEffect(QuestEffect* effect)
+    {
+        if(effect == NULL) //!< We don't want to set NULL-Pointers.
+        //TODO: Replace with assert.
+        if(effect == NULL) // We don't want to set NULL-Pointers.
+        {
             COUT(2) << "A NULL-QuestEffect was trying to be added" << std::endl;
 …
+        }
         this->failEffects_.push_back(effect); //!< Adds the QuestEffect to the end of the list of fail QuestEffects.
+        this->failEffects_.push_back(effect); // Adds the QuestEffect to the end of the list of fail QuestEffects.
         COUT(4) << "A FailEffect was added to Quest {" << this->getId() << "}." << std::endl;
 …
     bool Quest::addCompleteEffect(QuestEffect* effect)
+    {
+        if(effect == NULL) //!< We don't want to set NULL-Pointers.
+        //TODO: Replace with assert.
+        if(effect == NULL) // We don't want to set NULL-Pointers.
+        {
             COUT(2) << "A NULL-QuestEffect was trying to be added" << std::endl;
 …
+        }
         this->completeEffects_.push_back(effect); //!< Adds the QuestEffect to the end of the list of complete QuestEffects.
+        this->completeEffects_.push_back(effect); // Adds the QuestEffect to the end of the list of complete QuestEffects.
         COUT(4) << "A CompleteEffect was added to Quest {" << this->getId() << "}." << std::endl;
 …
     /**
     @brief
         Returns the subquest at the given index.
+        Returns the sub-quest at the given index.
     @param index
         The index.
     @return
         Returns a pointer to the subquest at the given index. NULL if there is no element at the given index.
+        Returns a pointer to the sub-quest at the given index. NULL if there is no element at the given index.
     */
     const Quest* Quest::getSubQuest(unsigned int index) const
 …
         int i = index;
         //! Iterate through all subquests.
+        // Iterate through all subquests.
         for (std::list<Quest*>::const_iterator subQuest = this->subQuests_.begin(); subQuest != this->subQuests_.end(); ++subQuest)
+        {
+            if(i == 0) //!< We're counting down...
+            {
+            if(i == 0) // We're counting down...
                return *subQuest;
+            }
             i--;
+        }
         return NULL; //!< If the index is greater than the number of elements in the list.
+        return NULL; // If the index is greater than the number of elements in the list.
+    }
 …
         int i = index;
         //! Iterate through all QuestHints.
+        // Iterate through all QuestHints.
         for (std::list<QuestHint*>::const_iterator hint = this->hints_.begin(); hint != this->hints_.end(); ++hint)
+        {
+            if(i == 0) //!< We're counting down...
+            {
+            if(i == 0) // We're counting down...
                return *hint;
+            }
             i--;
+        }
         return NULL; //!< If the index is greater than the number of elements in the list.
+        return NULL; // If the index is greater than the number of elements in the list.
+    }
 …
         int i = index;
         //! Iterate through all fail QuestEffects.
+        // Iterate through all fail QuestEffects.
         for (std::list<QuestEffect*>::const_iterator effect = this->failEffects_.begin(); effect != this->failEffects_.end(); ++effect)
+        {
+            if(i == 0) //!< We're counting down...
+            {
+            if(i == 0) // We're counting down...
                return *effect;
+            }
             i--;
+        }
         return NULL; //!< If the index is greater than the number of elements in the list.
+        return NULL; // If the index is greater than the number of elements in the list.
+    }
 …
         int i = index;
         //! Iterate through all complete QuestEffects.
+        // Iterate through all complete QuestEffects.
         for (std::list<QuestEffect*>::const_iterator effect = this->completeEffects_.begin(); effect != this->completeEffects_.end(); ++effect)
+        {
+            if(i == 0) //!< We're counting down...
+            {
+            if(i == 0) // We're counting down...
                return *effect;
+            }
             i--;
+        }
         return NULL; //!< If the index is greater than the number of elements in the list.
+        return NULL; // If the index is greater than the number of elements in the list.
+    }
 …
     bool Quest::isActive(const PlayerInfo* player) const
+    {
         return this->getStatus(player) == QuestStatus::Active;
+    }
 …
     bool Quest::fail(PlayerInfo* player)
+    {
         QuestListener::advertiseStatusChange(this->listeners_, "fail"); //!< Tells the QuestListeners, that the status has changed to failed.
+        QuestListener::advertiseStatusChange(this->listeners_, "fail"); // Tells the QuestListeners, that the status has changed to failed.
         this->setStatus(player, QuestStatus::Failed);
 …
     bool Quest::complete(PlayerInfo* player)
+    {
         QuestListener::advertiseStatusChange(this->listeners_, "complete"); //!< Tells the QuestListeners, that the status has changed to completed.
+        QuestListener::advertiseStatusChange(this->listeners_, "complete"); // Tells the QuestListeners, that the status has changed to completed.
         this->setStatus(player, QuestStatus::Completed);
 …
     bool Quest::start(PlayerInfo* player)
+    {
         if(!this->isStartable(player)) //!< Checks whether the quest can be started.
+        if(!this->isStartable(player)) // Checks whether the quest can be started.
+        {
             COUT(4) << "A non-startable quest was trying to be started." << std::endl;
 …
         COUT(4) << "Quest {" << this->getId() << "} is started for player: " << player << " ." <<std::endl;
         QuestListener::advertiseStatusChange(this->listeners_, "start"); //!< Tells the QuestListeners, that the status has changed to active.
+        QuestListener::advertiseStatusChange(this->listeners_, "start"); // Tells the QuestListeners, that the status has changed to active.
         this->setStatus(player, QuestStatus::Active);
 …
     bool Quest::addListener(QuestListener* listener)
+    {
+        //TODO: Replace with assert?
         if(listener == NULL)
+        {

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

-                      r7163
+                      r7456
 /**
     @file
+    @file Quest.h
     @brief Definition of the Quest class.
+        The Quest is the parent class of LocalQuest and GlobalQuest.
+        The Quest class is the parent class of @ref orxonox::LocalQuest "LocalQuest" and @ref orxonox::GlobalQuest "GlobalQuest".
+    @ingroup Questsystem
 */
 …
     namespace QuestStatus
+    {
         //!Different states of a Quest.
+        //! Different states of a @ref orxonox::Quest "Quest".
         enum Value
+        {
 …
     /**
     @brief
+        Represents a Quest in the game.
+        A Quest has a list of subquests and a parentquest (if it is not a rootquest).
+        Represents a Quest in the game. A Quest is a task that the player can (or has to) fulfill upon which he will (possibly) receive some kind of reward.
+        A Quest can have a list of sub-quests and has a parent-quest (if it is not a root-quest).
         Each Quest exists only once but it has a different status (inactive, active, failed or completed) for each player.
         A Quest has several hints (QuestHint) that can be unlocked through QuestEffects and then display aid in solving the Quest.
         A Quest has a list of QuestEffects that are invoked when the quest is failed and also a list of QuestEffects that are invoked, when the Quest is completed.
+        A Quest can have several hints (QuestHint) that can be unlocked through @ref orxonox::QuestEffect "QuestEffects" and then display aid in solving the Quest.
+        A Quest can have a list of @ref orxonox::QuestEffect "QuestEffects" that are invoked when the quest is failed and also a list of @ref orxonox::QuestEffect "QuestEffects" that are invoked, when the Quest is completed.
         Quest itself should not be instantiated, if you want to create a quest either go for LocalQuest or GlobalQuest, whichever suits you needs better.
+        Quest itself should not be instantiated, if you want to create a quest either use LocalQuest or GlobalQuest, whichever suits you needs better.
     @author
         Damian 'Mozork' Frick
 …
             /**
             @brief Returns the parentquest of the Quest.
             @return Returns a pointer to the parentquest of the Quest.
+            @brief Returns the parent-quest of the Quest.
+            @return Returns a pointer to the parent-quest of the Quest.
             */
             inline Quest* getParentQuest(void) const
 …
             /**
             @brief Returns the list of subquests.
             @return Returns a reference to the list of subquests of the quest.
+            @brief Returns the list of sub-quests.
+            @return Returns a reference to the list of sub-quests of the quest.
             */
             inline const std::list<Quest*> & getSubQuestList(void) const
 …
             virtual bool isCompletable(const PlayerInfo* player) const = 0; //!< Checks whether the Quest can be completed.
             const Quest* getSubQuest(unsigned int index) const; //!<Returns the subquest at the given index.
+            const Quest* getSubQuest(unsigned int index) const; //!<Returns the sub-quest at the given index.
             const QuestHint* getHint(unsigned int index) const; //!< Returns the QuestHint at the given index.
             const QuestEffect* getFailEffect(unsigned int index) const; //!< Returns the fail QuestEffect at the given index.
 …
         private:
             Quest* parentQuest_; //!< Pointer to the parentquest.
             std::list<Quest*> subQuests_; //!< List of all the subquests.
+            Quest* parentQuest_; //!< Pointer to the parent-quest.
+            std::list<Quest*> subQuests_; //!< List of all the sub-quests.
             std::list<QuestHint*> hints_; //!< A list of all the QuestHints tied to this Quest.
 …
             std::list<QuestListener*> listeners_; //!< A list of QuestListeners, that listen to what exactly happens with this Quest.
             bool setParentQuest(Quest* quest); //!< Sets the parentquest of the Quest.
             bool addSubQuest(Quest* quest); //!< Adds a subquest to the Quest.
+            bool setParentQuest(Quest* quest); //!< Sets the parent-quest of the Quest.
+            bool addSubQuest(Quest* quest); //!< Adds a sub-quest to the Quest.
             bool addHint(QuestHint* hint); //!< Add a QuestHint to the list of QuestHints.
             bool addFailEffect(QuestEffect* effect); //!< Adds an QuestEffect to the list of fail QuestEffects.

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

-                      r7403
+                      r7456
 /**
     @file
+    @file QuestDescription.cc
     @brief Implementation of the QuestDescription class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "QuestNotification.h"
 …
         std::string message;
         if(item == "hint")
+        {
             message = "You received a hint: '" + this->title_ + '\'';
+        }
         else if(item == "quest")
+        {
             if(status == "start")
+            {
                 message = "You received a new quest: '" + this->title_ + '\'';
+            }
             else if(status == "fail")
+            {
                 message = "You failed the quest: '" + this->title_ + '\'';
+            }
             else if(status == "complete")
+            {
                 message = "You successfully completed the quest: '" + this->title_ + '\'';
+            }
             else
+            {

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

-                      r7403
+                      r7456
 /**
     @file
+    @file QuestDescription.h
     @brief Definition of the QuestDescription class.
+    @ingroup Questsystem
 */
 …
     /**
     @brief
         This class is a description of a QuestItem.
         It holds a title and a description.
+        This class is a description of a QuestItem (@ref orxonox::Quest "Quest" and @ref orxonox::QuestHint "QuestHint").
+        It holds a title and a description. For quests also messages that are sent, when failing or completing the quest can be added.
         Creating a QuestDescription through XML goes as follows:
         @code
         <QuestDescription title="Title" description="Description Text" failMessage="You fail." completeMessage="You win!" />

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

-                      r6417
+                      r7456
 /**
     @file
+    @file QuestEffect.cc
     @brief Implementation of the QuestEffect class.
 */
 …
         A list of all the QuestEffects to be invoked.
     @return
         Returns false if there was an error, view console of log for further detail.
+        Returns false if there was an error, view console or log for further details.
     */
     /*static*/ bool QuestEffect::invokeEffects(PlayerInfo* player, std::list<QuestEffect*> & effects)
 …
         for (std::list<QuestEffect*>::iterator effect = effects.begin(); effect != effects.end(); effect++)
+        {
             check = check && (*effect)->invoke(player);
+        }
         return check;
+    }

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

-                      r5781
+                      r7456
 /**
     @file
+    @file QuestEffect.h
     @brief Definition of the QuestEffect class.
+    @ingroup Questsystem
 */
 …
     /**
     @brief
         Handles QuestEffects for Quests.
         QuestEffects are the only way for Quests to have any sideeffects in the game world. They are also the only way for a player to gain, complete or fail Quests.
+        Handles QuestEffects for @ref orxonox::Quest "Quests".
+        QuestEffects are one of the ways for @ref orxonox::Quest "Quests" to have any side effects on the game world and for the game world to influence the @ref orxonox::Quest "Quests".
     @author
         Damian 'Mozork' Frick
 …
             static bool invokeEffects(PlayerInfo* player, std::list<QuestEffect*> & effects); //!< Invokes all QuestEffects in the list.
     };

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestEffectBeacon.cc
     @brief Implementation of the QuestEffectBeacon class.
 */
 …
 #include "core/XMLPort.h"
 #include "core/EventIncludes.h"
+#include "interfaces/PlayerTrigger.h"
 #include "worldentities/pawns/Pawn.h"
+#include "interfaces/PlayerTrigger.h"
 #include "objects/triggers/MultiTriggerContainer.h"
 #include "QuestEffect.h"
 …
         Constructor. Registers the object and initializes defaults.
     */
+    //TODO: Make just BaseObject?
     QuestEffectBeacon::QuestEffectBeacon(BaseObject* creator) : StaticEntity(creator)
+    {
 …
         Returns true if successfully executed, false if not.
     */
+    //TODO: Eliminate MultiTriggerContainer stuff, since they are now PlayerTriggers as well.
     bool QuestEffectBeacon::execute(bool bTriggered, BaseObject* trigger)
+    {
 …
             return false;
+        }
         if(!(this->isActive())) //!< If the QuestEffectBeacon is inactive it cannot be executed.
+        if(!(this->isActive())) // If the QuestEffectBeacon is inactive it cannot be executed.
+        {
             COUT(4) << "The QuestEffectBeacon is inactive." << std::endl;
 …
         Pawn* pawn = NULL;
         //! If the trigger is neither a Playertrigger nor a MultiTrigger (i.e. a MultitriggerContainer) we can do anything with it.
+        // If the trigger is neither a Playertrigger nor a MultiTrigger (i.e. a MultitriggerContainer) we can do anything with it.
         if(pTrigger == NULL && mTrigger == NULL)
             return false;
 …
         if(pTrigger != NULL)
+        {
             if(!pTrigger->isForPlayer())  //!< The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
+            if(!pTrigger->isForPlayer())  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
                 return false;
             else
 …
+        }
         //! Extract the PlayerInfo from the Pawn.
+        // Extract the PlayerInfo from the Pawn.
         PlayerInfo* player = pawn->getPlayer();
 …
         COUT(4) << "QuestEffectBeacon executed on player: " << player << " ." << std::endl;
         bool check = QuestEffect::invokeEffects(player, this->effects_); //!< Invoke the QuestEffects on the PlayerInfo.
+        bool check = QuestEffect::invokeEffects(player, this->effects_); // Invoke the QuestEffects on the PlayerInfo.
         if(check)
+        {
             this->decrementTimes(); //!< Decrement the number of times the beacon can be used.
+            this->decrementTimes(); // Decrement the number of times the beacon can be used.
             return true;
+        }
 …
     bool QuestEffectBeacon::setActive(bool activate)
+    {
+        if(this->getTimes() == 0 && activate) //!< A QuestEffectBeacon that can be executed only 0 times is always inactive.
+        {
+            return false;
+        }
+        if(this->getTimes() == 0 && activate) // A QuestEffectBeacon that can be executed only 0 times is always inactive.
+            return false;
         if(activate)
+        {
         this->status_ = QuestEffectBeaconStatus::Active;
         return true;
+            this->status_ = QuestEffectBeaconStatus::Active;
+            return true;
+        }
 …
     bool QuestEffectBeacon::decrementTimes(void)
+    {
+        if(!(this->isActive())) //!< The QuestEffectBeacon mus be active to decrement the number of times it can be executed.
+        {
+            return false;
+        }
+        if(this->getTimes() == INFINITE_TIME) //!< If times is infinity the QuestEffectBeacon can be executed an infinite number fo times.
+        {
+        if(!(this->isActive())) // The QuestEffectBeacon mus be active to decrement the number of times it can be executed.
+            return false;
+        if(this->getTimes() == INFINITE_TIME) // If times is infinity the QuestEffectBeacon can be executed an infinite number fo times.
             return true;
+        }
+        this->times_ = this->times_ - 1; //!< Decrement number of times the QuestEffectBeacon can be executed.
+        if(this->getTimes() == 0) //!< Set the QuestEffectBeacon to inactive when the number of times it can be executed is reduced to 0.
+        {
+        this->times_ = this->times_ - 1; // Decrement number of times the QuestEffectBeacon can be executed.
+        if(this->getTimes() == 0) // Set the QuestEffectBeacon to inactive when the number of times it can be executed is reduced to 0.
             this->status_ = QuestEffectBeaconStatus::Inactive;
+        }
         return true;
 …
+    {
         if(n < 0 && n != INFINITE_TIME)
+        {
+            return false;
+        }
+            return false;
         this->times_ = n;
 …
     bool QuestEffectBeacon::addEffect(QuestEffect* effect)
+    {
+        if(effect == NULL) //!< NULL-pointers are not well liked here...
+        //TODO: Replace with assert.
+        if(effect == NULL) // NULL-pointers are not well liked here...
+        {
             COUT(2) << "A NULL-QuestEffect was trying to be added" << std::endl;
 …
+        {
             if(i == 0)
+            {
                return *effect;
+            }
             i--;
+        }

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestEffectBeacon.h
     @brief Definition of the QuestEffectBeacon class.
+    @ingroup Questsystem
 */
 …
     namespace QuestEffectBeaconStatus
+    {
         //! The status of the beacon, can be either active or inactive.
+        //! The status of the @ref orxonox::QuestEffectBeacon "QuestEffectBeacon", can be either active or inactive.
         enum Value
+        {
 …
     /**
     @brief
         A QuestEffectBeacon is a physical entity in the game which can (under some condition(s)) invoke a number QuestEffects on players meeting the condition(s).
         The conditions under which the QuestEffects are invoked on the player are defined by Triggers.
+        A QuestEffectBeacon is a physical entity in the game which can (under some condition(s)) invoke a number of @ref orxonox::QuestEffect "QuestEffects" on players meeting the condition(s).
+        The conditions under which the @ref orxonox::QuestEffect "QuestEffects" are invoked on the player are defined by @ref orxonox::Trigger "Triggers" (or really any kind of entity firing events, e.g. @ref oroxnox::EventListener "EventListeners"). The trigger the event originates from, however has to be a @ref orxonox::PlayerTrigger PlayerTrigger.
         A QuestEffectBeacon can be executed a defined number of times.
         A QuestEffectBeacon can be inactive or active.
+        A QuestEffectBeacon can be inactive or active. While inactive it can't be executed.
         Creating a QuestEffectBeacon through XML goes as follows:
         @code
         <QuestEffectBeacon times=n> //Where 'n' is eighter a number >= 0, which means the QuestEffectBeacon can be executed n times. Or n = -1, which means the QuestEffectBeacon can be executed an infinite number of times.

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

-                      r7403
+                      r7456
 /**
     @file
+    @file QuestHint.cc
     @brief Implementation of the QuestHint class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "Quest.h"
+#include "QuestDescription.h"
 #include "QuestManager.h"
-#include "QuestDescription.h"
-#include "Quest.h"
 namespace orxonox
 …
         SUPER(QuestHint, XMLPort, xmlelement, mode);
         QuestManager::getInstance().registerHint(this); //!< Registers the QuestHint with the QuestManager.
+        QuestManager::getInstance().registerHint(this); // Registers the QuestHint with the QuestManager.
         COUT(4) << "New QuestHint {" << this->getId() << "} created." << std::endl;
 …
     bool QuestHint::isActive(const PlayerInfo* player) const
+    {
+        if(player == NULL) //!< NULL-Pointers are ugly!
+        //TODO: Replace with asser.
+        if(player == NULL) // NULL-Pointers are ugly!
+        {
             ThrowException(Argument, "The input PlayerInfo* is NULL.");
 …
+        }
         //! Find the player.
+        // Find the player.
         std::map<const PlayerInfo*, QuestHintStatus::Value>::const_iterator it = this->playerStatus_.find(player);
+        if (it != this->playerStatus_.end()) //!< If the player is in the map.
+        {
+        if (it != this->playerStatus_.end()) // If the player is in the map.
             return it->second;
+        }
         return QuestStatus::Inactive;
 …
     bool QuestHint::setActive(PlayerInfo* player)
+    {
         if(this->quest_->isActive(player)) //!< For a hint to get activated the quest must be active.
+        if(this->quest_->isActive(player)) // For a hint to get activated the quest must be active.
+        {
             if(!(this->isActive(player)))  //!< If the hint is already active, activation is pointless.
+            if(!(this->isActive(player)))  // If the hint is already active, activation is pointless.
+            {
                 this->playerStatus_[player] = QuestHintStatus::Active;
 …
     bool QuestHint::setQuest(Quest* quest)
+    {
+        if(quest == NULL) //!< NULL-Pointer. Again..?
+        //TODO: Replace with assert.
+        if(quest == NULL) // NULL-Pointer. Again..?
+        {
             COUT(2) << "The input Quest* is NULL." << std::endl;

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestHint.h
     @brief Definition of the QuestHint class.
+    @ingroup Questsystem
 */
 …
 namespace orxonox // tolua_export
 { // tolua_export
     namespace QuestHintStatus
+    {
         //! The state of the hint.
+        //! The state of the @ref orxonox::QuestHint "QuestHint".
         enum Value
+        {
 …
     /**
     @brief
         Represents a hint in the game towards completing a Quest.
         Consists of title and description (which is stored in a QuestDescription object) in textual form and must belong to a quest.
+        Represents a hint in the game that gives aid towards completing a @ref orxonox::Quest "Quest".
+        Consists of title and description (which is stored in a @ref orxonox::QuestDescription "QuestDescription" object) in textual form and must belong to a quest.
         A QuestHint has a defined status (inactive or active, where inactive is default) for each player, which means each a QuestHint exists only once for all players, it doesn't belong to a player, it just has different states for each of them.
         Creating a QuestHint through XML goes as follows:
         @code
         <QuestHint id="hintId">

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestItem.cc
     @brief Implementation of the QuestItem class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "QuestDescription.h"
 …
     void QuestItem::setId(const std::string & id)
+    {
         if(id.compare(BLANKSTRING) == 0) //!< Checks whether the id is a valid id.
+        if(id.compare(BLANKSTRING) == 0) // Checks whether the id is a valid id.
+        {
             COUT(2) << "Invalid id. QuestItem id {" << id << "} could not be set." << std::endl;

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestItem.h
     @brief Definition of the QuestItem class.
+        The QuestItem is the parent class of Quest and QuestHint.
+        The @ref orxonox::QuestItem "QuestItem" is the parent class of @ref orxonox::Quest "Quest" and @ref orxonox::QuestHint "QuestHint".
+    @ingroup Questsystem
 */
 …
     /**
     @brief
         Functions as a base class for quest classes such as Quest or QuestHint.
         Has a unique identifier and a description.
+        Functions as a base class for quest classes such as @ref orxonox::Quest "Quest" or @ref orxonox::QuestHint "QuestHint".
+        Has a unique identifier and a @ref orxonox::QuestDescription "QuestDescription".
     @author
         Damian 'Mozork' Frick

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

-                      r7163
+                      r7456
 /**
     @file
+    @file QuestListener.cc
     @brief Implementation of the QuestListener class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "Quest.h"
 #include "QuestManager.h"
 …
     CreateFactory(QuestListener);
+    //! Initialization of the static variables for the modes as strings.
+    /*static*/ const std::string QuestListener::ALL = "all";
+    /*static*/ const std::string QuestListener::START = "start";
+    /*static*/ const std::string QuestListener::FAIL = "fail";
+    /*static*/ const std::string QuestListener::COMPLETE = "complete";
     /**
     @brief
 …
         if(this->quest_ != NULL)
             this->quest_->addListener(this); //!< Adds the QuestListener to the Quests list of listeners.
+            this->quest_->addListener(this); // Adds the QuestListener to the Quests list of listeners.
         COUT(4) << "QuestListener created for quest: {" << this->quest_->getId() << "} with mode '" << this->getMode() << "'." << std::endl;
 …
     /* static */ void QuestListener::advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status)
+    {
         for (std::list<QuestListener*>::iterator it = listeners.begin(); it != listeners.end(); ++it) //!< Iterate through all QuestListeners
+        for (std::list<QuestListener*>::iterator it = listeners.begin(); it != listeners.end(); ++it) // Iterate through all QuestListeners
+        {
             QuestListener* listener = *it;
+            if(listener->getMode() == status || listener->getMode() == "all") //!< Check whether the status change affects the give QuestListener.
+            {
+            if(listener->getMode() == status || listener->getMode() == QuestListener::ALL) // Check whether the status change affects the give QuestListener.
                 listener->execute();
+            }
+        }
+    }
 …
     bool QuestListener::setQuestId(const std::string & id)
+    {
         this->quest_ = QuestManager::getInstance().findQuest(id); //!< Find the Quest corresponding to the given questId.
         if(this->quest_ == NULL) //!< If there is no such Quest.
+        this->quest_ = QuestManager::getInstance().findQuest(id); // Find the Quest corresponding to the given questId.
+        if(this->quest_ == NULL) // If there is no such Quest.
+        {
             ThrowException(Argument, "This is bad! The QuestListener has not found a Quest with a corresponding id..");
 …
     bool QuestListener::setMode(const std::string & mode)
+    {
+        if(mode == "all")
+        {
+        if(mode == QuestListener::ALL)
             this->mode_ = QuestListenerMode::All;
+        }
+        else if(mode == "start")
+        {
+        else if(mode == QuestListener::START)
             this->mode_ = QuestListenerMode::Start;
+        }
+        else if(mode == "fail")
+        {
+        else if(mode == QuestListener::FAIL)
             this->mode_ = QuestListenerMode::Fail;
+        }
+        else if(mode == "complete")
+        {
+        else if(mode == QuestListener::COMPLETE)
             this->mode_ = QuestListenerMode::Complete;
+        }
         else
+        {
             COUT(2) << "QuestListener with invalid mode '" << mode << "' created. Mode set to 'all'." << std::endl;
         this->mode_ = QuestListenerMode::All;
         return false;
+            this->mode_ = QuestListenerMode::All;
+            return false;
+        }
 …
         Get the mode of the QuestListener.
     @return
         Return the mode of the QuestListener. Can be eighter 'all', 'start', 'fail' or 'complete'.
+        Return the mode of the QuestListener. Can be either 'all', 'start', 'fail' or 'complete'.
     */
     std::string QuestListener::getMode(void)
+    {
+        if(this->mode_ == QuestListenerMode::All)
+        {
+            return "all";
+        }
+        else if(this->mode_ == QuestListenerMode::Start)
+        {
+            return "start";
+        }
+        else if(this->mode_ == QuestListenerMode::Fail)
+        {
+            return "fail";
+        }
+        else if(this->mode_ == QuestListenerMode::Complete)
+        {
+            return "complete";
+        }
+        else
+        {
+            COUT(1) << "An unforseen, never to happen, Error has occurred. This is impossible!" << std::endl;
+            return "";
+        switch(this->mode_)
+        {
+            case QuestListenerMode::All:
+                return QuestListener::ALL;
+            case QuestListenerMode::Start:
+                return QuestListener::START;
+            case QuestListenerMode::Fail:
+                return QuestListener::FAIL;
+            case QuestListenerMode::Complete:
+                return QuestListener::COMPLETE;
+            default: // This will never happen.
+                return QuestListener::ALL;
+        }
+    }

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

-                      r7401
+                      r7456
 /**
     @file
+    @file QuestListener.h
     @brief Definition of the QuestListener class.
+    @ingroup Questsystem
 */
 …
     namespace QuestListenerMode
+    {
         //! The mode of the QuestListener.
+        //! The mode of the @ref orxonox::QuestListener "QuestListener".
         enum Value
+        {
 …
     /**
     @brief
         Provides a way to react to the starting, completing and failing of Quests.
+        Provides a way to react to the starting, completing and failing of @ref orxonox::Quest "Quests".
         The XML representation goes as follows:
-        You can use the QuestListener as if it were a Trigger or EventListener, that fires an Event when the status (depending on the set mode) of the given Quest changes.
         @code
         <BaseObject> // The object that should react to the status change of a Quest.
 …
         </BaseObject>
         @endcode
+        You can use the QuestListener as if it were a @ref orxonox::Trigger "Trigger" or @ref orxonox::EventListener "EventListener", that fires an Event when the status (depending on the set mode) of the given @ref orxonox::Quest "Quest" changes.
     @author
     Damian 'Mozork' Frick
 …
     class _QuestsystemExport QuestListener : public BaseObject
+    {
-    public:
-        QuestListener(BaseObject* creator);
-        virtual ~QuestListener();
+        virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a QuestListener object through XML.
+        public:
+            QuestListener(BaseObject* creator);
+            virtual ~QuestListener();
         static void advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status); //!< Makes all QuestListener in the list aware that a certain status change has occured.
+            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode); //!< Method for creating a QuestListener object through XML.
+        bool setQuestId(const std::string & id); //!< Sets the questId of the Quest the QuestListener reacts to.
+        bool setMode(const std::string & mode); //!< Sets the mode of the QuestListener.
+            static void advertiseStatusChange(std::list<QuestListener*> & listeners, const std::string & status); //!< Makes all QuestListener in the list aware that a certain status change has occured.
+        std::string getMode(void); //!< Get the mode of the QuestListener.
+            bool setQuestId(const std::string & id); //!< Sets the questId of the Quest the QuestListener reacts to.
+            bool setMode(const std::string & mode); //!< Sets the mode of the QuestListener.
+        const std::string & getQuestId(void);
+        bool execute(void); //!< Executes the QuestListener, resp. fires an Event.
+            std::string getMode(void); //!< Get the mode of the QuestListener.
+    private:
+        QuestListenerMode::Value mode_; //!< The mode of the QuestListener.
+        Quest* quest_; //!< A pointer to the Quest the QuestListener is reacting to.
+            const std::string & getQuestId(void);
+            bool execute(void); //!< Executes the QuestListener, resp. fires an Event.
+        private:
+            QuestListenerMode::Value mode_; //!< The mode of the QuestListener.
+            Quest* quest_; //!< A pointer to the Quest the QuestListener is reacting to.
+            //! Static variables for the modes as strings.
+            static const std::string ALL;
+            static const std::string START;
+            static const std::string FAIL;
+            static const std::string COMPLETE;
     };

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

-                      r7284
+                      r7456
 /**
     @file
+    @file QuestManager.cc
     @brief Implementation of the QuestManager class.
 */
 …
 #include "QuestManager.h"
-#include <CEGUIWindow.h>
 #include "util/Exception.h"
 #include "util/ScopedSingletonManager.h"
+#include "core/command/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
 #include "core/GUIManager.h"
 #include "core/LuaState.h"
+#include "core/command/ConsoleCommand.h"
 #include "infos/PlayerInfo.h"
+#include "overlays/GUIOverlay.h"
+#include "ToluaBindQuestsystem.h"
 #include "Quest.h"
 #include "QuestHint.h"
 #include "QuestItem.h"
+#include "ToluaBindQuestsystem.h"
 namespace orxonox
 …
+    {
         RegisterRootObject(QuestManager);
+        COUT(3) << "QuestManager created." << std::endl;
+    }
 …
     QuestManager::~QuestManager()
+    {
+        COUT(3) << "QuestManager destroyed." << std::endl;
+    }
 …
     bool QuestManager::registerQuest(Quest* quest)
+    {
+        if(quest == NULL) //!< Doh! Just as if there were actual quests behind NULL-pointers.
+        //TODO: Replace with assert.
+        if(quest == NULL) // Doh! Just as if there were actual quests behind NULL-pointers.
+        {
             COUT(2) << "Registration of Quest in QuestManager failed, because inserted Quest-pointer was NULL." << std::endl;
 …
         std::pair<std::map<std::string, Quest*>::iterator,bool> result;
         result = this->questMap_.insert( std::pair<std::string,Quest*>(quest->getId(),quest) ); //!< Inserting the Quest.
         if(result.second) //!< If inserting was a success.
+        result = this->questMap_.insert( std::pair<std::string,Quest*>(quest->getId(),quest) ); // Inserting the Quest.
+        if(result.second) // If inserting was a success.
+        {
             quest->setRegistered();
 …
     bool QuestManager::registerHint(QuestHint* hint)
+    {
+        if(hint == NULL) //!< Still not liking NULL-pointers.
+        //TODO: Replace with assert.
+        if(hint == NULL) // Still not liking NULL-pointers.
+        {
             COUT(2) << "Registration of QuestHint in QuestManager failed, because inserted QuestHint-pointer was NULL." << std::endl;
 …
         std::pair<std::map<std::string, QuestHint*>::iterator,bool> result;
         result = this->hintMap_.insert ( std::pair<std::string,QuestHint*>(hint->getId(),hint) ); //!< Inserting the QuestHSint.
         if(result.second) //!< If inserting was a success.
+        result = this->hintMap_.insert ( std::pair<std::string,QuestHint*>(hint->getId(),hint) ); // Inserting the QuestHSint.
+        if(result.second) // If inserting was a success.
+        {
             hint->setRegistered();
 …
     Quest* QuestManager::findQuest(const std::string & questId)
+    {
+        if(questId.compare(BLANKSTRING) == 1) //!< Check vor validity of the given id.
+        {
+        if(questId.compare(BLANKSTRING) == 1) // Check vor validity of the given id.
             ThrowException(Argument, "Invalid questId.");
+        }
         Quest* quest;
         std::map<std::string, Quest*>::iterator it = this->questMap_.find(questId);
+        if (it != this->questMap_.end()) //!< If the Quest is registered.
+        {
+        if (it != this->questMap_.end()) // If the Quest is registered.
             quest = it->second;
+        }
         else
+        {
 …
         return quest;
+    }
 …
     QuestHint* QuestManager::findHint(const std::string & hintId)
+    {
+        if(hintId.compare(BLANKSTRING) == 1) //!< Check vor validity of the given id.
+        {
+        if(hintId.compare(BLANKSTRING) == 1) // Check vor validity of the given id.
             ThrowException(Argument, "Invalid hintId.");
+        }
         QuestHint* hint;
         std::map<std::string, QuestHint*>::iterator it = this->hintMap_.find(hintId);
+        if (it != this->hintMap_.end()) //!< If the QuestHint is registered.
+        {
+        if (it != this->hintMap_.end()) // If the QuestHint is registered.
             hint = it->second;
+        }
         else
+        {
 …
         return hint;
+    }
+    int QuestManager::getNumParentQuests(PlayerInfo* player)
+    }
+    /**
+    @brief
+        Get the number of Quests the input player has, that are root quests.
+    @param player
+        The player.
+    @return
+        Returns the number of Quests the input player has, that are root quests.
+    */
+    int QuestManager::getNumRootQuests(PlayerInfo* player)
+    {
         int numQuests = 0;
 …
+    }
+    Quest* QuestManager::getParentQuest(PlayerInfo* player, int index)
+    /**
+    @brief
+        Get the index-th root quest of the input player.
+    @param player
+        The player.
+    @param index
+        The index of the root quest.
+    @return
+        Returns the index-th root quest of the input player.
+    */
+    Quest* QuestManager::getRootQuest(PlayerInfo* player, int index)
+    {
         for(std::map<std::string, Quest*>::iterator it = this->questMap_.begin(); it != this->questMap_.end(); it++)
 …
+    }
+    /**
+    @brief
+        Get the number of sub-quest of an input Quest for the input player.
+    @param quest
+        The quest to get the sub-quests of.
+    @param player
+        The player.
+    @return
+        Returns the number of sub-quest of an input Quest for the input player.
+    */
     int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
+    {
 …
+    }
+    /**
+    @brief
+        Get the index-th sub-quest of the input Quest for the input player.
+    @param quest
+        The Quest to get the sub-quest of.
+    @param player
+        The player.
+    @param index
+        The index of the sub-quest.
+    */
     Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
+    {
 …
+    }
+    /**
+    @brief
+        Get the number of QuestHints of the input Quest for the input player.
+    @param quest
+        The quest to get the hints of.
+    @param player
+        The player.
+    @return Returns the number of QuestHints of the input Quest for the input player.
+    */
     int QuestManager::getNumHints(Quest* quest, PlayerInfo* player)
+    {
 …
+    }
+    /**
+    @brief
+        Get the index-th QuestHint of the input Quest for the input player.
+    @param quest
+        The Quest to get the QuestHint of.
+    @param player
+        The player.
+    @param index
+        The index of the QuestHint.
+    */
     QuestHint* QuestManager::getHints(Quest* quest, PlayerInfo* player, int index)
+    {
 …
+    }
+    /**
+    @brief
+        Get the QuestDescription of the input Quest.
+    @param item
+        The Quest to get the QuestDescription of.
+    @return
+        Return a pointer ot the QuestDescription of the input Quest.
+    */
     QuestDescription* QuestManager::getDescription(Quest* item)
+    {
 …
+    }
+    /**
+    @brief
+        Get the QuestDescription of the input QuestHint.
+    @param item
+        The QuestHint to get the QuestDescription of.
+    @return
+        Returns a pointer to the QuestDescription of the input QuestHint.
+    */
     QuestDescription* QuestManager::getDescription(QuestHint* item)
+    {

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

-                      r7163
+                      r7456
 /**
     @file
+    @file QuestManager.h
     @brief Definition of the QuestManager class.
+    @ingroup Questsystem
 */
 …
 #include "core/OrxonoxClass.h"
+// tolua_begin
+namespace orxonox
+{
+namespace orxonox  // tolua_export
+{  // tolua_export
     /**
     @brief
         Is a Singleton and manages Quests, by registering every Quest/QuestHint (through registerX()) and making them globally accessible (through findX()).
         Quests (and QuestHints) are registered in the QuestManager with their id, and can be accessed in the same way.
+        Is a Singleton and manages @ref orxonox::Quest "Quests", by registering every @ref orxonox::Quest "Quest" / @ref orxonox::QuestHint "QuestHint" (through registerX()) and making them globally accessible (through findX()).
+        @ref orxonox::Quest "Quests" (and @ref orxonox::QuestHint 2) are registered in the QuestManager with their id, and can be accessed in the same way.
     @author
         Damian 'Mozork' Frick
     */
+    class _QuestsystemExport QuestManager
+// tolua_end
+    class _QuestsystemExport QuestManager  // tolua_export
         : public Singleton<QuestManager>, public orxonox::OrxonoxClass
     { // tolua_export
 …
             virtual ~QuestManager();
             //! Returns a reference to the single instance of the Quest Manager.
+            //! Returns a reference to the single instance of the QuestManager.
             static QuestManager& getInstance() { return Singleton<QuestManager>::getInstance(); } // tolua_export
             // tolua_begin
             int getNumParentQuests(orxonox::PlayerInfo* player);
             Quest* getParentQuest(orxonox::PlayerInfo* player, int index);
+            int getNumRootQuests(orxonox::PlayerInfo* player); //!< Get the number of Quests the input player has, that are root quests.
+            Quest* getRootQuest(orxonox::PlayerInfo* player, int index); //!< Get the index-th root quest of the input player.
             int getNumSubQuests(Quest* quest, orxonox::PlayerInfo* player);
             Quest* getSubQuest(Quest* quest, orxonox::PlayerInfo* player, int index);
+            int getNumSubQuests(Quest* quest, orxonox::PlayerInfo* player); //!< Get the number of sub-quest of an input Quest for an input player.
+            Quest* getSubQuest(Quest* quest, orxonox::PlayerInfo* player, int index); //!< Get the index-th sub-quest of the input Quest for the input player.
             int getNumHints(Quest* quest, orxonox::PlayerInfo* player);
             QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index);
+            int getNumHints(Quest* quest, orxonox::PlayerInfo* player); //!< Get the number of QuestHints of the input Quest for the input player.
+            QuestHint* getHints(Quest* quest, orxonox::PlayerInfo* player, int index); //!< Get the index-th QuestHint of the input Quest for the input player.
             QuestDescription* getDescription(Quest* item);

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

-                      r7403
+                      r7456
+ *
  */
+/**
+    @file QuestNotification.cc
+    @brief Implementation of the QuestNotification class.
+*/
 #include "QuestNotification.h"

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

-                      r7403
+                      r7456
+ *
  */
+/**
+    @file QuestNotification.h
+    @brief Definition of the QuestNotification class.
+    @ingroup Questsystem
+*/
 #ifndef _QuestNotification_H__

code/trunk/src/modules/questsystem/effects/AddQuest.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file AddQuest.cc
     @brief Implementation of the AddQuest class.
 */
 …
 #include "AddQuest.h"
+#include "core/CoreIncludes.h"
+#include "core/XMLPort.h"
 #include "util/Exception.h"
+#include "core/CoreIncludes.h"
+#include "questsystem/Quest.h"
 #include "questsystem/QuestManager.h"
-#include "questsystem/Quest.h"
 namespace orxonox
 …
     bool AddQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< Null-pointers are badass.
+        //TODO: Replace with assert?
+        if(player == NULL) // Null-pointers are badass.
+        {
             COUT(2) << "Input player is NULL." << std::endl;
 …
             Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->start(player))
+            {
                return false;
+            }
+        }
         catch(const orxonox::Exception& ex)

code/trunk/src/modules/questsystem/effects/AddQuest.h

-                      r7401
+                      r7456
 /**
     @file
+    @file AddQuest.h
     @brief Definition of the AddQuest class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         Adds a Quest, resp. changes the quests status to active for the player invoking the Quest.
+        Adds a @ref orxonox::Quest "Quest", resp. changes the @ref orxonox::Quest "Quests" status to active for the player invoking the @ref orxonox::Quest "Quest".
+        Creating a AddQuest through XML goes as follows:
+        Creating an AddQuest through XML goes as follows:
         @code
         <AddQuest questId="id" />  //Where id identifies the Quest that should be added.

code/trunk/src/modules/questsystem/effects/AddQuestHint.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file AddQuestHint.cc
     @brief Implementation of the AddQuestHint class.
 */
 …
 #include "AddQuestHint.h"
-#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "util/Exception.h"
+#include "questsystem/QuestHint.h"
 #include "questsystem/QuestManager.h"
 #include "questsystem/QuestItem.h"
-#include "questsystem/QuestHint.h"
 namespace orxonox
 …
     bool AddQuestHint::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< NULL-pointers are evil!
+        //TODO: Replace with assert?
+        if(player == NULL) // NULL-pointers are evil!
+        {
             COUT(2) << "The input player is NULL." << std::endl;
 …
             QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
             if(hint == NULL || !hint->setActive(player))
+            {
                 return false;
+            }
+        }
         catch(const Exception& e)

code/trunk/src/modules/questsystem/effects/AddQuestHint.h

-                      r7401
+                      r7456
 /**
     @file
+    @file AddQuestHint.h
     @brief Definition of the AddQuestHint class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         Adds a QuestHint, resp. activates the QuestHint of the given id for the player the QuestEffect is invoked on.
+        Adds a @ref orxonox::QuestHint "QuestHint", resp. activates the @ref orxonox::QuestHint "QuestHint" of the given id for the player the QuestEffect is invoked on.
         Creating a AddQuestHint through XML goes as follows:
         @code
         <AddQuestHint hintId="id" />  //Where id identifies the QuestHint that should be added.

code/trunk/src/modules/questsystem/effects/AddReward.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file AddReward.cc
     @brief Implementation of the AddReward class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "interfaces/Rewardable.h"
 …
     AddReward::~AddReward()
+    {
+    }
 …
+        {
             if(i == 0)
+            {
                return *reward;
+            }
             i--;
+        }
 …
         bool check = true;
         for ( std::list<Rewardable*>::iterator reward = this->rewards_.begin(); reward != this->rewards_.end(); ++reward )
+        {
             check = check && (*reward)->reward(player);
+        }
         COUT(4) << "Rewardable successfully added to player." << player << " ." << std::endl;

code/trunk/src/modules/questsystem/effects/AddReward.h

-                      r7401
+                      r7456
 /**
     @file
+    @file AddReward.h
     @brief Definition of the AddReward class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         Adds a list of Rewardables to a player.
+        Adds a list of @ref orxonox::Rewardable "Rewardables" to a player.
         Creating a AddReward through XML goes as follows:
         @code
         <AddReward>

code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file ChangeQuestStatus.cc
     @brief Implementation of the ChangeQuestStatus class.
+    @ingroup QuestEffects
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 #include "questsystem/QuestItem.h"
 …
     ChangeQuestStatus::~ChangeQuestStatus()
+    {
+    }

code/trunk/src/modules/questsystem/effects/ChangeQuestStatus.h

-                      r7401
+                      r7456
 /**
     @file
+    @file ChangeQuestStatus.h
     @brief Definition of the ChangeQuestStatus class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         A QuestEffect which changes the status of a specified Quest for the player invoking the QuestEffect.
+        A QuestEffect which changes the status of a specified @ref orxonox::Quest "Quest" for the player invoking the QuestEffect.
     @author
         Damian 'Mozork' Frick

code/trunk/src/modules/questsystem/effects/CompleteQuest.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file CompleteQuest.cc
     @brief Implementation of the CompleteQuest class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "questsystem/Quest.h"
 #include "questsystem/QuestManager.h"
-#include "questsystem/Quest.h"
 namespace orxonox
 …
     CompleteQuest::~CompleteQuest()
+    {
+    }
 …
     bool CompleteQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< You know, what we think of NULL-pointers...
+        //TODO: Replace with assert?
+        if(player == NULL) // You know, what we think of NULL-pointers...
+        {
             COUT(2) << "Input player is NULL." << std::endl;
 …
             quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->complete(player))
+            {
                return false;
+            }
+        }
         catch(const Exception& e)

code/trunk/src/modules/questsystem/effects/CompleteQuest.h

-                      r7401
+                      r7456
 /**
     @file
+    @file CompleteQuest.h
     @brief Definition of the CompleteQuest class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         Completes a Quest (with a specified id) for the player invoking the QuestEffect.
+        Completes a @ref orxonox::Quest "Quest" (with a specified id) for the player invoking the QuestEffect.
         Creating a CompleteQuest through XML goes as follows:
         @code
         <CompleteQuest questId="id" />  //Where id identifies the Quest that should be completed.

code/trunk/src/modules/questsystem/effects/FailQuest.cc

-                      r7401
+                      r7456
 /**
     @file
+    @file FailQuest.cc
     @brief Implementation of the FailQuest class.
 */
 …
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
+#include "questsystem/Quest.h"
 #include "questsystem/QuestManager.h"
-#include "questsystem/Quest.h"
 namespace orxonox
 …
     FailQuest::~FailQuest()
+    {
+    }
 …
         SUPER(FailQuest, XMLPort, xmlelement, mode);
         COUT(4) << "New FailQUest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+        COUT(4) << "New FailQuest, with target Quest {" << this->getQuestId() << "}, created." << std::endl;
+    }
 …
     bool FailQuest::invoke(PlayerInfo* player)
+    {
+        if(player == NULL) //!< We don't know what to do with no player.
+        //TODO: Replace with assert?
+        if(player == NULL) // We don't know what to do with no player.
+        {
             COUT(2) << "Input player is NULL." << std::endl;
 …
             quest = QuestManager::getInstance().findQuest(this->getQuestId());
             if(quest == NULL || !quest->fail(player))
+            {
                return false;
+            }
+        }
         catch(const Exception& e)

code/trunk/src/modules/questsystem/effects/FailQuest.h

-                      r7401
+                      r7456
 /**
     @file
+    @file FailQuest.h
     @brief Definition of the FailQuest class.
+    @ingroup QuestEffects
 */
 …
     /**
     @brief
         Fails a quest (with a specified id) for the player invoking the QuestEffect.
+        Fails a @ref orxonox::Quest "Quest" (with a specified id) for the player invoking the QuestEffect.
         Creating a FailQuest through XML goes as follows:
         @code
         <FailQuest questId="id" />  //Where id identifies the Quest that should be failed.

code/trunk/src/orxonox/interfaces/PickupCarrier.h

r7163	r7456
30	30	@file PickupCarrier.h
31	31	@brief Definition of the PickupCarrier class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/orxonox/interfaces/Pickupable.h

r7401	r7456
30	30	@file Pickupable.h
31	31	@brief Definition of the Pickupable class.
	32	@ingroup Pickup
32	33	*/
33	34

code/trunk/src/orxonox/pickup/PickupIdentifier.h

r7163	r7456
30	30	@file PickupIdentifier.h
31	31	@brief Definition of the PickupIdentifier class.
	32	@ingroup Pickup
32	33	*/
33	34

Context Navigation

Legend:

Download in other formats: